RSACryptoServiceProvider Classe

Définition

Effectue un chiffrement et un déchiffrement asymétriques à l’aide de l’implémentation de l’algorithme RSA fourni par le fournisseur de services de chiffrement. Cette classe ne peut pas être héritée.

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
[<System.Runtime.InteropServices.ComVisible(true)>]
type RSACryptoServiceProvider = class
    inherit RSA
    interface ICspAsymmetricAlgorithm
Public NotInheritable Class RSACryptoServiceProvider
Inherits RSA
Implements ICspAsymmetricAlgorithm
Public NotInheritable Class RSACryptoServiceProvider
Inherits RSA
Héritage
RSACryptoServiceProvider
Attributs
Implémente

Exemples

L’exemple de code suivant utilise la RSACryptoServiceProvider classe pour chiffrer une chaîne dans un tableau d’octets, puis déchiffrer les octets dans une chaîne.

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

L’exemple de code suivant exporte les informations de clé créées à l’aide de dans RSACryptoServiceProvider un RSAParameters objet .

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

Remarques

Pour plus d’informations sur cette API, consultez Remarques supplémentaires sur l’API pour RSACryptoServiceProvider.

Constructeurs

RSACryptoServiceProvider()

Initialise une nouvelle instance de la classe RSACryptoServiceProvider avec une paire de clés aléatoire.

RSACryptoServiceProvider(CspParameters)

Initialise une nouvelle instance de la classe RSACryptoServiceProvider avec les paramètres spécifiés.

RSACryptoServiceProvider(Int32)

Initialise une nouvelle instance de la classe RSACryptoServiceProvider avec une paire de clés aléatoire de la taille de clé spécifiée.

RSACryptoServiceProvider(Int32, CspParameters)

Initialise une nouvelle instance de la classe RSACryptoServiceProvider avec les paramètres et la taille de clé spécifiés.

Champs

KeySizeValue

Représente la taille, en bits, du modulo de la clé utilisé par l'algorithme asymétrique.

(Hérité de AsymmetricAlgorithm)
LegalKeySizesValue

Spécifie les tailles de clé prises en charge par l'algorithme asymétrique.

(Hérité de AsymmetricAlgorithm)

Propriétés

CspKeyContainerInfo

Obtient un objet CspKeyContainerInfo qui comprend des informations supplémentaires concernant une paire de clés de chiffrement.

KeyExchangeAlgorithm

Obtient le nom de l’algorithme d’échange de clés disponible avec cette implémentation de RSA.

KeyExchangeAlgorithm

Obtient le nom de l’algorithme d’échange de clés disponible avec cette implémentation de RSA.

(Hérité de RSA)
KeySize

Obtient la taille de la clé actuelle.

LegalKeySizes

Obtient les tailles de clé prises en charge par l'algorithme asymétrique.

LegalKeySizes

Obtient les tailles de clé prises en charge par l'algorithme asymétrique.

(Hérité de AsymmetricAlgorithm)
PersistKeyInCsp

Obtient ou définit une valeur qui indique si la clé doit être persistante dans le fournisseur de services de chiffrement (CSP).

PublicOnly

Obtient une valeur qui indique si l’objet RSACryptoServiceProvider contient uniquement une clé publique.

SignatureAlgorithm

Obtient le nom de l’algorithme de signature disponible avec cette implémentation de RSA.

SignatureAlgorithm

Obtient le nom de l’algorithme de signature disponible avec cette implémentation de RSA.

(Hérité de RSA)
UseMachineKeyStore

Obtient ou définit une valeur qui indique si la clé doit être persistante dans le magasin de clés de l’ordinateur plutôt que le magasin de profils utilisateur.

Méthodes

Clear()

Libère toutes les ressources utilisées par la classe AsymmetricAlgorithm.

(Hérité de AsymmetricAlgorithm)
Decrypt(Byte[], Boolean)

Déchiffre les données avec l’algorithme RSA.

Decrypt(Byte[], RSAEncryptionPadding)

Déchiffre les données précédemment chiffrées avec l’algorithme RSA à l’aide du remplissage spécifié.

Decrypt(Byte[], RSAEncryptionPadding)

En cas de remplacement dans une classe dérivée, déchiffre les données d’entrée en utilisant le mode de remplissage spécifié.

(Hérité de RSA)
Decrypt(ReadOnlySpan<Byte>, RSAEncryptionPadding)

