RSACryptoServiceProvider Klasse

Definition

Führt eine asymmetrische Ver- und Entschlüsselung mithilfe der Implementierung des RSA-Algorithmus aus, der vom Kryptografiedienstanbieter (CSP) bereitgestellt wird.Performs asymmetric encryption and decryption using the implementation of the RSA algorithm provided by the cryptographic service provider (CSP). Diese Klasse kann nicht vererbt werden.This class cannot be inherited.

public ref class RSACryptoServiceProvider sealed : System::Security::Cryptography::RSA, System::Security::Cryptography::ICspAsymmetricAlgorithm
public ref class RSACryptoServiceProvider sealed : System::Security::Cryptography::RSA
public sealed class RSACryptoServiceProvider : System.Security.Cryptography.RSA, System.Security.Cryptography.ICspAsymmetricAlgorithm
public sealed class RSACryptoServiceProvider : System.Security.Cryptography.RSA
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class RSACryptoServiceProvider : System.Security.Cryptography.RSA, System.Security.Cryptography.ICspAsymmetricAlgorithm
type RSACryptoServiceProvider = class
    inherit RSA
    interface ICspAsymmetricAlgorithm
type RSACryptoServiceProvider = class
    inherit RSA
Public NotInheritable Class RSACryptoServiceProvider
Inherits RSA
Implements ICspAsymmetricAlgorithm
Public NotInheritable Class RSACryptoServiceProvider
Inherits RSA
Vererbung
RSACryptoServiceProvider
Attribute
Implementiert

Beispiele

Im folgenden Codebeispiel wird die RSACryptoServiceProvider-Klasse verwendet, um eine Zeichenfolge in ein Bytearray zu verschlüsseln, und anschließend werden die Bytes wieder in eine Zeichenfolge entschlüsselt.The following code example uses the RSACryptoServiceProvider class to encrypt a string into an array of bytes and then decrypt the bytes back into a string.

using namespace System;
using namespace System::Security::Cryptography;
using namespace System::Text;
array<Byte>^ RSAEncrypt( array<Byte>^DataToEncrypt, RSAParameters RSAKeyInfo, bool DoOAEPPadding )
{
   try
   {
      
      //Create a new instance of RSACryptoServiceProvider.
      RSACryptoServiceProvider^ RSA = gcnew RSACryptoServiceProvider;
      
      //Import the RSA Key information. This only needs
      //toinclude the public key information.
      RSA->ImportParameters( RSAKeyInfo );
      
      //Encrypt the passed byte array and specify OAEP padding.  
      //OAEP padding is only available on Microsoft Windows XP or
      //later.  

      array<Byte>^encryptedData = RSA->Encrypt( DataToEncrypt, DoOAEPPadding );
      delete RSA;
      return encryptedData;
   }
   //Catch and display a CryptographicException  
   //to the console.
   catch ( CryptographicException^ e ) 
   {
      Console::WriteLine( e->Message );
      return nullptr;
   }

}

array<Byte>^ RSADecrypt( array<Byte>^DataToDecrypt, RSAParameters RSAKeyInfo, bool DoOAEPPadding )
{
   try
   {
      
      //Create a new instance of RSACryptoServiceProvider.
      RSACryptoServiceProvider^ RSA = gcnew RSACryptoServiceProvider;
      
      //Import the RSA Key information. This needs
      //to include the private key information.
      RSA->ImportParameters( RSAKeyInfo );
      
      //Decrypt the passed byte array and specify OAEP padding.  
      //OAEP padding is only available on Microsoft Windows XP or
      //later.  
      
      array<Byte>^decryptedData = RSA->Decrypt( DataToDecrypt, DoOAEPPadding );
      delete RSA;
      return decryptedData;
   }
   //Catch and display a CryptographicException  
   //to the console.
   catch ( CryptographicException^ e ) 
   {
      Console::WriteLine( e );
      return nullptr;
   }

}

