RSACryptoServiceProvider Classe

Définition

Procède au chiffrement et au déchiffrement asymétriques à l'aide de l'implémentation de l'algorithme RSA fourni par le fournisseur de services de chiffrement (CSP).Performs asymmetric encryption and decryption using the implementation of the RSA algorithm provided by the cryptographic service provider (CSP). Cette classe ne peut pas être héritée.This class cannot be inherited.

public ref class RSACryptoServiceProvider sealed : System::Security::Cryptography::RSA, System::Security::Cryptography::ICspAsymmetricAlgorithm
[System.Runtime.InteropServices.ComVisible(true)]
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
Héritage
RSACryptoServiceProvider
Attributs
Implémente

Exemples

L’exemple de code suivant utilise la classe RSACryptoServiceProvider pour chiffrer une chaîne en un tableau d’octets, puis déchiffrer les octets dans une chaîne.The following code example uses the RSACryptoServiceProvider class to encrypt a string into an array of bytes and then decrypt the bytes back into a string.

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

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

}

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

}

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

}

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

class RSACSPSample
{

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

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

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

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

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

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

        }
    }

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

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

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

            return null;
        }

    }

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

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

            return null;
        }

    }
}
Imports System.Security.Cryptography
Imports System.Text

 _

Class RSACSPSample


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

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

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

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

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

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


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

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

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

            Return Nothing
        End Try
    End Function


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

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

            Return Nothing
        End Try
    End Function
End Class

L’exemple de code suivant exporte les informations de clé créées à l’aide de l' RSACryptoServiceProvider dans un objet RSAParameters.The following code example exports the key information created using the RSACryptoServiceProvider into an RSAParameters object.

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


        //Export the key information to an RSAParameters object.
        //Pass false to export the public key information or pass
        //true to export public and private key information.
        RSAParameters RSAParams = RSA.ExportParameters(false);
    }


}
catch (CryptographicException e)
{
    //Catch this exception in case the encryption did
    //not succeed.
    Console.WriteLine(e.Message);

}
Try

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

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


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

Remarques

Il s’agit de l’implémentation par défaut de RSA.This is the default implementation of RSA.

Le RSACryptoServiceProvider prend en charge des tailles de clé de 384 bits à 16384 bits par incréments de 8 bits si le fournisseur de services de chiffrement Microsoft Enhanced est installé.The RSACryptoServiceProvider supports key sizes from 384 bits to 16384 bits in increments of 8 bits if you have the Microsoft Enhanced Cryptographic Provider installed. Il prend en charge des tailles de clé de 384 bits à 512 bits par incréments de 8 bits si le fournisseur de services de chiffrement de base Microsoft est installé.It supports key sizes from 384 bits to 512 bits in increments of 8 bits if you have the Microsoft Base Cryptographic Provider installed.

Les tailles de clé valides dépendent du fournisseur de services de chiffrement (CSP) utilisé par l’instance RSACryptoServiceProvider.Valid key sizes are dependent on the cryptographic service provider (CSP) that is used by the RSACryptoServiceProvider instance. Les fournisseurs de services de chiffrement Windows activent des tailles de clés de 384 à 16384 bits pour les versions de Windows antérieures à Windows 8.1Windows 8.1et des tailles de clé de 512 à 16384 bits pour les Windows 8.1Windows 8.1.Windows CSPs enable keys sizes of 384 to 16384 bits for Windows versions prior to Windows 8.1Windows 8.1, and key sizes of 512 to 16384 bits for Windows 8.1Windows 8.1. Pour plus d’informations, consultez fonction CryptGenKey dans la documentation de Windows.For more information, see CryptGenKey function in the Windows documentation.

Interopérabilité avec l’API de chiffrement Microsoft (CAPI)Interoperation with the Microsoft Cryptographic API (CAPI)

