RSACryptoServiceProvider Klasse

Definition

Namespace:

System.Security.Cryptography

Assembly:

System.Security.Cryptography.dll

Quelle:

RSACryptoServiceProvider.Unix.cs

Führt eine asymmetrische Ver- und Entschlüsselung mithilfe der Implementierung des RSA-Algorithmus aus, der vom Kryptografiedienstanbieter (CSP) bereitgestellt wird. Diese Klasse kann nicht vererbt werden.

public ref class RSACryptoServiceProvider sealed : System::Security::Cryptography::RSA, System::Security::Cryptography::ICspAsymmetricAlgorithm

public sealed class RSACryptoServiceProvider : System.Security.Cryptography.RSA, System.Security.Cryptography.ICspAsymmetricAlgorithm

type RSACryptoServiceProvider = class
    inherit RSA
    interface ICspAsymmetricAlgorithm

Public NotInheritable Class RSACryptoServiceProvider
Inherits RSA
Implements ICspAsymmetricAlgorithm

Vererbung

Object

AsymmetricAlgorithm

RSA

RSACryptoServiceProvider

Implementiert

ICspAsymmetricAlgorithm

Beispiele

Im folgenden Codebeispiel wird die RSACryptoServiceProvider -Klasse verwendet, um eine Zeichenfolge in ein Bytearray zu verschlüsseln und die Bytes dann wieder in eine Zeichenfolge zu entschlüsseln.

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
                //to include 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 mit dem RSACryptoServiceProvider erstellten Schlüsselinformationen in ein RSAParameters -Objekt exportiert.

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

Weitere Informationen zu dieser API finden Sie unter Zusätzliche API-Hinweise für RSACryptoServiceProvider.

Konstruktoren

RSACryptoServiceProvider()	Initialisiert eine neue Instanz der RSACryptoServiceProvider-Klasse mit einem zufällig generierten Schlüsselpaar.
RSACryptoServiceProvider(CspParameters)	Initialisiert eine neue Instanz der RSACryptoServiceProvider-Klasse mit den angegebenen Parametern.
RSACryptoServiceProvider(Int32)	Initialisiert eine neue Instanz der RSACryptoServiceProvider-Klasse mit einem zufällig erzeugten Schlüsselpaar der angegebenen Schlüsselgröße.
RSACryptoServiceProvider(Int32, CspParameters)	Initialisiert eine neue Instanz der RSACryptoServiceProvider-Klasse mit der angegebenen Schlüsselgröße und den angegebenen Parametern.

Felder

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

Eigenschaften

CspKeyContainerInfo	Ruft ein CspKeyContainerInfo-Objekt ab, das zusätzliche beschreibende Informationen zu einem kryptografischen Schlüsselpaar enthält.
KeyExchangeAlgorithm	Ruft den Namen des in dieser Implementierung von RSA verfügbaren Algorithmus für den Schlüsselaustausch ab.
KeySize	Ruft die Größe des aktuellen Schlüssels ab.
LegalKeySizes	Ruft die vom asymmetrischen Algorithmus unterstützten Schlüsselgrößen ab.
PersistKeyInCsp	Ruft einen Wert ab, der angibt, ob der Schlüssel im Kryptografiedienstanbieter (CSP) beibehalten werden soll, oder legt diesen Wert fest.
PublicOnly	Ruft einen Wert ab, der angibt, ob das RSACryptoServiceProvider-Objekt nur einen öffentlichen Schlüssel enthält.
SignatureAlgorithm	Ruft den Namen des in dieser Implementierung von RSAverfügbaren Signaturalgorithmus ab.
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.

Methoden