int main()
{
   try
   {
      
      //Create a UnicodeEncoder to convert between byte array and string.
      UnicodeEncoding^ ByteConverter = gcnew UnicodeEncoding;
      
      //Create byte arrays to hold original, encrypted, and decrypted data.
      array<Byte>^dataToEncrypt = ByteConverter->GetBytes( "Data to Encrypt" );
      array<Byte>^encryptedData;
      array<Byte>^decryptedData;
      
      //Create a new instance of RSACryptoServiceProvider to generate
      //public and private key data.
      RSACryptoServiceProvider^ RSA = gcnew RSACryptoServiceProvider;
      
      //Pass the data to ENCRYPT, the public key information 
      //(using RSACryptoServiceProvider.ExportParameters(false),
      //and a boolean flag specifying no OAEP padding.
      encryptedData = RSAEncrypt( dataToEncrypt, RSA->ExportParameters( false ), false );
      
      //Pass the data to DECRYPT, the private key information 
      //(using RSACryptoServiceProvider.ExportParameters(true),
      //and a boolean flag specifying no OAEP padding.
      decryptedData = RSADecrypt( encryptedData, RSA->ExportParameters( true ), false );
      
      //Display the decrypted plaintext to the console. 
      Console::WriteLine( "Decrypted plaintext: {0}", ByteConverter->GetString( decryptedData ) );
      delete RSA;
   }
   catch ( ArgumentNullException^ ) 
   {
      
      //Catch this exception in case the encryption did
      //not succeed.
      Console::WriteLine( "Encryption failed." );
   }

}

using System;
using System.Security.Cryptography;
using System.Text;

class RSACSPSample
{

    static void Main()
    {
        try
        {
            //Create a UnicodeEncoder to convert between byte array and string.
            UnicodeEncoding ByteConverter = new UnicodeEncoding();

            //Create byte arrays to hold original, encrypted, and decrypted data.
            byte[] dataToEncrypt = ByteConverter.GetBytes("Data to Encrypt");
            byte[] encryptedData;
            byte[] decryptedData;

            //Create a new instance of RSACryptoServiceProvider to generate
            //public and private key data.
            using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
            {

                //Pass the data to ENCRYPT, the public key information 
                //(using RSACryptoServiceProvider.ExportParameters(false),
                //and a boolean flag specifying no OAEP padding.
                encryptedData = RSAEncrypt(dataToEncrypt, RSA.ExportParameters(false), false);

                //Pass the data to DECRYPT, the private key information 
                //(using RSACryptoServiceProvider.ExportParameters(true),
                //and a boolean flag specifying no OAEP padding.
                decryptedData = RSADecrypt(encryptedData, RSA.ExportParameters(true), false);

                //Display the decrypted plaintext to the console. 
                Console.WriteLine("Decrypted plaintext: {0}", ByteConverter.GetString(decryptedData));
            }
        }
        catch (ArgumentNullException)
        {
            //Catch this exception in case the encryption did
            //not succeed.
            Console.WriteLine("Encryption failed.");
        }
    }

    public static byte[] RSAEncrypt(byte[] DataToEncrypt, RSAParameters RSAKeyInfo, bool DoOAEPPadding)
    {
        try
        {
            byte[] encryptedData;
            //Create a new instance of RSACryptoServiceProvider.
            using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
            {

                //Import the RSA Key information. This only needs
                //toinclude the public key information.
                RSA.ImportParameters(RSAKeyInfo);

                //Encrypt the passed byte array and specify OAEP padding.  
                //OAEP padding is only available on Microsoft Windows XP or
                //later.  
                encryptedData = RSA.Encrypt(DataToEncrypt, DoOAEPPadding);
            }
            return encryptedData;
        }
        //Catch and display a CryptographicException  
        //to the console.
        catch (CryptographicException e)
        {
            Console.WriteLine(e.Message);

            return null;
        }
    }

    public static byte[] RSADecrypt(byte[] DataToDecrypt, RSAParameters RSAKeyInfo, bool DoOAEPPadding)
    {
        try
        {
            byte[] decryptedData;
            //Create a new instance of RSACryptoServiceProvider.
            using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
            {
                //Import the RSA Key information. This needs
                //to include the private key information.
                RSA.ImportParameters(RSAKeyInfo);

                //Decrypt the passed byte array and specify OAEP padding.  
                //OAEP padding is only available on Microsoft Windows XP or
                //later.  
                decryptedData = RSA.Decrypt(DataToDecrypt, DoOAEPPadding);
            }
            return decryptedData;
        }
        //Catch and display a CryptographicException  
        //to the console.
        catch (CryptographicException e)
        {
            Console.WriteLine(e.ToString());

            return null;
        }
    }
}
Imports System.Security.Cryptography
Imports System.Text

 _