Contrairement à l’implémentation RSA dans CAPI non managé, la classe RSACryptoServiceProvider inverse l’ordre d’un tableau chiffré d’octets après le chiffrement et avant le déchiffrement.Unlike the RSA implementation in unmanaged CAPI, the RSACryptoServiceProvider class reverses the order of an encrypted array of bytes after encryption and before decryption. Par défaut, les données chiffrées par la classe RSACryptoServiceProvider ne peuvent pas être déchiffrées par la fonction CAPI CryptDecrypt et les données chiffrées par la méthode CAPI CryptEncrypt ne peuvent pas être déchiffrées par la classe RSACryptoServiceProvider.By default, data encrypted by the RSACryptoServiceProvider class cannot be decrypted by the CAPI CryptDecrypt function and data encrypted by the CAPI CryptEncrypt method cannot be decrypted by the RSACryptoServiceProvider class.

Si vous ne compensez pas l’ordre inverse lors de l’interopérabilité entre les API, la classe RSACryptoServiceProvider lève une CryptographicException.If you do not compensate for the reverse ordering when interoperating between APIs, the RSACryptoServiceProvider class throws a CryptographicException.

Pour interagir avec CAPI, vous devez inverser manuellement l’ordre des octets chiffrés avant que les données chiffrées interagissent avec une autre API.To interoperate with CAPI, you must manually reverse the order of encrypted bytes before the encrypted data interoperates with another API. Vous pouvez facilement inverser l’ordre d’un tableau d’octets managé en appelant la méthode Array.Reverse.You can easily reverse the order of a managed byte array by calling the Array.Reverse method.

Constructeurs

RSACryptoServiceProvider()

Initialise une nouvelle instance de la classe RSACryptoServiceProvider en utilisant la clé par défaut.Initializes a new instance of the RSACryptoServiceProvider class using the default key.

RSACryptoServiceProvider(CspParameters)

Initialise une nouvelle instance de la classe RSACryptoServiceProvider avec les paramètres spécifiés.Initializes a new instance of the RSACryptoServiceProvider class with the specified parameters.

RSACryptoServiceProvider(Int32)

Initialise une nouvelle instance de la classe RSACryptoServiceProvider avec la taille de clé spécifiée.Initializes a new instance of the RSACryptoServiceProvider class with the specified key size.

RSACryptoServiceProvider(Int32, CspParameters)

Initialise une nouvelle instance de la classe RSACryptoServiceProvider avec les paramètres et la taille de clé spécifiés.Initializes a new instance of the RSACryptoServiceProvider class with the specified key size and parameters.

Champs

KeySizeValue

Représente la taille, en bits, du modulo de la clé utilisé par l'algorithme asymétrique.Represents the size, in bits, of the key modulus used by the asymmetric algorithm.

(Hérité de AsymmetricAlgorithm)
LegalKeySizesValue

Spécifie les tailles de clé prises en charge par l'algorithme asymétrique.Specifies the key sizes that are supported by the asymmetric algorithm.

