RSACryptoServiceProvider Classe

Definizione

Esegue la crittografia e la decrittografia asimmetrica utilizzando l'implementazione dell'algoritmo RSA fornito dal provider del servizio di crittografia (CSP).Performs asymmetric encryption and decryption using the implementation of the RSA algorithm provided by the cryptographic service provider (CSP). Questa classe non può essere ereditata.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
Ereditarietà
RSACryptoServiceProvider
Attributi
Implementazioni

Esempi

Nell'esempio di codice seguente viene usata la classe RSACryptoServiceProvider per crittografare una stringa in una matrice di byte e quindi decrittografare i byte di nuovo in una stringa.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

Nell'esempio di codice seguente vengono esportate le informazioni sulla chiave create utilizzando il RSACryptoServiceProvider in un oggetto 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

Commenti

Si tratta dell'implementazione predefinita di RSA.This is the default implementation of RSA.

Il RSACryptoServiceProvider supporta le dimensioni delle chiavi da 384 bit a 16384 bit a incrementi di 8 bit se è installato Microsoft Enhanced Cryptographic Provider.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. Supporta le dimensioni delle chiavi da 384 bit a 512 bit a incrementi di 8 bit se è installato Microsoft Base Cryptographic Provider.It supports key sizes from 384 bits to 512 bits in increments of 8 bits if you have the Microsoft Base Cryptographic Provider installed.

Le dimensioni valide delle chiavi dipendono dal provider del servizio di crittografia (CSP) usato dall'istanza di RSACryptoServiceProvider.Valid key sizes are dependent on the cryptographic service provider (CSP) that is used by the RSACryptoServiceProvider instance. I DSN di Windows abilitano le dimensioni delle chiavi da 384 a 16384 bit per le versioni di Windows precedenti a Windows 8,1Windows 8.1e le dimensioni delle chiavi da 512 a 16384 bit per 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. Per ulteriori informazioni, vedere la funzione CryptGenKey nella documentazione di Windows.For more information, see CryptGenKey function in the Windows documentation.

Interoperabilità con l'API di crittografia Microsoft (CAPI)Interoperation with the Microsoft Cryptographic API (CAPI)

A differenza dell'implementazione RSA in CAPI non gestiti, la classe RSACryptoServiceProvider inverte l'ordine di una matrice crittografata di byte dopo la crittografia e prima della decrittografia.Unlike the RSA implementation in unmanaged CAPI, the RSACryptoServiceProvider class reverses the order of an encrypted array of bytes after encryption and before decryption. Per impostazione predefinita, i dati crittografati dalla classe RSACryptoServiceProvider non possono essere decrittografati dalla funzione CAPI CryptDecrypt e i dati crittografati dal metodo CAPI CryptEncrypt non possono essere decrittografati dalla 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.

Se non si compensa l'ordine inverso durante l'interoperabilità tra le API, la classe RSACryptoServiceProvider genera un'CryptographicException.If you do not compensate for the reverse ordering when interoperating between APIs, the RSACryptoServiceProvider class throws a CryptographicException.

Per interagire con CAPI, è necessario invertire manualmente l'ordine dei byte crittografati prima che i dati crittografati interagiscano con un'altra API.To interoperate with CAPI, you must manually reverse the order of encrypted bytes before the encrypted data interoperates with another API. È possibile invertire facilmente l'ordine di una matrice di byte gestita chiamando il metodo Array.Reverse.You can easily reverse the order of a managed byte array by calling the Array.Reverse method.

Costruttori

RSACryptoServiceProvider()

Inizializza una nuova istanza della classe RSACryptoServiceProvider usando la chiave predefinita.Initializes a new instance of the RSACryptoServiceProvider class using the default key.

RSACryptoServiceProvider(CspParameters)

Inizializza una nuova istanza della classe RSACryptoServiceProvider con i parametri specificati.Initializes a new instance of the RSACryptoServiceProvider class with the specified parameters.

RSACryptoServiceProvider(Int32)