Class RSACSPSample


    Shared Sub Main()
        Try
            'Create a UnicodeEncoder to convert between byte array and string.
            Dim ByteConverter As New UnicodeEncoding()

            'Create byte arrays to hold original, encrypted, and decrypted data.
            Dim dataToEncrypt As Byte() = ByteConverter.GetBytes("Data to Encrypt")
            Dim encryptedData() As Byte
            Dim decryptedData() As Byte

            'Create a new instance of RSACryptoServiceProvider to generate
            'public and private key data.
            Using RSA As New RSACryptoServiceProvider

                'Pass the data to ENCRYPT, the public key information 
                '(using RSACryptoServiceProvider.ExportParameters(false),
                'and a boolean flag specifying no OAEP padding.
                encryptedData = RSAEncrypt(dataToEncrypt, RSA.ExportParameters(False), False)

                'Pass the data to DECRYPT, the private key information 
                '(using RSACryptoServiceProvider.ExportParameters(true),
                'and a boolean flag specifying no OAEP padding.
                decryptedData = RSADecrypt(encryptedData, RSA.ExportParameters(True), False)

                'Display the decrypted plaintext to the console. 
                Console.WriteLine("Decrypted plaintext: {0}", ByteConverter.GetString(decryptedData))
            End Using
        Catch e As ArgumentNullException
            'Catch this exception in case the encryption did
            'not succeed.
            Console.WriteLine("Encryption failed.")
        End Try
    End Sub


    Public Shared Function RSAEncrypt(ByVal DataToEncrypt() As Byte, ByVal RSAKeyInfo As RSAParameters, ByVal DoOAEPPadding As Boolean) As Byte()
        Try
            Dim encryptedData() As Byte
            'Create a new instance of RSACryptoServiceProvider.
            Using RSA As New RSACryptoServiceProvider

                'Import the RSA Key information. This only needs
                'toinclude the public key information.
                RSA.ImportParameters(RSAKeyInfo)

                'Encrypt the passed byte array and specify OAEP padding.  
                'OAEP padding is only available on Microsoft Windows XP or
                'later.  
                encryptedData = RSA.Encrypt(DataToEncrypt, DoOAEPPadding)
            End Using
            Return encryptedData
            'Catch and display a CryptographicException  
            'to the console.
        Catch e As CryptographicException
            Console.WriteLine(e.Message)

            Return Nothing
        End Try
    End Function


    Public Shared Function RSADecrypt(ByVal DataToDecrypt() As Byte, ByVal RSAKeyInfo As RSAParameters, ByVal DoOAEPPadding As Boolean) As Byte()
        Try
            Dim decryptedData() As Byte
            'Create a new instance of RSACryptoServiceProvider.
            Using RSA As New RSACryptoServiceProvider
                'Import the RSA Key information. This needs
                'to include the private key information.
                RSA.ImportParameters(RSAKeyInfo)

                'Decrypt the passed byte array and specify OAEP padding.  
                'OAEP padding is only available on Microsoft Windows XP or
                'later.  
                decryptedData = RSA.Decrypt(DataToDecrypt, DoOAEPPadding)
                'Catch and display a CryptographicException  
                'to the console.
            End Using
            Return decryptedData
        Catch e As CryptographicException
            Console.WriteLine(e.ToString())

            Return Nothing
        End Try
    End Function
End Class

Im folgenden Codebeispiel werden die Schlüsselinformationen, die mit dem RSACryptoServiceProvider erstellt wurden, in ein RSAParameters Objekt exportiert.The following code example exports the key information created using the RSACryptoServiceProvider into an RSAParameters object.