Déchiffre les données d’entrée en utilisant le mode de remplissage spécifié.

(Hérité de RSA)
Decrypt(ReadOnlySpan<Byte>, Span<Byte>, RSAEncryptionPadding)

Déchiffre les données d’entrée en utilisant le mode de remplissage spécifié.

(Hérité de RSA)
DecryptValue(Byte[])
Obsolète.

Cette méthode n’est pas prise en charge dans la version actuelle.

DecryptValue(Byte[])
Obsolète.

En cas de remplacement dans une classe dérivée, déchiffre les données d'entrée en utilisant la clé privée.

(Hérité de RSA)
Dispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe AsymmetricAlgorithm.

(Hérité de AsymmetricAlgorithm)
Dispose(Boolean)

Libère les ressources non managées utilisées par la classe AsymmetricAlgorithm et libère éventuellement les ressources managées.

(Hérité de AsymmetricAlgorithm)
Encrypt(Byte[], Boolean)

Chiffre les données avec l’algorithme RSA.

Encrypt(Byte[], RSAEncryptionPadding)

Chiffre les données avec l’algorithme RSA à l’aide du remplissage spécifié.

Encrypt(Byte[], RSAEncryptionPadding)

En cas de remplacement dans une classe dérivée, chiffre les données d’entrée en utilisant le mode de remplissage spécifié.

(Hérité de RSA)
Encrypt(ReadOnlySpan<Byte>, RSAEncryptionPadding)

Chiffre les données d’entrée en utilisant le mode de remplissage spécifié.

(Hérité de RSA)
Encrypt(ReadOnlySpan<Byte>, Span<Byte>, RSAEncryptionPadding)

Chiffre les données d’entrée en utilisant le mode de remplissage spécifié.

(Hérité de RSA)
EncryptValue(Byte[])
Obsolète.

Cette méthode n’est pas prise en charge dans la version actuelle.

EncryptValue(Byte[])
Obsolète.

En cas de remplacement dans une classe dérivée, chiffre les données d'entrée en utilisant la clé publique.

(Hérité de RSA)
Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
ExportCspBlob(Boolean)

Exporte un objet blob qui contient les informations clés associées à un objet RSACryptoServiceProvider.

ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters)

Exporte la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo avec un mot de passe basé sur l’octet.

(Hérité de AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters)

Exporte la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo avec un mot de passe basé sur char.

(Hérité de AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Byte>, PbeParameters)

Exporte la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo avec un mot de passe basé sur des octets, encodé en PEM.

(Hérité de AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Char>, PbeParameters)

Exporte la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo avec un mot de passe basé sur char, encodé pem.

(Hérité de AsymmetricAlgorithm)
ExportParameters(Boolean)

Exporte les RSAParameters.

ExportPkcs8PrivateKey()

Exporte la clé actuelle au format PKCS#8 PrivateKeyInfo.

(Hérité de AsymmetricAlgorithm)
ExportPkcs8PrivateKeyPem()

Exporte la clé actuelle au format PKCS#8 PrivateKeyInfo, encodé en PEM.

(Hérité de AsymmetricAlgorithm)
ExportRSAPrivateKey()

Exporte la clé actuelle au format PKCS#1 RSAPrivateKey.

(Hérité de RSA)
ExportRSAPrivateKeyPem()

Exporte la clé actuelle au format RSAPrivateKey PKCS#1, encodé en PEM.

(Hérité de RSA)
ExportRSAPublicKey()

Exporte la partie clé publique de la clé actuelle au format PKCS#1 RSAPublicKey.

(Hérité de RSA)
ExportRSAPublicKeyPem()

Exporte la partie clé publique de la clé actuelle au format RSAPublicKey PKCS#1, encodé en PEM.

(Hérité de RSA)
ExportSubjectPublicKeyInfo()

Exporte la partie clé publique de la clé actuelle au format X.509 SubjectPublicKeyInfo.

(Hérité de AsymmetricAlgorithm)
ExportSubjectPublicKeyInfoPem()

Exporte la partie clé publique de la clé actuelle au format X.509 SubjectPublicKeyInfo, encodé en PEM.

(Hérité de AsymmetricAlgorithm)
Finalize()

Libère les ressources non managées détenues par cette instance.

FromXmlString(String)

Initialise un objet RSA à partir des informations de clé d'une chaîne XML.

(Hérité de RSA)
GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetMaxOutputSize()