Inizializza una nuova istanza della classe RSACryptoServiceProvider con la dimensione della chiave specificata.Initializes a new instance of the RSACryptoServiceProvider class with the specified key size.

RSACryptoServiceProvider(Int32, CspParameters)

Inizializza una nuova istanza della classe RSACryptoServiceProvider con la dimensione e i parametri di chiave specificati.Initializes a new instance of the RSACryptoServiceProvider class with the specified key size and parameters.

Campi

KeySizeValue

Rappresenta la dimensione in bit del modulo della chiave usato dall'algoritmo asimmetrico.Represents the size, in bits, of the key modulus used by the asymmetric algorithm.

(Ereditato da AsymmetricAlgorithm)
LegalKeySizesValue

Specifica le dimensioni delle chiavi supportate dall'algoritmo asimmetrico.Specifies the key sizes that are supported by the asymmetric algorithm.

(Ereditato da AsymmetricAlgorithm)

Proprietà

CspKeyContainerInfo

Ottiene un oggetto CspKeyContainerInfo che descrive informazioni aggiuntive su una coppia di chiavi crittografiche.Gets a CspKeyContainerInfo object that describes additional information about a cryptographic key pair.

KeyExchangeAlgorithm

Ottiene il nome dell'algoritmo di scambio delle chiavi disponibile con l'implementazione di RSA.Gets the name of the key exchange algorithm available with this implementation of RSA.

KeySize

Ottiene la dimensione della chiave corrente.Gets the size of the current key.

LegalKeySizes

Ottiene le dimensioni delle chiavi supportate dall'algoritmo asimmetrico.Gets the key sizes that are supported by the asymmetric algorithm.

PersistKeyInCsp

Ottiene o imposta un valore che indica se la chiave deve essere mantenuta nel provider del servizio di crittografia (CSP).Gets or sets a value indicating whether the key should be persisted in the cryptographic service provider (CSP).

PublicOnly

Ottiene un valore che indica se l'oggetto RSACryptoServiceProvider contiene solo una chiave pubblica.Gets a value that indicates whether the RSACryptoServiceProvider object contains only a public key.

SignatureAlgorithm

Ottiene il nome dell'algoritmo di firma disponibile con l'implementazione di RSA.Gets the name of the signature algorithm available with this implementation of RSA.

UseMachineKeyStore

Ottiene o imposta un valore che indica se la chiave deve essere mantenuta nell'archivio delle chiavi del computer invece che nell'archivio del profilo utente.Gets or sets a value indicating whether the key should be persisted in the computer's key store instead of the user profile store.

Metodi

Clear()

Rilascia tutte le risorse usate dalla classe AsymmetricAlgorithm.Releases all resources used by the AsymmetricAlgorithm class.

(Ereditato da AsymmetricAlgorithm)
Decrypt(Byte[], Boolean)

Decrittografa i dati con l'algoritmo RSA.Decrypts data with the RSA algorithm.

Decrypt(Byte[], RSAEncryptionPadding)

Decrittografa i dati precedentemente crittografati con l'algoritmo RSA usando il riempimento specificato.Decrypts data that was previously encrypted with the RSA algorithm by using the specified padding.

DecryptValue(Byte[])

Metodo non supportato nella versione corrente.This method is not supported in the current version.

Dispose()

Rilascia tutte le risorse usate dall'istanza corrente della classe AsymmetricAlgorithm.Releases all resources used by the current instance of the AsymmetricAlgorithm class.

(Ereditato da AsymmetricAlgorithm)
Dispose(Boolean)

Rilascia le risorse non gestite usate dalla classe AsymmetricAlgorithm e facoltativamente le risorse gestite.Releases the unmanaged resources used by the AsymmetricAlgorithm class and optionally releases the managed resources.

(Ereditato da AsymmetricAlgorithm)
Encrypt(Byte[], Boolean)

Crittografa i dati con l'algoritmo RSA.Encrypts data with the RSA algorithm.

Encrypt(Byte[], RSAEncryptionPadding)

Crittografa i dati con l'algoritmo RSA usando il riempimento specificato.Encrypts data with the RSA algorithm using the specified padding.