try
{
   //Create a new RSACryptoServiceProvider Object*.
   RSACryptoServiceProvider^ RSA = gcnew RSACryptoServiceProvider;
   
   //Export the key information to an RSAParameters object.
   //Pass false to export the public key information or pass
   //true to export public and private key information.
   RSAParameters RSAParams = RSA->ExportParameters( false );
}
catch ( CryptographicException^ e ) 
{
   //Catch this exception in case the encryption did
   //not succeed.
   Console::WriteLine( e->Message );
}
try
{
    //Create a new RSACryptoServiceProvider object.
    using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
    {

        //Export the key information to an RSAParameters object.
        //Pass false to export the public key information or pass
        //true to export public and private key information.
        RSAParameters RSAParams = RSA.ExportParameters(false);
    }
}
catch (CryptographicException e)
{
    //Catch this exception in case the encryption did
    //not succeed.
    Console.WriteLine(e.Message);
}
Try

    'Create a new RSACryptoServiceProvider object. 
    Dim RSA As New RSACryptoServiceProvider()

    'Export the key information to an RSAParameters object.
    'Pass false to export the public key information or pass
    'true to export public and private key information.
    Dim RSAParams As RSAParameters = RSA.ExportParameters(False)


Catch e As CryptographicException
    'Catch this exception in case the encryption did
    'not succeed.
    Console.WriteLine(e.Message)
End Try

Hinweise

Dies ist die Standard Implementierung von RSA.This is the default implementation of RSA.

Der RSACryptoServiceProvider unterstützt Schlüsselgrößen von 384 Bits bis 16384 Bits in Schritten von 8 Bits, wenn der Microsoft Enhanced Cryptographic Provider installiert ist.The RSACryptoServiceProvider supports key sizes from 384 bits to 16384 bits in increments of 8 bits if you have the Microsoft Enhanced Cryptographic Provider installed. Wenn der Microsoft Base Cryptographic Provider installiert ist, werden Schlüsselgrößen von 384 Bits bis 512 Bits in Schritten von 8 Bits unterstützt.It supports key sizes from 384 bits to 512 bits in increments of 8 bits if you have the Microsoft Base Cryptographic Provider installed.

Gültige Schlüsselgrößen sind abhängig vom Kryptografiedienstanbieter (kryptografischen Service Provider, CSP), der von der RSACryptoServiceProvider Instanz verwendet wird.Valid key sizes are dependent on the cryptographic service provider (CSP) that is used by the RSACryptoServiceProvider instance. Windows-CSPs aktivieren Schlüsselgrößen von 384 bis 16384 Bits für Windows-Versionen vor Windows 8.1Windows 8.1und Schlüsselgrößen von 512 bis 16384 Bits für Windows 8.1Windows 8.1.Windows CSPs enable keys sizes of 384 to 16384 bits for Windows versions prior to Windows 8.1Windows 8.1, and key sizes of 512 to 16384 bits for Windows 8.1Windows 8.1. Weitere Informationen finden Sie unter CryptGenKey -Funktion in der Windows-Dokumentation.For more information, see CryptGenKey function in the Windows documentation.

Interoperation mit der Microsoft Cryptographic API (CAPI)Interoperation with the Microsoft Cryptographic API (CAPI)

Anders als bei der RSA-Implementierung in nicht verwaltetem CAPI kehrt die RSACryptoServiceProvider-Klasse die Reihenfolge eines verschlüsselten Bytearrays nach der Verschlüsselung und vor der Entschlüsselung um.Unlike the RSA implementation in unmanaged CAPI, the RSACryptoServiceProvider class reverses the order of an encrypted array of bytes after encryption and before decryption. Standardmäßig können von der RSACryptoServiceProvider-Klasse verschlüsselte Daten nicht von der CAPI CryptDecrypt-Funktion entschlüsselt werden, und von der CAPI-CryptEncrypt-Methode verschlüsselte Daten können von der RSACryptoServiceProvider-Klasse nicht entschlüsselt werden.By default, data encrypted by the RSACryptoServiceProvider class cannot be decrypted by the CAPI CryptDecrypt function and data encrypted by the CAPI CryptEncrypt method cannot be decrypted by the RSACryptoServiceProvider class.

Wenn Sie die umgekehrte Reihenfolge bei der Interaktion zwischen APIs nicht kompensieren, löst die RSACryptoServiceProvider Klasse eine CryptographicExceptionaus.If you do not compensate for the reverse ordering when interoperating between APIs, the RSACryptoServiceProvider class throws a CryptographicException.

