RSACryptoServiceProvider Osztály

Definíció

Névtér:

System.Security.Cryptography

Szerelvények:

netstandard.dll, System.Security.Cryptography.dll

Forrás:

RSACryptoServiceProvider.Unix.cs

A titkosítási szolgáltató (CSP) által biztosított algoritmus implementálásával RSA aszimmetrikus titkosítást és visszafejtést hajt végre. Ez az osztály nem örökölhető.

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

Öröklődés

Object

AsymmetricAlgorithm

RSA

RSACryptoServiceProvider

Megvalósítás

ICspAsymmetricAlgorithm

Példák

Az alábbi kódpéldában az RSACryptoServiceProvider osztály egy bájtból álló tömbbe titkosít egy sztringet, majd visszafejti a bájtokat egy sztringbe.

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

Az alábbi példakód exportálja a használatával RSACryptoServiceProvider létrehozott kulcsadatokat egy RSAParameters objektumba.

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

Megjegyzések

A RSACryptoServiceProvider osztály az alapértelmezett implementációja RSA.

A RSACryptoServiceProvider 384 bites és 16384 bites kulcsméreteket 8 bites lépésekben támogatja, ha telepítve van a Microsoft Enhanced Cryptographic Provider. 384 bittől 512 bitig, 8 bites lépésekben támogatja a kulcsméreteket, ha telepítve van a Microsoft Base titkosítási szolgáltató.

Az érvényes kulcsméretek a példány által RSACryptoServiceProvider használt titkosítási szolgáltatótól (CSP) függnek. A Windows CSP-k 384 és 16384 bites kulcsméreteket engedélyeznek a Windows 8.1 előtti Windows-verziókhoz, a Windows 8.1-hez pedig 512–16384 bites kulcsméreteket. További információ: CryptGenKey függvény a Windows dokumentációjában.

Együttműködés a Microsoft Cryptographic API-val (CAPI)

A nem felügyelt CAPI RSA-implementációtól eltérően az RSACryptoServiceProvider osztály megfordítja a titkosítás után és a visszafejtés előtt lévő bájtok titkosított tömbjének sorrendjét. Alapértelmezés szerint az RSACryptoServiceProvider osztály által titkosított adatokat a CAPI-függvény nem tudja visszafejteni, és a CAPI-módszerrel CryptDecryptCryptEncrypt titkosított adatokat az RSACryptoServiceProvider osztály nem tudja visszafejteni.

Ha nem kompenzálja a visszafelé irányuló sorrendet, amikor API-k között működik, akkor az RSACryptoServiceProvider osztály kivételt dob CryptographicException.

A CAPI-val való együttműködéshez manuálisan vissza kell fordítania a titkosított bájtok sorrendjét, mielőtt a titkosított adatok egy másik API-val együttműködnek. A metódus meghívásával egyszerűen megfordíthatja a felügyelt bájttömbök sorrendjét Array.Reverse .

Konstruktorok

Name	Description
RSACryptoServiceProvider()	Inicializálja az RSACryptoServiceProvider osztály új példányát egy véletlenszerű kulcspárral.
RSACryptoServiceProvider(CspParameters)	Inicializálja az RSACryptoServiceProvider osztály új példányát a megadott paraméterekkel.
RSACryptoServiceProvider(Int32, CspParameters)	Inicializálja az RSACryptoServiceProvider osztály új példányát a megadott kulcsmérettel és paraméterekkel.
RSACryptoServiceProvider(Int32)	Inicializálja az RSACryptoServiceProvider osztály új példányát a megadott kulcsméretű véletlenszerű kulcspárral.

Mezők

Name	Description
KeySizeValue	Az aszimmetrikus algoritmus által használt kulcsmodulusok méretét jelöli bitekben. (Öröklődés forrása AsymmetricAlgorithm)
LegalKeySizesValue	Megadja az aszimmetrikus algoritmus által támogatott kulcsméreteket. (Öröklődés forrása AsymmetricAlgorithm)