EncryptValue(Byte[])

Questo metodo non è supportato nella versione corrente.This method is not supported in the current version.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
ExportCspBlob(Boolean)

Esporta un BLOB che contiene le informazioni sulla chiave associate a un oggetto RSACryptoServiceProvider.Exports a blob containing the key information associated with an RSACryptoServiceProvider object.

ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters)

Esporta la chiave corrente nel formato PKCS#8 EncryptedPrivateKeyInfo con una password basata su byte.Exports the current key in the PKCS#8 EncryptedPrivateKeyInfo format with a byte-based password.

(Ereditato da AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters)

Esporta la chiave corrente nel formato PKCS#8 EncryptedPrivateKeyInfo con una password basata su caratteri.Exports the current key in the PKCS#8 EncryptedPrivateKeyInfo format with a char-based password.

(Ereditato da AsymmetricAlgorithm)
ExportParameters(Boolean)

Esporta RSAParameters.Exports the RSAParameters.

ExportPkcs8PrivateKey()

Esporta la chiave corrente nel formato PKCS#8 PrivateKeyInfo.Exports the current key in the PKCS#8 PrivateKeyInfo format.

(Ereditato da AsymmetricAlgorithm)
ExportRSAPrivateKey()

Esporta la chiave corrente nel formato PKCS#1 RSAPrivateKey.Exports the current key in the PKCS#1 RSAPrivateKey format.

(Ereditato da RSA)
ExportRSAPublicKey()

Esporta la parte della chiave pubblica della chiave corrente nel formato PKCS#1 RSAPublicKey.Exports the public-key portion of the current key in the PKCS#1 RSAPublicKey format.

(Ereditato da RSA)
ExportSubjectPublicKeyInfo()

Esporta la parte della chiave pubblica della chiave corrente nel formato X.509 SubjectPublicKeyInfo.Exports the public-key portion of the current key in the X.509 SubjectPublicKeyInfo format.

(Ereditato da AsymmetricAlgorithm)
Finalize()
FromXmlString(String)

Inizializza un oggetto RSA dalle informazioni sulla chiave di una stringa XML.Initializes an RSA object from the key information from an XML string.

(Ereditato da RSA)
GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
HashData(Byte[], Int32, Int32, HashAlgorithmName)

Quando sottoposto a override in una classe derivata, calcola il valore hash di una parte specificata di una matrice di byte usando un algoritmo hash specificato.When overridden in a derived class, computes the hash value of a specified portion of a byte array by using a specified hashing algorithm.

(Ereditato da RSA)
HashData(Stream, HashAlgorithmName)

Quando sottoposto a override in una classe derivata, calcola il valore hash di un flusso binario specificato usando un algoritmo hash specificato.When overridden in a derived class, computes the hash value of a specified binary stream by using a specified hashing algorithm.

(Ereditato da RSA)
ImportCspBlob(Byte[])

Importa un BLOB che rappresenta le informazioni chiave RSA.Imports a blob that represents RSA key information.

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

Importa la coppia di chiavi pubblica/privata da una struttura PKCS#8 EncryptedPrivateKeyInfo dopo la decrittografia con una password basata su byte, sostituendo le chiavi per questo oggetto.Imports the public/private keypair from a PKCS#8 EncryptedPrivateKeyInfo structure after decrypting with a byte-based password, replacing the keys for this object.

(Ereditato da RSA)
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Int32)

Importa la coppia di chiavi pubblica/privata da una struttura PKCS#8 EncryptedPrivateKeyInfo dopo la decrittografia con una password basata su caratteri, sostituendo le chiavi per questo oggetto.Imports the public/private keypair from a PKCS#8 EncryptedPrivateKeyInfo structure after decrypting with a char-based password, replacing the keys for this object.

(Ereditato da RSA)
ImportParameters(RSAParameters)

Importa l'oggetto RSAParameters specificato.Imports the specified RSAParameters.

ImportPkcs8PrivateKey(ReadOnlySpan<Byte>, Int32)