(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.Gets a CspKeyContainerInfo object that describes additional information about a cryptographic key pair.

KeyExchangeAlgorithm

Obtient le nom de l’algorithme d’échange de clés disponible avec cette implémentation de RSA.Gets the name of the key exchange algorithm available with this implementation of RSA.

KeySize

Obtient la taille de la clé en cours.Gets the size of the current key.

LegalKeySizes

Obtient les tailles de clé prises en charge par l'algorithme asymétrique.Gets the key sizes that are supported by the asymmetric algorithm.

PersistKeyInCsp

Obtient ou définit une valeur qui indique si la clé doit être persistante dans le fournisseur de services de chiffrement (CSP).Gets or sets a value indicating whether the key should be persisted in the cryptographic service provider (CSP).

PublicOnly

Obtient une valeur qui indique si l'objet RSACryptoServiceProvider ne contient qu'une clé publique.Gets a value that indicates whether the RSACryptoServiceProvider object contains only a public key.

SignatureAlgorithm

Obtient le nom de l’algorithme de signature disponible avec cette implémentation de RSA.Gets the name of the signature algorithm available with this implementation of 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.Gets or sets a value indicating whether the key should be persisted in the computer's key store instead of the user profile store.

Méthodes

Clear()

Libère toutes les ressources utilisées par la classe AsymmetricAlgorithm.Releases all resources used by the AsymmetricAlgorithm class.

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

Déchiffre les données avec l'algorithme RSA.Decrypts data with the RSA algorithm.

Decrypt(Byte[], RSAEncryptionPadding)

Déchiffre les données précédemment chiffrées avec l’algorithme RSA à l’aide du remplissage spécifié.Decrypts data that was previously encrypted with the RSA algorithm by using the specified padding.

DecryptValue(Byte[])

Cette méthode n’est pas prise en charge dans la version actuelle.This method is not supported in the current version.

Dispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe AsymmetricAlgorithm.Releases all resources used by the current instance of the AsymmetricAlgorithm class.

(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.Releases the unmanaged resources used by the AsymmetricAlgorithm class and optionally releases the managed resources.

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

Chiffre les données avec l’algorithme RSA.Encrypts data with the RSA algorithm.

Encrypt(Byte[], RSAEncryptionPadding)

Chiffre les données avec l’algorithme RSA à l’aide du remplissage spécifié.Encrypts data with the RSA algorithm using the specified padding.

EncryptValue(Byte[])

Cette méthode n'est pas prise en charge dans la version actuelle.This method is not supported in the current version.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

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

Exporte un blob qui contient les informations de clés associées à un objet RSACryptoServiceProvider.Exports a blob containing the key information associated with an RSACryptoServiceProvider object.

ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters)

Exporte la clé actuelle au format PKCS#8 EncryptedPrivateKeyInfo avec un mot de passe basé sur l’octet.Exports the current key in the PKCS#8 EncryptedPrivateKeyInfo format with a byte-based password.

(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.Exports the current key in the PKCS#8 EncryptedPrivateKeyInfo format with a char-based password.

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

Exporte les RSAParameters.Exports the RSAParameters.

ExportPkcs8PrivateKey()

Exporte la clé actuelle au format PKCS#8 PrivateKeyInfo.Exports the current key in the PKCS#8 PrivateKeyInfo format.

(Hérité de AsymmetricAlgorithm)
ExportRSAPrivateKey()

Exporte la clé actuelle au format PKCS#1 RSAPrivateKey.Exports the current key in the PKCS#1 RSAPrivateKey format.

(Hérité de RSA)
ExportRSAPublicKey()

Exporte la partie clé publique de la clé actuelle au format PKCS#1 RSAPublicKey.Exports the public-key portion of the current key in the PKCS#1 RSAPublicKey format.

(Hérité de RSA)
ExportSubjectPublicKeyInfo()

Exporte la partie clé publique de la clé actuelle au format X.509 SubjectPublicKeyInfo.Exports the public-key portion of the current key in the X.509 SubjectPublicKeyInfo format.

(Hérité de AsymmetricAlgorithm)
Finalize()
FromXmlString(String)

Initialise un objet RSA à partir des informations de clé d'une chaîne XML.Initializes an RSA object from the key information from an XML string.

(Hérité de RSA)
GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(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é.When overridden in a derived class, computes the hash value of a specified portion of a byte array by using a specified hashing algorithm.

(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é.When overridden in a derived class, computes the hash value of a specified binary stream by using a specified hashing algorithm.

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

Importe un objet blob qui représente des informations de clé RSA.Imports a blob that represents RSA key information.

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.Imports the public/private keypair from a PKCS#8 EncryptedPrivateKeyInfo structure after decrypting with a byte-based password, replacing the keys for this object.

(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.Imports the public/private keypair from a PKCS#8 EncryptedPrivateKeyInfo structure after decrypting with a char-based password, replacing the keys for this object.

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

Importe le RSAParameters spécifié.Imports the specified RSAParameters.

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.Imports the public/private keypair from a PKCS#8 PrivateKeyInfo structure after decryption, replacing the keys for this object.

(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.Imports the public/private keypair from a PKCS#1 RSAPrivateKey structure after decryption, replacing the keys for this object.

(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.Imports the public key from a PKCS#1 RSAPublicKey structure after decryption, replacing the keys for this object.

(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.Imports the public key from an X.509 SubjectPublicKeyInfo structure after decryption, replacing the keys for this object.

(Hérité de RSA)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(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.Computes the hash value of the specified byte array using the specified hash algorithm and padding mode, and signs the resulting hash value.

(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.Computes the hash value of a portion of the specified byte array using the specified hash algorithm and padding mode, and signs the resulting hash value.

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

Calcule la valeur de hachage d'un sous-ensemble du tableau d'octets spécifié à l'aide de l'algorithme de hachage spécifié et signe la valeur de hachage qui en résulte.Computes the hash value of a subset of the specified byte array using the specified hash algorithm, and signs the resulting hash value.

SignData(Byte[], Object)

Calcule la valeur de hachage du tableau d'octets spécifié à l'aide de l'algorithme de hachage indiqué et signe la valeur de hachage qui en résulte.Computes the hash value of the specified byte array using the specified hash algorithm, and signs the resulting hash value.

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.Computes the hash value of the specified stream using the specified hash algorithm and padding mode, and signs the resulting hash value.

(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é et signe la valeur de hachage qui en résulte.Computes the hash value of the specified input stream using the specified hash algorithm, and signs the resulting hash value.

SignHash(Byte[], HashAlgorithmName, RSASignaturePadding)

Calcule la signature pour la valeur de hachage spécifiée en la chiffrant avec la clé privée à l’aide du remplissage spécifié.Computes the signature for the specified hash value by encrypting it with the private key using the specified padding.

SignHash(Byte[], String)

Calcule la signature pour la valeur de hachage spécifiée en la chiffrant avec la clé privée.Computes the signature for the specified hash value by encrypting it with the private key.

ToString()

Retourne une chaîne qui représente l'objet en cours.Returns a string that represents the current object.

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

Crée et retourne une chaîne XML contenant la clé de l'objet RSA actif.Creates and returns an XML string containing the key of the current RSA object.

(Hérité de RSA)
TryDecrypt(ReadOnlySpan<Byte>, Span<Byte>, RSAEncryptionPadding, Int32) (Hérité de RSA)
TryEncrypt(ReadOnlySpan<Byte>, Span<Byte>, RSAEncryptionPadding, Int32) (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.Attempts to export the current key in the PKCS#8 EncryptedPrivateKeyInfo format into a provided buffer, using a byte-based password.

(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.Attempts to export the current key in the PKCS#8 EncryptedPrivateKeyInfo format into a provided buffer, using a char-based password.

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

Tente d’exporter la clé actuelle au format PKCS#8 PrivateKeyInfo dans une mémoire tampon fournie.Attempts to export the current key in the PKCS#8 PrivateKeyInfo format into a provided buffer.

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

Tente d’exporter la clé actuelle au format PKCS#1 RSAPrivateKey dans une mémoire tampon fournie.Attempts to export the current key in the PKCS#1 RSAPrivateKey format into a provided buffer.

(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.Attempts to export the current key in the PKCS#1 RSAPublicKey format into a provided buffer.

(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.Attempts to export the current key in the X.509 SubjectPublicKeyInfo format into a provided buffer.

(Hérité de RSA)
TryHashData(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, Int32) (Hérité de RSA)
TrySignData(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, RSASignaturePadding, Int32) (Hérité de RSA)
TrySignHash(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, RSASignaturePadding, Int32) (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.Verifies that a digital signature is valid by calculating the hash value of the specified data using the specified hash algorithm and padding, and comparing it to the provided signature.

(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.Verifies that a digital signature is valid by calculating the hash value of the data in a portion of a byte array using the specified hash algorithm and padding, and comparing it to the provided signature.

(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.Verifies that a digital signature is valid by determining the hash value in the signature using the provided public key and comparing it to the hash value of the provided data.

VerifyData(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, HashAlgorithmName, RSASignaturePadding) (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.Verifies that a digital signature is valid by calculating the hash value of the specified stream using the specified hash algorithm and padding, and comparing it to the provided signature.

(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.Verifies that a digital signature is valid by determining the hash value in the signature using the specified hashing algorithm and padding, and comparing it to the provided hash value.

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

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.Verifies that a digital signature is valid by determining the hash value in the signature using the provided public key and comparing it to the provided hash value.

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

Implémentations d’interfaces explicites

IDisposable.Dispose()

Pour obtenir une description de ce membre, consultez Dispose().For a description of this member, see Dispose().

(Hérité de AsymmetricAlgorithm)

S’applique à

Voir aussi