Um mit CAPI zusammenarbeiten zu können, müssen Sie die Reihenfolge verschlüsselter Bytes manuell umkehren, bevor die verschlüsselten Daten mit einer anderen API interagieren.To interoperate with CAPI, you must manually reverse the order of encrypted bytes before the encrypted data interoperates with another API. Sie können die Reihenfolge eines verwalteten Bytearrays problemlos umkehren, indem Sie die Array.Reverse-Methode aufrufen.You can easily reverse the order of a managed byte array by calling the Array.Reverse method.

Konstruktoren

RSACryptoServiceProvider()

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

RSACryptoServiceProvider(CspParameters)

Initialisiert eine neue Instanz der RSACryptoServiceProvider-Klasse mit den angegebenen Parametern.Initializes a new instance of the RSACryptoServiceProvider class with the specified parameters.

RSACryptoServiceProvider(Int32)

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

RSACryptoServiceProvider(Int32, CspParameters)

Initialisiert eine neue Instanz der RSACryptoServiceProvider-Klasse mit der angegebenen Schlüsselgröße und den angegebenen Parametern.Initializes a new instance of the RSACryptoServiceProvider class with the specified key size and parameters.

Felder

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.

(Geerbt von AsymmetricAlgorithm)
LegalKeySizesValue

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

(Geerbt von AsymmetricAlgorithm)

Eigenschaften

CspKeyContainerInfo

Ruft ein CspKeyContainerInfo-Objekt ab, das zusätzliche beschreibende Informationen zu einem kryptografischen Schlüsselpaar enthält.Gets a CspKeyContainerInfo object that describes additional information about a cryptographic key pair.

KeyExchangeAlgorithm

Ruft den Namen des in dieser Implementierung von RSA verfügbaren Algorithmus für den Schlüsselaustausch ab.Gets the name of the key exchange algorithm available with this implementation of RSA.

KeySize

Ruft die Größe des aktuellen Schlüssels ab.Gets the size of the current key.

LegalKeySizes

Ruft die vom asymmetrischen Algorithmus unterstützten Schlüsselgrößen ab.Gets the key sizes that are supported by the asymmetric algorithm.

PersistKeyInCsp

Ruft einen Wert ab, der angibt, ob der Schlüssel im Kryptografiedienstanbieter (CSP) beibehalten werden soll, oder legt diesen Wert fest.Gets or sets a value indicating whether the key should be persisted in the cryptographic service provider (CSP).

PublicOnly

Ruft einen Wert ab, der angibt, ob das RSACryptoServiceProvider-Objekt nur einen öffentlichen Schlüssel enthält.Gets a value that indicates whether the RSACryptoServiceProvider object contains only a public key.

SignatureAlgorithm

Ruft den Namen des in dieser Implementierung von RSA verfügbaren Signaturalgorithmus ab.Gets the name of the signature algorithm available with this implementation of RSA.

UseMachineKeyStore

Ruft einen Wert ab, der angibt, ob der Schlüssel statt im Benutzerprofilspeicher im Schlüsselspeicher des Computers beibehalten werden soll, oder legt diesen Wert fest.Gets or sets a value indicating whether the key should be persisted in the computer's key store instead of the user profile store.

Methoden

Clear()

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

(Geerbt von AsymmetricAlgorithm)
Decrypt(Byte[], Boolean)

Verschlüsselt Daten mit dem RSA-Algorithmus.Decrypts data with the RSA algorithm.

Decrypt(Byte[], RSAEncryptionPadding)

Entschlüsselt zuvor mit dem RSA-Algorithmus verschlüsselte Daten unter Verwendung der angegebenen Auffüllung.Decrypts data that was previously encrypted with the RSA algorithm by using the specified padding.

DecryptValue(Byte[])

Diese Methode wird in der aktuellen Version nicht unterstützt.This method is not supported in the current version.

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.

(Geerbt von AsymmetricAlgorithm)
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.

(Geerbt von AsymmetricAlgorithm)
Encrypt(Byte[], Boolean)

Verschlüsselt Daten mit dem RSA-Algorithmus.Encrypts data with the RSA algorithm.

Encrypt(Byte[], RSAEncryptionPadding)

Verschlüsselt Daten mit dem RSA-Algorithmus unter Verwendung der angegebenen Auffüllung.Encrypts data with the RSA algorithm using the specified padding.

EncryptValue(Byte[])

Diese Methode wird in der aktuellen Version nicht unterstützt.This method is not supported in the current version.