Importa la coppia di chiavi pubblica/privata da una struttura PKCS#8 PrivateKeyInfo dopo la decrittografia, sostituendo le chiavi per questo oggetto.Imports the public/private keypair from a PKCS#8 PrivateKeyInfo structure after decryption, replacing the keys for this object.

(Ereditato da RSA)
ImportRSAPrivateKey(ReadOnlySpan<Byte>, Int32)

Importa la coppia di chiavi pubblica/privata da una struttura PKCS#1 RSAPrivateKey dopo la decrittografia, sostituendo le chiavi per questo oggetto.Imports the public/private keypair from a PKCS#1 RSAPrivateKey structure after decryption, replacing the keys for this object.

(Ereditato da RSA)
ImportRSAPublicKey(ReadOnlySpan<Byte>, Int32)

Importa la chiave pubblica da una struttura PKCS#1 RSAPublicKey dopo la decrittografia, sostituendo le chiavi per questo oggetto.Imports the public key from a PKCS#1 RSAPublicKey structure after decryption, replacing the keys for this object.

(Ereditato da RSA)
ImportSubjectPublicKeyInfo(ReadOnlySpan<Byte>, Int32)

Importa la chiave pubblica da una struttura X.509 SubjectPublicKeyInfo dopo la decrittografia, sostituendo le chiavi per questo oggetto.Imports the public key from an X.509 SubjectPublicKeyInfo structure after decryption, replacing the keys for this object.

(Ereditato da RSA)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
SignData(Byte[], HashAlgorithmName, RSASignaturePadding)

Calcola il valore hash della matrice di byte specificata usando l'algoritmo hash e la modalità di spaziatura interna specificati e firma il valore hash risultante.Computes the hash value of the specified byte array using the specified hash algorithm and padding mode, and signs the resulting hash value.

(Ereditato da RSA)
SignData(Byte[], Int32, Int32, HashAlgorithmName, RSASignaturePadding)

Calcola il valore hash di una parte della matrice di byte specificata usando l'algoritmo hash e la modalità di riempimento specificati e firma il valore hash risultante.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.

(Ereditato da RSA)
SignData(Byte[], Int32, Int32, Object)

Calcola il valore hash di un subset della matrice di byte specificata utilizzando l'algoritmo hash specificato, quindi firmare il valore hash risultante.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)

Calcola il valore hash della matrice di byte specificata utilizzando l'algoritmo hash specificato, quindi firma il valore hash risultante.Computes the hash value of the specified byte array using the specified hash algorithm, and signs the resulting hash value.

SignData(Stream, HashAlgorithmName, RSASignaturePadding)

Calcola il valore hash del flusso specificato usando l'algoritmo hash e la modalità di spaziatura interna specificati e firma il valore hash risultante.Computes the hash value of the specified stream using the specified hash algorithm and padding mode, and signs the resulting hash value.

(Ereditato da RSA)
SignData(Stream, Object)

Calcola il valore hash del flusso di input specificato utilizzando l'algoritmo hash specificato, quindi firma il valore hash risultante.Computes the hash value of the specified input stream using the specified hash algorithm, and signs the resulting hash value.

SignHash(Byte[], HashAlgorithmName, RSASignaturePadding)

Calcola la firma per il valore hash specificato crittografandola con la chiave privata tramite il riempimento specificato.Computes the signature for the specified hash value by encrypting it with the private key using the specified padding.

SignHash(Byte[], String)

Calcola la firma per il valore hash specificato crittografandola con la chiave privata.Computes the signature for the specified hash value by encrypting it with the private key.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)
ToXmlString(Boolean)

Crea e restituisce una stringa XML contenente la chiave dell'oggetto RSA corrente.Creates and returns an XML string containing the key of the current RSA object.

(Ereditato da RSA)
TryDecrypt(ReadOnlySpan<Byte>, Span<Byte>, RSAEncryptionPadding, Int32) (Ereditato da RSA)
TryEncrypt(ReadOnlySpan<Byte>, Span<Byte>, RSAEncryptionPadding, Int32) (Ereditato da RSA)
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters, Span<Byte>, Int32)