Clear()	Gibt alle von der AsymmetricAlgorithm-Klasse verwendeten Ressourcen frei. (Geerbt von AsymmetricAlgorithm)
Decrypt(Byte[], Boolean)	Verschlüsselt Daten mit dem RSA-Algorithmus.
Decrypt(Byte[], RSAEncryptionPadding)	Entschlüsselt zuvor mit dem RSA-Algorithmus verschlüsselte Daten unter Verwendung des angegebene Paddingmodus.
Decrypt(ReadOnlySpan<Byte>, RSAEncryptionPadding)	Entschlüsselt die Eingabedaten mithilfe der angegebenen Paddingmethode. (Geerbt von RSA)
Decrypt(ReadOnlySpan<Byte>, Span<Byte>, RSAEncryptionPadding)	Entschlüsselt die Eingabedaten mithilfe der angegebenen Paddingmethode. (Geerbt von RSA)
DecryptValue(Byte[])	Veraltet. Diese Methode wird in der aktuellen Version nicht unterstützt.
Dispose()	Gibt alle von der aktuellen Instanz der AsymmetricAlgorithm-Klasse verwendeten Ressourcen frei. (Geerbt von AsymmetricAlgorithm)
Dispose(Boolean)	Gibt die von der AsymmetricAlgorithm-Klasse verwendeten nicht verwalteten Ressourcen frei und gibt (optional) auch die verwalteten Ressourcen frei. (Geerbt von AsymmetricAlgorithm)
Encrypt(Byte[], Boolean)	Verschlüsselt Daten mit dem RSA-Algorithmus.
Encrypt(Byte[], RSAEncryptionPadding)	Verschlüsselt Daten mit dem RSA-Algorithmus unter Verwendung der angegebenen Auffüllung.
Encrypt(ReadOnlySpan<Byte>, RSAEncryptionPadding)	Verschlüsselt die Eingabedaten mithilfe der angegebenen Paddingmethode. (Geerbt von RSA)
Encrypt(ReadOnlySpan<Byte>, Span<Byte>, RSAEncryptionPadding)	Verschlüsselt die Eingabedaten mithilfe der angegebenen Paddingmethode. (Geerbt von RSA)
EncryptValue(Byte[])	Veraltet. Diese Methode wird in der aktuellen Version nicht unterstützt.
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
ExportCspBlob(Boolean)	Exportiert ein BLOB, das die Schlüsselinformationen enthält, die einem RSACryptoServiceProvider-Objekt zugeordnet sind.
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters)	Exportiert den aktuellen Schlüssel in das Format „PKCS#8 EncryptedPrivateKeyInfo“ mit einem bytebasierten Kennwort. (Geerbt von AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters)	Exportiert den aktuellen Schlüssel in das Format „PKCS#8 EncryptedPrivateKeyInfo“ mit einem zeichenbasierten Kennwort. (Geerbt von AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Byte>, PbeParameters)	Exportiert den aktuellen Schlüssel im PKCS#8 EncryptedPrivateKeyInfo-Format mit einem bytebasierten Kennwort, PEM-codiert. (Geerbt von AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Char>, PbeParameters)	Exportiert den aktuellen Schlüssel im PKCS#8 EncryptedPrivateKeyInfo-Format mit einem charbasierten Kennwort, PEM-codiert. (Geerbt von AsymmetricAlgorithm)
ExportParameters(Boolean)	Exportiert die RSAParameters.
ExportPkcs8PrivateKey()	Exportiert den aktuellen Schlüssel im Format „PKCS#8 PrivateKeyInfo“. (Geerbt von AsymmetricAlgorithm)
ExportPkcs8PrivateKeyPem()	Exportiert den aktuellen Schlüssel im PKCS#8 PrivateKeyInfo-Format, PEM-codiert. (Geerbt von AsymmetricAlgorithm)
ExportRSAPrivateKey()	Exportiert den aktuellen Schlüssel im PKCS#1-RSAPrivateKey-Format. (Geerbt von RSA)
ExportRSAPrivateKeyPem()	Exportiert den aktuellen Schlüssel im PKCS#1 RSAPrivateKey-Format, PEM-codiert. (Geerbt von RSA)
ExportRSAPublicKey()	Exportiert den Teil mit dem öffentlichen Schlüssel des aktuellen Schlüssels in das PKCS#1-RSAPublicKey-Format. (Geerbt von RSA)
ExportRSAPublicKeyPem()	Exportiert den öffentlichen Schlüsselteil des aktuellen Schlüssels im PKCS#1 RSAPublicKey-Format, PEM-codiert. (Geerbt von RSA)
ExportSubjectPublicKeyInfo()	Exportiert den Teil mit dem öffentlichen Schlüssel des aktuellen Schlüssels in das Format „X.509 SubjectPublicKeyInfo“. (Geerbt von AsymmetricAlgorithm)
ExportSubjectPublicKeyInfoPem()	Exportiert den öffentlichen Schlüsselteil des aktuellen Schlüssels im X.509 SubjectPublicKeyInfo-Format, PEM-codiert. (Geerbt von AsymmetricAlgorithm)
FromXmlString(String)	Initialisiert ein RSA-Objekt mit den Schlüsselinformationen aus einer XML-Zeichenfolge. (Geerbt von RSA)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetMaxOutputSize()	Ruft die maximale Anzahl von Bytes ab, die ein RSA-Vorgang erzeugen kann. (Geerbt von RSA)
GetType()	Ruft den Type der aktuellen Instanz ab. (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. (Geerbt von RSA)
HashData(Stream, HashAlgorithmName)	Berechnet, falls in einer abgeleiteten Klasse überschrieben, den Hashwert eines angegebenen Binärdatenstroms mithilfe eines angegebenen Hashalgorithmus. (Geerbt von RSA)
ImportCspBlob(Byte[])	Importiert ein BLOB, das RSA-Schlüsselinformationen darstellt.
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Int32)	Importiert das Paar aus öffentlichem und privatem Schlüssel aus einer PKCS#8-EncryptedPrivateKeyInfo-Struktur nach der Entschlüsselung mit einem bytebasierten Kennwort und ersetzt die Schlüssel für dieses Objekt.
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Int32)	Importiert das Paar aus öffentlichem und privatem Schlüssel aus einer PKCS#8-EncryptedPrivateKeyInfo-Struktur nach der Entschlüsselung mit einem zeichenbasierten Kennwort und ersetzt die Schlüssel für dieses Objekt.
ImportFromEncryptedPem(ReadOnlySpan<Char>, ReadOnlySpan<Byte>)	Importiert einen verschlüsselten, mit RFC 7468 PEM-codierten privaten Schlüssel und ersetzt die Schlüssel für dieses Objekt. (Geerbt von RSA)
ImportFromEncryptedPem(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Importiert einen verschlüsselten, mit RFC 7468 PEM-codierten privaten Schlüssel und ersetzt die Schlüssel für dieses Objekt. (Geerbt von RSA)
ImportFromPem(ReadOnlySpan<Char>)	Importiert einen mit RFC 7468 PEM-codierten Schlüssel und ersetzt die Schlüssel für dieses Objekt. (Geerbt von RSA)
ImportParameters(RSAParameters)	Importiert die angegebenen 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. (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. (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. (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. (Geerbt von RSA)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen 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. (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. (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.
SignData(Byte[], Object)	Berechnet den Hashwert des angegebenen Bytearrays mithilfe des angegebenen Hashalgorithmus und signiert den resultierenden Hashwert.
SignData(ReadOnlySpan<Byte>, HashAlgorithmName, RSASignaturePadding)	Berechnet den Hashwert der angegebenen Daten und signiert ihn. (Geerbt von RSA)
SignData(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, RSASignaturePadding)	Berechnet den Hash der bereitgestellten Daten mit dem angegebenen Algorithmus und signiert den Hash mit dem aktuellen Schlüssel, wobei die Signatur in einen bereitgestellten Puffer geschrieben wird. (Geerbt von RSA)
SignData(Stream, HashAlgorithmName, RSASignaturePadding)	Berechnet den Hashwert des angegebenen Datenstroms mithilfe des angegebenen Hashalgorithmus und Paddingsmodus und signiert den resultierenden Hashwert. (Geerbt von RSA)
SignData(Stream, Object)	Berechnet den Hashwert des angegebenen Eingabedatenstroms mithilfe des angegebenen Hashalgorithmus und signiert den resultierenden Hashwert.
SignHash(Byte[], HashAlgorithmName, RSASignaturePadding)	Berechnet die Signatur für den angegebenen Hashwert unter Verwendung des angegebenen Paddings.
SignHash(Byte[], String)	Berechnet die Signatur für den angegebenen Hashwert.
SignHash(ReadOnlySpan<Byte>, HashAlgorithmName, RSASignaturePadding)	Berechnet die Signatur für den angegebenen Hashwert unter Verwendung des angegebenen Paddings. (Geerbt von RSA)
SignHash(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, RSASignaturePadding)	Signiert den Hash mit dem aktuellen Schlüssel, und schreibt die Signatur in einen bereitgestellten Puffer. (Geerbt von RSA)
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
ToXmlString(Boolean)	Erstellt eine XML-Zeichenfolge mit dem Schlüssel des aktuellen RSA-Objekts und gibt diese zurück. (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. (Geerbt von RSA)
TryEncrypt(ReadOnlySpan<Byte>, Span<Byte>, RSAEncryptionPadding, Int32)	Versucht, die Eingabedaten mithilfe eines angegebenen Paddingmodus in einen bereitgestellten Puffer zu verschlüsseln. (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. (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. (Geerbt von RSA)
TryExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Byte>, PbeParameters, Span<Char>, Int32)	Versucht, den aktuellen Schlüssel im PKCS#8 EncryptedPrivateKeyInfo-Format mit einem bytebasierten Kennwort( PEM-codiert) zu exportieren. (Geerbt von AsymmetricAlgorithm)
TryExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Char>, PbeParameters, Span<Char>, Int32)	Exportiert den aktuellen Schlüssel im PKCS#8 EncryptedPrivateKeyInfo-Format mit einem charbasierten Kennwort, PEM-codiert. (Geerbt von AsymmetricAlgorithm)
TryExportPkcs8PrivateKey(Span<Byte>, Int32)	Versucht, den aktuellen Schlüssel im PKCS#8-PrivateKeyInfo-Format in einen bereitgestellten Puffer zu exportieren. (Geerbt von RSA)
TryExportPkcs8PrivateKeyPem(Span<Char>, Int32)	Versucht, den aktuellen Schlüssel im PEM-codierten PKCS#8 PrivateKeyInfo-Format in einen bereitgestellten Puffer zu exportieren. (Geerbt von AsymmetricAlgorithm)
TryExportRSAPrivateKey(Span<Byte>, Int32)	Versucht, den aktuellen Schlüssel im PKCS#1-RSAPrivateKey-Format in einen bereitgestellten Puffer zu exportieren. (Geerbt von RSA)
TryExportRSAPrivateKeyPem(Span<Char>, Int32)	Versucht, den aktuellen Schlüssel im PEM-codierten PKCS#1 RSAPrivateKey-Format in einen bereitgestellten Puffer zu exportieren. (Geerbt von RSA)
TryExportRSAPublicKey(Span<Byte>, Int32)	Versucht, den aktuellen Schlüssel im PKCS#1-RSAPublicKey-Format in einen bereitgestellten Puffer zu exportieren. (Geerbt von RSA)
TryExportRSAPublicKeyPem(Span<Char>, Int32)	Versucht, den aktuellen Schlüssel im PEM-codierten PKCS#1 RSAPublicKey-Format in einen bereitgestellten Puffer zu exportieren. (Geerbt von RSA)
TryExportSubjectPublicKeyInfo(Span<Byte>, Int32)	Versucht, den aktuellen Schlüssel im X.509-SubjectPublicKeyInfo-Format in einen bereitgestellten Puffer zu exportieren. (Geerbt von RSA)
TryExportSubjectPublicKeyInfoPem(Span<Char>, Int32)	Versucht, den aktuellen Schlüssel im PEM-codierten X.509 SubjectPublicKeyInfo-Format in einen bereitgestellten Puffer zu exportieren. (Geerbt von AsymmetricAlgorithm)
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. (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. (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. (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. (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. (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.
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. (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. (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.
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.
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. (Geerbt von RSA)

Weitere Informationen

• Kryptografische Dienste