Tulajdonságok

Name	Description
CspKeyContainerInfo	Lekéri a CspKeyContainerInfo titkosítási kulcspárokkal kapcsolatos további információkat leíró objektumot.
KeyExchangeAlgorithm	Lekéri a kulcscsere algoritmus nevét, amely a következő implementációval RSAérhető el: .
KeySize	Lekéri az aktuális kulcs méretét.
LegalKeySizes	Lekéri az aszimmetrikus algoritmus által támogatott kulcsméreteket.
PersistKeyInCsp	Lekéri vagy beállít egy értéket, amely jelzi, hogy a kulcsot meg kell-e őrizni a titkosítási szolgáltatóban (CSP).
PublicOnly	Olyan értéket kap, amely jelzi, hogy az RSACryptoServiceProvider objektum csak nyilvános kulcsot tartalmaz-e.
SignatureAlgorithm	Lekéri a jelen implementációval elérhető aláírási RSAalgoritmus nevét.
UseMachineKeyStore	Lekéri vagy beállít egy értéket, amely jelzi, hogy a kulcsot a számítógép kulcstárolójában kell-e tárolni a felhasználói profiltároló helyett.

Metódusok

Name	Description
Clear()	Az osztály által AsymmetricAlgorithm használt összes erőforrást felszabadítja. (Öröklődés forrása AsymmetricAlgorithm)
Decrypt(Byte[], Boolean)	Adatok visszafejtése az RSA algoritmussal.
Decrypt(Byte[], RSAEncryptionPadding)	A korábban az RSA algoritmussal titkosított adatok visszafejtése a megadott kitöltéssel.
Decrypt(ReadOnlySpan<Byte>, RSAEncryptionPadding)	A bemeneti adatok visszafejtése a megadott kitöltési móddal. (Öröklődés forrása RSA)
Decrypt(ReadOnlySpan<Byte>, Span<Byte>, RSAEncryptionPadding)	A bemeneti adatok visszafejtése a megadott kitöltési móddal. (Öröklődés forrása RSA)
DecryptValue(Byte[])	Elavult. Ez a módszer az aktuális verzióban nem támogatott.
Dispose()	Az osztály aktuális példánya által használt összes erőforrást felszabadítja AsymmetricAlgorithm . (Öröklődés forrása AsymmetricAlgorithm)
Dispose(Boolean)	Felszabadítja az osztály által AsymmetricAlgorithm használt nem felügyelt erőforrásokat, és opcionálisan felszabadítja a felügyelt erőforrásokat. (Öröklődés forrása AsymmetricAlgorithm)
Encrypt(Byte[], Boolean)	Az algoritmussal titkosítja az RSA adatokat.
Encrypt(Byte[], RSAEncryptionPadding)	A megadott kitöltéssel titkosítja az adatokat az RSA algoritmussal.
Encrypt(ReadOnlySpan<Byte>, RSAEncryptionPadding)	A megadott kitöltési móddal titkosítja a bemeneti adatokat. (Öröklődés forrása RSA)
Encrypt(ReadOnlySpan<Byte>, Span<Byte>, RSAEncryptionPadding)	A megadott kitöltési móddal titkosítja a bemeneti adatokat. (Öröklődés forrása RSA)
EncryptValue(Byte[])	Elavult. Ez a módszer az aktuális verzióban nem támogatott.
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
ExportCspBlob(Boolean)	Egy objektumhoz társított kulcsinformációkat RSACryptoServiceProvider tartalmazó blobot exportál.
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters)	Az aktuális kulcsot a PKCS#8 EncryptedPrivateKeyInfo formátumban exportálja bájtalapú jelszóval. (Öröklődés forrása AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters)	Az aktuális kulcsot a PKCS#8 EncryptedPrivateKeyInfo formátumban exportálja karakteralapú jelszóval. (Öröklődés forrása AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Byte>, PbeParameters)	A PKCS#8 EncryptedPrivateKeyInfo formátumban exportálja az aktuális kulcsot egy bájtalapú jelszóval, PEM kódolással. (Öröklődés forrása AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Char>, PbeParameters)	A PKCS#8 EncryptedPrivateKeyInfo formátumban exportálja az aktuális kulcsot egy karakteralapú jelszóval, PEM kódolással. (Öröklődés forrása AsymmetricAlgorithm)
ExportParameters(Boolean)	Exportálja a RSAParameters.
ExportPkcs8PrivateKey()	Exportálja az aktuális kulcsot a PKCS#8 PrivateKeyInfo formátumban. (Öröklődés forrása AsymmetricAlgorithm)
ExportPkcs8PrivateKeyPem()	Exportálja az aktuális kulcsot PKCS#8 PrivateKeyInfo formátumban, PEM kódolású formátumban. (Öröklődés forrása AsymmetricAlgorithm)
ExportRSAPrivateKey()	Exportálja az aktuális kulcsot PKCS#1 RSAPrivateKey formátumban. (Öröklődés forrása RSA)
ExportRSAPrivateKeyPem()	Exportálja az aktuális kulcsot a PKCS#1 RSAPrivateKey formátumban, PEM kódolású formátumban. (Öröklődés forrása RSA)
ExportRSAPublicKey()	Az aktuális kulcs nyilvános kulcs részét exportálja PKCS#1 RSAPublicKey formátumban. (Öröklődés forrása RSA)
ExportRSAPublicKeyPem()	Exportálja az aktuális kulcs nyilvános kulcs részét PKCS#1 RSAPublicKey formátumban, PEM kódolású formátumban. (Öröklődés forrása RSA)
ExportSubjectPublicKeyInfo()	Az aktuális kulcs nyilvános kulcs részét exportálja X.509 SubjectPublicKeyInfo formátumban. (Öröklődés forrása AsymmetricAlgorithm)
ExportSubjectPublicKeyInfoPem()	Exportálja az aktuális kulcs nyilvános kulcs részét X.509 SubjectPublicKeyInfo formátumban, PEM kódolású formátumban. (Öröklődés forrása AsymmetricAlgorithm)
FromXmlString(String)	Inicializál egy RSA objektumot egy XML-sztring kulcsadataiból. (Öröklődés forrása RSA)
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetMaxOutputSize()	Az RSA-művelet által létrehozható bájtok maximális számát adja meg. (Öröklődés forrása RSA)
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
HashData(Byte[], Int32, Int32, HashAlgorithmName)	Ha egy származtatott osztályban felül van bírálva, kiszámítja a bájttömb egy adott részének kivonatértékét egy megadott kivonatolási algoritmus használatával. (Öröklődés forrása RSA)
HashData(Stream, HashAlgorithmName)	Ha egy származtatott osztályban felül van bírálva, egy megadott bináris stream kivonatértékét számítja ki egy megadott kivonatoló algoritmus használatával. (Öröklődés forrása RSA)
ImportCspBlob(Byte[])	Importál egy olyan blobot, amely RSA-kulcsadatokat jelöl.
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Int32)	Importálja a nyilvános/privát kulcspairt egy PKCS#8 EncryptedPrivateKeyInfo szerkezetből, miután a visszafejtést egy bájtalapú jelszóval végzett visszafejtés után az objektum kulcsainak lecserélésével végzi.
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Int32)	Importálja a nyilvános/privát kulcspairt egy PKCS#8 EncryptedPrivateKeyInfo struktúrából, miután a visszafejtés egy karakteralapú jelszóval megtörtént, és lecserélte az objektum kulcsait.
ImportFromEncryptedPem(ReadOnlySpan<Char>, ReadOnlySpan<Byte>)	Importál egy titkosított RFC 7468 PEM-kódolású titkos kulcsot, lecserélve az objektum kulcsait. (Öröklődés forrása RSA)
ImportFromEncryptedPem(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Importál egy titkosított RFC 7468 PEM-kódolású titkos kulcsot, lecserélve az objektum kulcsait. (Öröklődés forrása RSA)
ImportFromPem(ReadOnlySpan<Char>)	Importál egy RFC 7468 PEM kódolású kulcsot, és lecseréli az objektum kulcsait. (Öröklődés forrása RSA)
ImportParameters(RSAParameters)	Importálja a megadott RSAParameters.
ImportPkcs8PrivateKey(ReadOnlySpan<Byte>, Int32)	A visszafejtés után importálja a nyilvános/privát kulcstárat egy PKCS#8 PrivateKeyInfo struktúrából, és lecseréli az objektum kulcsait. (Öröklődés forrása RSA)
ImportRSAPrivateKey(ReadOnlySpan<Byte>, Int32)	Importálja a nyilvános/privát kulcspairt egy PKCS#1 RSAPrivateKey szerkezetből a visszafejtés után, és cserélje le az objektum kulcsait. (Öröklődés forrása RSA)
ImportRSAPublicKey(ReadOnlySpan<Byte>, Int32)	Importálja a nyilvános kulcsot egy PKCS#1 RSAPublicKey struktúrából a visszafejtés után, és cserélje le az objektum kulcsait. (Öröklődés forrása RSA)
ImportSubjectPublicKeyInfo(ReadOnlySpan<Byte>, Int32)	A visszafejtés után importálja a nyilvános kulcsot egy X.509 SubjectPublicKeyInfo struktúrából, és lecseréli az objektum kulcsait. (Öröklődés forrása RSA)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
SignData(Byte[], HashAlgorithmName, RSASignaturePadding)	Kiszámítja a megadott bájttömb kivonatértékét a megadott kivonatoló algoritmus és kitöltési mód használatával, és aláírja az eredményként kapott kivonatértéket. (Öröklődés forrása RSA)
SignData(Byte[], Int32, Int32, HashAlgorithmName, RSASignaturePadding)	Kiszámítja a megadott bájttömb egy részének kivonatértékét a megadott kivonatoló algoritmus és a kitöltési mód használatával, és aláírja az eredményként kapott kivonatértéket. (Öröklődés forrása RSA)
SignData(Byte[], Int32, Int32, Object)	Kiszámítja a megadott bájttömb egy részhalmazának kivonatértékét a megadott kivonatoló algoritmus használatával, és aláírja az eredményül kapott kivonatértéket.
SignData(Byte[], Object)	Kiszámítja a megadott bájttömb kivonatértékét a megadott kivonatoló algoritmus használatával, és aláírja az eredményként kapott kivonatértéket.
SignData(ReadOnlySpan<Byte>, HashAlgorithmName, RSASignaturePadding)	Kiszámítja a megadott adatok kivonatértékét, és aláírja azokat. (Öröklődés forrása RSA)
SignData(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, RSASignaturePadding)	Kiszámítja a megadott adatok kivonatát a megadott algoritmussal, és aláírja a kivonatot az aktuális kulccsal, és az aláírást egy megadott pufferbe írja. (Öröklődés forrása RSA)
SignData(Stream, HashAlgorithmName, RSASignaturePadding)	Kiszámítja a megadott stream kivonatértékét a megadott kivonatoló algoritmus és a kitöltési mód használatával, és aláírja az eredményként kapott kivonatértéket. (Öröklődés forrása RSA)
SignData(Stream, Object)	Kiszámítja a megadott bemeneti adatfolyam kivonatértékét a megadott kivonatoló algoritmus használatával, és aláírja az eredményként kapott kivonatértéket.
SignHash(Byte[], HashAlgorithmName, RSASignaturePadding)	Kiszámítja a megadott kivonatérték aláírását a megadott kitöltéssel.
SignHash(Byte[], String)	Kiszámítja a megadott kivonatérték aláírását.
SignHash(ReadOnlySpan<Byte>, HashAlgorithmName, RSASignaturePadding)	Kiszámítja a megadott kivonatérték aláírását a megadott kitöltéssel. (Öröklődés forrása RSA)
SignHash(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, RSASignaturePadding)	Írja alá a kivonatot az aktuális kulccsal, és írja be az aláírást egy megadott pufferbe. (Öröklődés forrása RSA)
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)
ToXmlString(Boolean)	Létrehoz és visszaad egy XML-sztringet, amely az aktuális RSA objektum kulcsát tartalmazza. (Öröklődés forrása RSA)
TryDecrypt(ReadOnlySpan<Byte>, Span<Byte>, RSAEncryptionPadding, Int32)	Megkísérli visszafejteni a bemeneti adatokat a megadott kitöltési móddal, és az eredményt egy megadott pufferbe írja. (Öröklődés forrása RSA)
TryEncrypt(ReadOnlySpan<Byte>, Span<Byte>, RSAEncryptionPadding, Int32)	Megkísérli titkosítani a bemeneti adatokat egy megadott párnázási móddal egy megadott pufferbe. (Öröklődés forrása RSA)
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters, Span<Byte>, Int32)	Megkísérli exportálni a PKCS#8 EncryptedPrivateKeyInfo formátumú aktuális kulcsot egy megadott pufferbe egy bájtalapú jelszó használatával. (Öröklődés forrása RSA)
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters, Span<Byte>, Int32)	Megkísérli exportálni az aktuális kulcsot a PKCS#8 EncryptedPrivateKeyInfo formátumban egy megadott pufferbe egy karakteralapú jelszó használatával. (Öröklődés forrása RSA)
TryExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Byte>, PbeParameters, Span<Char>, Int32)	Megkísérli exportálni az aktuális kulcsot a PKCS#8 EncryptedPrivateKeyInfo formátumban egy bájtalapú jelszóval, PEM kódolással. (Öröklődés forrása AsymmetricAlgorithm)
TryExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Char>, PbeParameters, Span<Char>, Int32)	A PKCS#8 EncryptedPrivateKeyInfo formátumban exportálja az aktuális kulcsot egy karakteralapú jelszóval, PEM kódolással. (Öröklődés forrása AsymmetricAlgorithm)
TryExportPkcs8PrivateKey(Span<Byte>, Int32)	Megkísérli exportálni az aktuális kulcsot a PKCS#8 PrivateKeyInfo formátumban egy megadott pufferbe. (Öröklődés forrása RSA)
TryExportPkcs8PrivateKeyPem(Span<Char>, Int32)	Megkísérli exportálni az aktuális kulcsot a PEM kódolású PKCS#8 PrivateKeyInfo formátumban egy megadott pufferbe. (Öröklődés forrása AsymmetricAlgorithm)
TryExportRSAPrivateKey(Span<Byte>, Int32)	Megkísérli exportálni az aktuális kulcsot a PKCS#1 RSAPrivateKey formátumban egy megadott pufferbe. (Öröklődés forrása RSA)
TryExportRSAPrivateKeyPem(Span<Char>, Int32)	Megkísérli exportálni az aktuális kulcsot a PEM kódolású PKCS#1 RSAPrivateKey formátumban egy megadott pufferbe. (Öröklődés forrása RSA)
TryExportRSAPublicKey(Span<Byte>, Int32)	Megkísérli exportálni az aktuális kulcsot a PKCS#1 RSAPublicKey formátumban egy megadott pufferbe. (Öröklődés forrása RSA)
TryExportRSAPublicKeyPem(Span<Char>, Int32)	Megpróbálja exportálni az aktuális kulcsot a PEM kódolású PKCS#1 RSAPublicKey formátumban egy megadott pufferbe. (Öröklődés forrása RSA)
TryExportSubjectPublicKeyInfo(Span<Byte>, Int32)	Megkísérli exportálni az aktuális kulcsot az X.509 SubjectPublicKeyInfo formátumban egy megadott pufferbe. (Öröklődés forrása RSA)
TryExportSubjectPublicKeyInfoPem(Span<Char>, Int32)	A PEM kódolású X.509 SubjectPublicKeyInfo formátumban lévő aktuális kulcsot egy megadott pufferbe próbálja exportálni. (Öröklődés forrása AsymmetricAlgorithm)
TryHashData(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, Int32)	Megkísérli kiszámítani a megadott adatok kivonatát a megadott algoritmus használatával, és az eredményeket egy megadott pufferbe írja. (Öröklődés forrása RSA)
TrySignData(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, RSASignaturePadding, Int32)	Megkísérli kivonatelni a megadott adatokat a megadott algoritmussal, és aláírni a kivonatot az aktuális kulccsal, és az aláírást egy megadott pufferbe írni. (Öröklődés forrása RSA)
TrySignHash(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, RSASignaturePadding, Int32)	Megkísérli aláírni a kivonatot az aktuális kulccsal, és az aláírást egy megadott pufferbe írja. (Öröklődés forrása RSA)
VerifyData(Byte[], Byte[], HashAlgorithmName, RSASignaturePadding)	A digitális aláírás érvényességének ellenőrzéséhez számítsa ki a megadott adatok kivonatértékét a megadott kivonatoló algoritmus és kitöltés használatával, és hasonlítsa össze azokat a megadott aláírással. (Öröklődés forrása RSA)
VerifyData(Byte[], Int32, Int32, Byte[], HashAlgorithmName, RSASignaturePadding)	A digitális aláírás érvényességének ellenőrzéséhez számítsa ki a bájttömb egy részének kivonatértékét a megadott kivonatoló algoritmus és kitöltés használatával, és hasonlítsa össze azokat a megadott aláírással. (Öröklődés forrása RSA)
VerifyData(Byte[], Object, Byte[])	A digitális aláírás érvényességének ellenőrzéséhez határozza meg az aláírás kivonatértékét a megadott nyilvános kulcs használatával, és hasonlítsa össze a megadott adatok kivonatértékével.
VerifyData(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, HashAlgorithmName, RSASignaturePadding)	A digitális aláírás érvényességének ellenőrzéséhez számítsa ki a megadott adatok kivonatértékét a megadott kivonatoló algoritmus és kitöltés használatával, és hasonlítsa össze azokat a megadott aláírással. (Öröklődés forrása RSA)
VerifyData(Stream, Byte[], HashAlgorithmName, RSASignaturePadding)	A digitális aláírás érvényességének ellenőrzéséhez számítsa ki a megadott stream kivonatértékét a megadott kivonatoló algoritmus és kitöltés használatával, majd hasonlítsa össze a megadott aláírással. (Öröklődés forrása RSA)
VerifyHash(Byte[], Byte[], HashAlgorithmName, RSASignaturePadding)	A digitális aláírás érvényességének ellenőrzéséhez határozza meg az aláírás kivonatértékét a megadott kivonatolási algoritmus és kitöltés használatával, majd hasonlítsa össze a megadott kivonatértékkel.
VerifyHash(Byte[], String, Byte[])	A digitális aláírás érvényességének ellenőrzéséhez határozza meg az aláírás kivonatértékét a megadott nyilvános kulcs használatával, és hasonlítsa össze a megadott kivonatértékkel.
VerifyHash(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, HashAlgorithmName, RSASignaturePadding)	A digitális aláírás érvényességének ellenőrzéséhez határozza meg az aláírás kivonatértékét a megadott kivonatoló algoritmus és kitöltés használatával, majd hasonlítsa össze a megadott kivonatértékkel. (Öröklődés forrása RSA)

Lásd még

• Titkosítási szolgáltatások