Tenta di esportare la chiave corrente nel formato PKCS#8 EncryptedPrivateKeyInfo in un buffer specificato, usando una password basata su byte.Attempts to export the current key in the PKCS#8 EncryptedPrivateKeyInfo format into a provided buffer, using a byte-based password.

(Ereditato da RSA)
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters, Span<Byte>, Int32)

Tenta di esportare la chiave corrente nel formato PKCS#8 EncryptedPrivateKeyInfo in un buffer specificato, usando una password basata su caratteri.Attempts to export the current key in the PKCS#8 EncryptedPrivateKeyInfo format into a provided buffer, using a char-based password.

(Ereditato da RSA)
TryExportPkcs8PrivateKey(Span<Byte>, Int32)

Tenta di esportare la chiave corrente nel formato PKCS#8 PrivateKeyInfo in un buffer specificato.Attempts to export the current key in the PKCS#8 PrivateKeyInfo format into a provided buffer.

(Ereditato da RSA)
TryExportRSAPrivateKey(Span<Byte>, Int32)

Tenta di esportare la chiave corrente nel formato PKCS#1 RSAPrivateKey in un buffer specificato.Attempts to export the current key in the PKCS#1 RSAPrivateKey format into a provided buffer.

(Ereditato da RSA)
TryExportRSAPublicKey(Span<Byte>, Int32)

Tenta di esportare la chiave corrente nel formato PKCS#1 RSAPublicKey in un buffer specificato.Attempts to export the current key in the PKCS#1 RSAPublicKey format into a provided buffer.

(Ereditato da RSA)
TryExportSubjectPublicKeyInfo(Span<Byte>, Int32)

Tenta di esportare la chiave corrente nel formato X.509 SubjectPublicKeyInfo in un buffer specificato.Attempts to export the current key in the X.509 SubjectPublicKeyInfo format into a provided buffer.

(Ereditato da RSA)
TryHashData(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, Int32) (Ereditato da RSA)
TrySignData(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, RSASignaturePadding, Int32) (Ereditato da RSA)
TrySignHash(ReadOnlySpan<Byte>, Span<Byte>, HashAlgorithmName, RSASignaturePadding, Int32) (Ereditato da RSA)
VerifyData(Byte[], Byte[], HashAlgorithmName, RSASignaturePadding)

Verifica che una firma digitale sia valida calcolando il valore hash dei dati indicati usando l'algoritmo hash e la spaziatura interna specificati e confrontandolo con la firma fornita.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.

(Ereditato da RSA)
VerifyData(Byte[], Int32, Int32, Byte[], HashAlgorithmName, RSASignaturePadding)

Verifica che una firma digitale sia valida calcolando il valore hash dei dati in una parte di matrice di byte usando l'algoritmo hash e la spaziatura interna specificati e confrontandolo con la firma fornita.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.

(Ereditato da RSA)
VerifyData(Byte[], Object, Byte[])

Verifica la validità di una firma digitale confrontando il valore hash della firma determinato tramite la chiave pubblica fornita con il valore hash dei dati forniti.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) (Ereditato da RSA)
VerifyData(Stream, Byte[], HashAlgorithmName, RSASignaturePadding)

Verifica che una firma digitale sia valida calcolando il valore hash del flusso specificato usando l'algoritmo hash e la spaziatura interna specificati e confrontandolo con la firma fornita.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.

(Ereditato da RSA)
VerifyHash(Byte[], Byte[], HashAlgorithmName, RSASignaturePadding)

Verifica che una firma digitale sia valida determinando il valore hash nella firma tramite l'algoritmo hash e il riempimento specificati e confrontandolo con il valore hash indicato.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[])

Verifica la validità di una firma digitale confrontando il valore hash della firma determinato tramite la chiave pubblica fornita con il valore hash fornito.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) (Ereditato da RSA)

Implementazioni dell'interfaccia esplicita

IDisposable.Dispose()

Per una descrizione di questo membro, vedere Dispose().For a description of this member, see Dispose().

(Ereditato da AsymmetricAlgorithm)

Si applica a

Vedi anche