Equals(Object)

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

(Geerbt von Object)
ExportCspBlob(Boolean)

Exportiert ein BLOB, das die Schlüsselinformationen enthält, die einem RSACryptoServiceProvider-Objekt zugeordnet sind.Exports a blob containing the key information associated with an RSACryptoServiceProvider object.

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.

(Geerbt von AsymmetricAlgorithm)
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.

(Geerbt von AsymmetricAlgorithm)
ExportParameters(Boolean)

Exportiert die RSAParameters.Exports the RSAParameters.

ExportPkcs8PrivateKey()

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

(Geerbt von AsymmetricAlgorithm)
ExportRSAPrivateKey()

Exportiert den aktuellen Schlüssel im PKCS#1-RSAPrivateKey-Format.Exports the current key in the PKCS#1 RSAPrivateKey format.

(Geerbt von RSA)
ExportRSAPublicKey()

Exportiert den Teil mit dem öffentlichen Schlüssel des aktuellen Schlüssels in das PKCS#1-RSAPublicKey-Format.Exports the public-key portion of the current key in the PKCS#1 RSAPublicKey format.

(Geerbt von RSA)
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.

(Geerbt von AsymmetricAlgorithm)
Finalize()

Gibt die von dieser Instanz gehaltenen, nicht verwalteten Ressourcen frei.Releases the unmanaged resources held by this instance.

FromXmlString(String)

Initialisiert ein RSA-Objekt mit den Schlüsselinformationen aus einer XML-Zeichenfolge.Initializes an RSA object from the key information from an XML string.

(Geerbt von RSA)
GetHashCode()

Dient als die Standard-HashfunktionServes as the default hash function.

(Geerbt von Object)
GetType()

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

(Geerbt von Object)
HashData(Byte[], Int32, Int32, HashAlgorithmName)

Berechnet, falls in einer abgeleiteten Klasse überschrieben, den Hashwert eines angegebenen Teils eines Bytearrays mithilfe eines angegebenen Hashalgorithmus.When overridden in a derived class, computes the hash value of a specified portion of a byte array by using a specified hashing algorithm.

(Geerbt von RSA)
HashData(Stream, HashAlgorithmName)

Berechnet, falls in einer abgeleiteten Klasse überschrieben, den Hashwert eines angegebenen Binärdatenstroms mithilfe eines angegebenen Hashalgorithmus.When overridden in a derived class, computes the hash value of a specified binary stream by using a specified hashing algorithm.

(Geerbt von RSA)
ImportCspBlob(Byte[])

Importiert ein BLOB, das RSA-Schlüsselinformationen darstellt.Imports a blob that represents RSA key information.

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.

(Geerbt von RSA)
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.

(Geerbt von RSA)
ImportParameters(RSAParameters)

Importiert die angegebenen RSAParameters.Imports the specified RSAParameters.

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.

(Geerbt von RSA)
ImportRSAPrivateKey(ReadOnlySpan<Byte>, Int32)

Importiert das Paar aus öffentlichem und privatem Schlüssel aus einer PKCS#1-RSAPrivateKey-Struktur nach der Entschlüsselung und ersetzt die Schlüssel für dieses Objekt.Imports the public/private keypair from a PKCS#1 RSAPrivateKey structure after decryption, replacing the keys for this object.

(Geerbt von RSA)
ImportRSAPublicKey(ReadOnlySpan<Byte>, Int32)

Importiert den öffentlichen Schlüssel aus einer PKCS#1-RSAPublicKey-Struktur nach der Entschlüsselung und ersetzt dabei die Schlüssel für dieses Objekt.Imports the public key from a PKCS#1 RSAPublicKey structure after decryption, replacing the keys for this object.

(Geerbt von RSA)
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.

(Geerbt von RSA)
MemberwiseClone()

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

(Geerbt von Object)
SignData(Byte[], HashAlgorithmName, RSASignaturePadding)

Berechnet den Hashwert des angegebenen Bytearrays mithilfe des angegebenen Hashalgorithmus und Paddingmodus (Auffüllmodus) und signiert den resultierenden Hashwert.Computes the hash value of the specified byte array using the specified hash algorithm and padding mode, and signs the resulting hash value.