Obtient le nombre maximal d’octets qu’une opération RSA peut produire.

(Hérité de RSA)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
HashData(Byte[], Int32, Int32, HashAlgorithmName)

En cas de remplacement dans une classe dérivée, calcule la valeur de hachage de la partie spécifiée d’un tableau d’octets à l’aide d’un algorithme de hachage spécifié.

(Hérité de RSA)
HashData(Stream, HashAlgorithmName)

En cas de remplacement dans une classe dérivée, calcule la valeur de hachage du flux binaire spécifié en utilisant un algorithme de hachage spécifié.

(Hérité de RSA)
ImportCspBlob(Byte[])

Importe un objet blob qui représente des informations de clé RSA.

ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Int32)

Importe la paire de clés publique/privée à partir d’une structure PKCS#8 EncryptedPrivateKeyInfo après le déchiffrement avec un mot de passe basé sur l’octet, en remplaçant les clés de cet objet.

ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Int32)

Importe la paire de clés publique/privée à partir d’une structure PKCS#8 EncryptedPrivateKeyInfo après le déchiffrement avec un mot de passe basé sur l’octet, en remplaçant les clés de cet objet.

(Hérité de RSA)
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Int32)

Importe la paire de clés publique/privée à partir d’une structure PKCS#8 EncryptedPrivateKeyInfo après le déchiffrement avec un mot de passe basé sur char, en remplaçant les clés de cet objet.

ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Int32)

Importe la paire de clés publique/privée à partir d’une structure PKCS#8 EncryptedPrivateKeyInfo après le déchiffrement avec un mot de passe basé sur char, en remplaçant les clés de cet objet.

(Hérité de RSA)
ImportFromEncryptedPem(ReadOnlySpan<Char>, ReadOnlySpan<Byte>)

Importe une clé privée chiffrée encodée en PEM RFC 7468, en remplaçant les clés de cet objet.

(Hérité de RSA)
ImportFromEncryptedPem(ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Importe une clé privée chiffrée encodée en PEM RFC 7468, en remplaçant les clés de cet objet.

(Hérité de RSA)
ImportFromPem(ReadOnlySpan<Char>)

Importe une clé encodée EN PEM RFC 7468, en remplaçant les clés de cet objet.

(Hérité de RSA)
ImportParameters(RSAParameters)

Importe le RSAParameters spécifié.

ImportPkcs8PrivateKey(ReadOnlySpan<Byte>, Int32)

Importe la paire de clés publique/privée à partir d’une structure PKCS#8 PrivateKeyInfo après le déchiffrement, en remplaçant les clés de cet objet.

(Hérité de RSA)
ImportRSAPrivateKey(ReadOnlySpan<Byte>, Int32)

Importe la paire de clés publique/privée à partir d’une structure PKCS#1 RSAPrivateKey après le déchiffrement, en remplaçant les clés de cet objet.

(Hérité de RSA)
ImportRSAPublicKey(ReadOnlySpan<Byte>, Int32)

Importe la clé publique à partir d’une structure PKCS#1 RSAPublicKey après le déchiffrement, en remplaçant les clés de cet objet.

(Hérité de RSA)
ImportSubjectPublicKeyInfo(ReadOnlySpan<Byte>, Int32)

Importe la clé publique à partir d’une structure X.509 SubjectPublicKeyInfo après le déchiffrement, en remplaçant les clés de cet objet.

(Hérité de RSA)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
SignData(Byte[], HashAlgorithmName, RSASignaturePadding)

Calcule la valeur de hachage du tableau d’octets spécifié en utilisant l’algorithme de hachage et le mode de remplissage spécifiés, et signe la valeur de hachage obtenue.

(Hérité de RSA)
SignData(Byte[], Int32, Int32, HashAlgorithmName, RSASignaturePadding)

Calcule la valeur de hachage d’une partie du tableau d’octets indiqué à l’aide de l’algorithme de hachage et du mode de remplissage spécifiés, et signe la valeur de hachage obtenue.

(Hérité de RSA)
SignData(Byte[], Int32, Int32, Object)

Calcule la valeur de hachage d’un sous-ensemble du tableau d’octets indiqué à l’aide de l’algorithme de hachage spécifié et signe la valeur de hachage obtenue.

SignData(Byte[], Object)

Calcule la valeur de hachage du tableau d’octets indiqué à l’aide de l’algorithme de hachage spécifié et signe la valeur de hachage obtenue.

SignData(ReadOnlySpan<Byte>, HashAlgorithmName, RSASignaturePadding)

Calcule la valeur de hachage des données spécifiées et la signe.

(Hérité de RSA)
SignData(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, RSASignaturePadding)

Calcule le hachage des données fournies avec l’algorithme spécifié et signe le hachage avec la clé actuelle, en écrivant la signature dans une mémoire tampon fournie.

(Hérité de RSA)
SignData(Stream, HashAlgorithmName, RSASignaturePadding)

Calcule la valeur de hachage du flux spécifié en utilisant l’algorithme de hachage et le mode de remplissage spécifiés, et signe la valeur de hachage obtenue.

(Hérité de RSA)
SignData(Stream, Object)

Calcule la valeur de hachage du flux d’entrée spécifié à l’aide de l’algorithme de hachage spécifié, puis signe la valeur de hachage obtenue.

SignHash(Byte[], HashAlgorithmName, RSASignaturePadding)

Calcule la signature pour la valeur de hachage spécifiée à l’aide du remplissage spécifié.

SignHash(Byte[], HashAlgorithmName, RSASignaturePadding)

En cas de substitution dans une classe dérivée, calcule la signature pour la valeur de hachage spécifiée à l’aide du remplissage spécifié.

(Hérité de RSA)
SignHash(Byte[], String)

Calcule la signature pour la valeur de hachage spécifiée.

SignHash(ReadOnlySpan<Byte>, HashAlgorithmName, RSASignaturePadding)

Calcule la signature pour la valeur de hachage spécifiée à l’aide du remplissage spécifié.

(Hérité de RSA)
SignHash(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, RSASignaturePadding)

Signe le hachage avec la clé actuelle, en écrivant la signature dans une mémoire tampon fournie.

(Hérité de RSA)
ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)
ToXmlString(Boolean)