(Geerbt von RSA)
SignData(Byte[], Int32, Int32, HashAlgorithmName, RSASignaturePadding)

Berechnet den Hashwert eines Teils des angegebenen Bytearrays mithilfe des angegebenen Hashalgorithmus und Paddingmodus und signiert den resultierenden Hashwert.Computes the hash value of a portion of the specified byte array using the specified hash algorithm and padding mode, and signs the resulting hash value.

(Geerbt von RSA)
SignData(Byte[], Int32, Int32, Object)

Berechnet den Hashwert einer Teilmenge des angegebenen Bytearrays mithilfe des angegebenen Hashalgorithmus und signiert den sich ergebenden Hashwert.Computes the hash value of a subset of the specified byte array using the specified hash algorithm, and signs the resulting hash value.

SignData(Byte[], Object)

Berechnet den Hashwert des angegebenen Bytearrays mithilfe des angegebenen Hashalgorithmus und signiert den resultierenden Hashwert.Computes the hash value of the specified byte array using the specified hash algorithm, and signs the resulting hash value.

SignData(Stream, HashAlgorithmName, RSASignaturePadding)

Berechnet den Hashwert des angegebenen Datenstroms mithilfe des angegebenen Hashalgorithmus und Paddingsmodus und signiert den resultierenden Hashwert.Computes the hash value of the specified stream using the specified hash algorithm and padding mode, and signs the resulting hash value.

(Geerbt von RSA)
SignData(Stream, Object)

Berechnet den Hashwert des angegebenen Eingabedatenstroms mithilfe des angegebenen Hashalgorithmus und signiert den resultierenden Hashwert.Computes the hash value of the specified input stream using the specified hash algorithm, and signs the resulting hash value.

SignHash(Byte[], HashAlgorithmName, RSASignaturePadding)

Berechnet die Signatur für den angegebenen Hashwert unter Verwendung des angegebenen Paddings.Computes the signature for the specified hash value using the specified padding.

SignHash(Byte[], String)

Berechnet die Signatur für den angegebenen Hashwert.Computes the signature for the specified hash value.

ToString()

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

(Geerbt von Object)
ToXmlString(Boolean)

Erstellt eine XML-Zeichenfolge mit dem Schlüssel des aktuellen RSA-Objekts und gibt diese zurück.Creates and returns an XML string containing the key of the current RSA object.

(Geerbt von RSA)
TryDecrypt(ReadOnlySpan<Byte>, Span<Byte>, RSAEncryptionPadding, Int32)

Versucht, die Eingabedaten mithilfe des angegebenen Paddingmodus zu entschlüsseln, wobei das Ergebnis in einen bereitgestellten Puffer geschrieben wird.Attempts to decrypt the input data using the specified padding mode, writing the result into a provided buffer.

(Geerbt von RSA)
TryEncrypt(ReadOnlySpan<Byte>, Span<Byte>, RSAEncryptionPadding, Int32)

Versucht, die Eingabedaten mithilfe eines angegebenen Paddingmodus in einen bereitgestellten Puffer zu verschlüsseln.Attempts to encrypt the input data with a specified padding mode into a provided buffer.

(Geerbt von RSA)
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.

(Geerbt von RSA)
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.

(Geerbt von RSA)
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.

(Geerbt von RSA)
TryExportRSAPrivateKey(Span<Byte>, Int32)

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

(Geerbt von RSA)
TryExportRSAPublicKey(Span<Byte>, Int32)

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

(Geerbt von RSA)
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.

(Geerbt von RSA)
TryHashData(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, Int32)

Versucht, den Hashwert der angegebenen Daten unter Verwendung eines angegebenen Algorithmus zu berechnen, wobei die Ergebnisse in einen angegebenen Puffer geschrieben werden.Attempts to compute the hash of the provided data by using the specified algorithm, writing the results into a provided buffer.

(Geerbt von RSA)
TrySignData(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, RSASignaturePadding, Int32)

Versucht, den Hash für die angegebenen Daten mit dem angegebenen Algorithmus zu berechnen und den Hash mit dem aktuellen Schlüssel zu signieren, wobei die Signatur in einen bereitgestellten Puffer geschrieben wird.Attempts to hash the provided data with the specified algorithm and sign the hash with the current key, writing the signature into a provided buffer.

(Geerbt von RSA)
TrySignHash(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, RSASignaturePadding, Int32)

Versucht, den Hash mit dem aktuellen Schlüssel zu signieren, wobei die Signatur in einen bereitgestellten Puffer geschrieben wird.Attempts to sign the hash with the current key, writing the signature into a provided buffer.

(Geerbt von RSA)
VerifyData(Byte[], Byte[], HashAlgorithmName, RSASignaturePadding)

Überprüft, ob eine digitale Signatur gültig ist, indem der Hashwert der angegebenen Daten unter Verwendung des angegebenen Hashalgorithmus und Paddingmodus berechnet und mit der angegebenen Signatur verglichen wird.Verifies that a digital signature is valid by calculating the hash value of the specified data using the specified hash algorithm and padding, and comparing it to the provided signature.

(Geerbt von RSA)
VerifyData(Byte[], Int32, Int32, Byte[], HashAlgorithmName, RSASignaturePadding)

Überprüft, ob eine digitale Signatur gültig ist, indem der Hashwert der Daten in einem Teil eines Bytearrays unter Verwendung des angegebenen Hashalgorithmus und Paddings und durch Vergleichen mit der angegebenen Signatur berechnet wird.Verifies that a digital signature is valid by calculating the hash value of the data in a portion of a byte array using the specified hash algorithm and padding, and comparing it to the provided signature.

(Geerbt von RSA)
VerifyData(Byte[], Object, Byte[])

Überprüft, ob eine digitale Signatur gültig ist, indem der Hashwert in der Signatur unter Verwendung des bereitgestellten öffentlichen Schlüssels und durch Vergleichen mit dem Hashwert der bereitgestellten Daten.Verifies that a digital signature is valid by determining the hash value in the signature using the provided public key and comparing it to the hash value of the provided data.

VerifyData(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, HashAlgorithmName, RSASignaturePadding)

Überprüft, ob eine digitale Signatur gültig ist, indem der Hashwert der angegebenen Daten unter Verwendung des angegebenen Hashalgorithmus und Paddingmodus berechnet und mit der angegebenen Signatur verglichen wird.Verifies that a digital signature is valid by calculating the hash value of the specified data using the specified hash algorithm and padding, and comparing it to the provided signature.

(Geerbt von RSA)
VerifyData(Stream, Byte[], HashAlgorithmName, RSASignaturePadding)

Überprüft, ob eine digitale Signatur gültig ist, indem der Hashwert des angegebenen Datenstroms unter Verwendung des angegebenen Hashalgorithmus und Paddings und durch Vergleichen mit der angegebenen Signatur berechnet wird.Verifies that a digital signature is valid by calculating the hash value of the specified stream using the specified hash algorithm and padding, and comparing it to the provided signature.

(Geerbt von RSA)
VerifyHash(Byte[], Byte[], HashAlgorithmName, RSASignaturePadding)

Überprüft, ob eine digitale Signatur gültig ist, indem der Hashwert in der Signatur unter Verwendung des angegebenen Hashalgorithmus und Paddingmodus ermittelt und mit dem angegebenen Hashwert verglichen wird.Verifies that a digital signature is valid by determining the hash value in the signature using the specified hashing algorithm and padding, and comparing it to the provided hash value.

VerifyHash(Byte[], String, Byte[])

Überprüft, ob eine digitale Signatur gültig ist, indem der Hashwert in der Signatur unter Verwendung des bereitgestellten öffentlichen Schlüssels ermittelt und mit dem bereitgestellten Hashwert verglichen wird.Verifies that a digital signature is valid by determining the hash value in the signature using the provided public key and comparing it to the provided hash value.

VerifyHash(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, HashAlgorithmName, RSASignaturePadding)

Überprüft, ob eine digitale Signatur gültig ist, indem der Hashwert in der Signatur unter Verwendung des angegebenen Hashalgorithmus und Paddings ermittelt und mit dem angegebenen Hashwert verglichen wird.Verifies that a digital signature is valid by determining the hash value in the signature using the specified hash algorithm and padding, and comparing it to the provided hash value.

(Geerbt von RSA)

Explizite Schnittstellenimplementierungen

IDisposable.Dispose()

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

(Geerbt von AsymmetricAlgorithm)

Gilt für:

Siehe auch