Crée et retourne une chaîne XML contenant la clé de l'objet RSA actif.

(Hérité de RSA)
TryDecrypt(ReadOnlySpan<Byte>, Span<Byte>, RSAEncryptionPadding, Int32)

Tente de déchiffrer les données d’entrée à l’aide du mode de remplissage spécifié, en écrivant le résultat dans une mémoire tampon fournie.

(Hérité de RSA)
TryEncrypt(ReadOnlySpan<Byte>, Span<Byte>, RSAEncryptionPadding, Int32)

Tente de chiffrer les données d’entrée avec un mode de remplissage spécifié dans une mémoire tampon fournie.

(Hérité de RSA)
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters, Span<Byte>, Int32)

Tente d’exporter la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo dans une mémoire tampon fournie, à l’aide d’un mot de passe basé sur l’octet.

(Hérité de RSA)
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters, Span<Byte>, Int32)

Tente d’exporter la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo dans une mémoire tampon fournie, à l’aide d’un mot de passe basé sur char.

(Hérité de RSA)
TryExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Byte>, PbeParameters, Span<Char>, Int32)

Tente d’exporter la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo avec un mot de passe basé sur des octets, encodé pem.

(Hérité de AsymmetricAlgorithm)
TryExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Char>, PbeParameters, Span<Char>, Int32)

Exporte la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo avec un mot de passe basé sur char, encodé pem.

(Hérité de AsymmetricAlgorithm)
TryExportPkcs8PrivateKey(Span<Byte>, Int32)

Tente d’exporter la clé actuelle au format PKCS#8 PrivateKeyInfo dans une mémoire tampon fournie.

(Hérité de RSA)
TryExportPkcs8PrivateKeyPem(Span<Char>, Int32)

Tente d’exporter la clé actuelle au format PKCS#8 PrivateKeyInfo encodé en PEM dans une mémoire tampon fournie.

(Hérité de AsymmetricAlgorithm)
TryExportRSAPrivateKey(Span<Byte>, Int32)

Tente d’exporter la clé actuelle au format PKCS#1 RSAPrivateKey dans une mémoire tampon fournie.

(Hérité de RSA)
TryExportRSAPrivateKeyPem(Span<Char>, Int32)

Tente d’exporter la clé actuelle au format RSAPrivateKey PKCS#1 codé en PEM dans une mémoire tampon fournie.

(Hérité de RSA)
TryExportRSAPublicKey(Span<Byte>, Int32)

Tente d’exporter la clé actuelle au format PKCS#1 RSAPublicKey dans une mémoire tampon fournie.

(Hérité de RSA)
TryExportRSAPublicKeyPem(Span<Char>, Int32)

Tente d’exporter la clé actuelle au format RSAPublicKey PKCS#1 codé en PEM dans une mémoire tampon fournie.

(Hérité de RSA)
TryExportSubjectPublicKeyInfo(Span<Byte>, Int32)

Tente d’exporter la clé actuelle au format X.509 SubjectPublicKeyInfo dans une mémoire tampon fournie.

(Hérité de RSA)
TryExportSubjectPublicKeyInfoPem(Span<Char>, Int32)

Tente d’exporter la clé actuelle au format X.509 SubjectPublicKeyInfo encodé en PEM dans une mémoire tampon fournie.

(Hérité de AsymmetricAlgorithm)
TryHashData(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, Int32)

Tente de calculer le hachage des données fournies à l’aide de l’algorithme spécifié, en écrivant les résultats dans une mémoire tampon fournie.

(Hérité de RSA)
TrySignData(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, RSASignaturePadding, Int32)

Tente de hacher les données fournies avec l’algorithme spécifié et de signer le hachage avec la clé actuelle, en écrivant la signature dans une mémoire tampon fournie.

(Hérité de RSA)
TrySignHash(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, RSASignaturePadding, Int32)

Tente de signer le hachage avec la clé actuelle, en écrivant la signature dans une mémoire tampon fournie.

(Hérité de RSA)
VerifyData(Byte[], Byte[], HashAlgorithmName, RSASignaturePadding)

Vérifie qu’une signature numérique est valide en calculant la valeur de hachage des données indiquées à l’aide de l’algorithme de hachage et du remplissage spécifiés, et en la comparant à la signature fournie.

(Hérité de RSA)
VerifyData(Byte[], Int32, Int32, Byte[], HashAlgorithmName, RSASignaturePadding)

Vérifie qu’une signature numérique est valide en calculant la valeur de hachage des données dans une partie d’un tableau d’octets à l’aide de l’algorithme de hachage et du remplissage spécifiés, et en la comparant à la signature fournie.

(Hérité de RSA)
VerifyData(Byte[], Object, Byte[])

Vérifie qu’une signature numérique est valide en déterminant la valeur de hachage dans la signature en utilisant la clé publique fournie et en la comparant à la valeur de hachage des données fournies.

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

Vérifie qu’une signature numérique est valide en calculant la valeur de hachage des données indiquées à l’aide de l’algorithme de hachage et du remplissage spécifiés, et en la comparant à la signature fournie.

(Hérité de RSA)
VerifyData(Stream, Byte[], HashAlgorithmName, RSASignaturePadding)

Vérifie qu’une signature numérique est valide en calculant la valeur de hachage du flux spécifié en utilisant l’algorithme de hachage et le remplissage spécifiés, et en la comparant à la signature fournie.

(Hérité de RSA)
VerifyHash(Byte[], Byte[], HashAlgorithmName, RSASignaturePadding)

Vérifie qu’une signature numérique est valide en déterminant la valeur de hachage dans la signature en utilisant l’algorithme de hachage et le remplissage spécifiés, et en la comparant à la valeur de hachage fournie.

VerifyHash(Byte[], Byte[], HashAlgorithmName, RSASignaturePadding)

Vérifie qu’une signature numérique est valide en déterminant la valeur de hachage dans la signature en utilisant l’algorithme de hachage et le remplissage spécifiés, et en la comparant à la valeur de hachage fournie.

(Hérité de RSA)
VerifyHash(Byte[], String, Byte[])

Vérifie qu’une signature numérique est valide en déterminant la valeur de hachage dans la signature en utilisant la clé publique fournie et en la comparant à la valeur de hachage fournie.

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

Vérifie qu’une signature numérique est valide en déterminant la valeur de hachage dans la signature en utilisant l’algorithme de hachage et le remplissage spécifiés, et en la comparant à la valeur de hachage fournie.

(Hérité de RSA)

Implémentations d’interfaces explicites

IDisposable.Dispose()

Cette API prend en charge l'infrastructure du produit et n'est pas destinée à être utilisée directement à partir de votre code.

Pour obtenir une description de ce membre, consultez Dispose().

(Hérité de AsymmetricAlgorithm)

S’applique à

Voir aussi