CryptoStream Classe

Définition

Définit un flux qui lie les flux de données aux transformations par chiffrement.Defines a stream that links data streams to cryptographic transformations.

public ref class CryptoStream : System::IO::Stream
public class CryptoStream : System.IO.Stream
[System.Runtime.InteropServices.ComVisible(true)]
public class CryptoStream : System.IO.Stream
type CryptoStream = class
    inherit Stream
    interface IDisposable
Public Class CryptoStream
Inherits Stream
Héritage
CryptoStream
Héritage
Attributs
Implémente

Exemples

L’exemple suivant montre comment utiliser un CryptoStream pour chiffrer une chaîne.The following example demonstrates how to use a CryptoStream to encrypt a string. Cette méthode utilise RijndaelManaged classe avec la Key et le vecteur d’initialisation (IV) spécifiés.This method uses RijndaelManaged class with the specified Key and initialization vector (IV).

using System;
using System.IO;
using System.Security.Cryptography;

namespace RijndaelManaged_Example
{
    class RijndaelExample
    {
        public static void Main()
        {
            try
            {

                string original = "Here is some data to encrypt!";

                // Create a new instance of the Rijndael
                // class.  This generates a new key and initialization 
                // vector (IV).
                using (Rijndael myRijndael = Rijndael.Create())
                {
                    // Encrypt the string to an array of bytes.
                    byte[] encrypted = EncryptStringToBytes(original, myRijndael.Key, myRijndael.IV);

                    // Decrypt the bytes to a string.
                    string roundtrip = DecryptStringFromBytes(encrypted, myRijndael.Key, myRijndael.IV);

                    //Display the original data and the decrypted data.
                    Console.WriteLine("Original:   {0}", original);
                    Console.WriteLine("Round Trip: {0}", roundtrip);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("Error: {0}", e.Message);
            }
        }
        static byte[] EncryptStringToBytes(string plainText, byte[] Key, byte[] IV)
        {
            // Check arguments.
            if (plainText == null || plainText.Length <= 0)
                throw new ArgumentNullException("plainText");
            if (Key == null || Key.Length <= 0)
                throw new ArgumentNullException("Key");
            if (IV == null || IV.Length <= 0)
                throw new ArgumentNullException("IV");
            byte[] encrypted;
            // Create an Rijndael object
            // with the specified key and IV.
            using (Rijndael rijAlg = Rijndael.Create())
            {
                rijAlg.Key = Key;
                rijAlg.IV = IV;

                // Create an encryptor to perform the stream transform.
                ICryptoTransform encryptor = rijAlg.CreateEncryptor(rijAlg.Key, rijAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {

                            //Write all data to the stream.
                            swEncrypt.Write(plainText);
                        }
                        encrypted = msEncrypt.ToArray();
                    }
                }
            }

            // Return the encrypted bytes from the memory stream.
            return encrypted;
        }

        static string DecryptStringFromBytes(byte[] cipherText, byte[] Key, byte[] IV)
        {
            // Check arguments.
            if (cipherText == null || cipherText.Length <= 0)
                throw new ArgumentNullException("cipherText");
            if (Key == null || Key.Length <= 0)
                throw new ArgumentNullException("Key");
            if (IV == null || IV.Length <= 0)
                throw new ArgumentNullException("IV");

            // Declare the string used to hold
            // the decrypted text.
            string plaintext = null;

            // Create an Rijndael object
            // with the specified key and IV.
            using (Rijndael rijAlg = Rijndael.Create())
            {
                rijAlg.Key = Key;
                rijAlg.IV = IV;

                // Create a decryptor to perform the stream transform.
                ICryptoTransform decryptor = rijAlg.CreateDecryptor(rijAlg.Key, rijAlg.IV);

                // Create the streams used for decryption.
                using (MemoryStream msDecrypt = new MemoryStream(cipherText))
                {
                    using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                    {
                        using (StreamReader srDecrypt = new StreamReader(csDecrypt))
                        {

                            // Read the decrypted bytes from the decrypting stream
                            // and place them in a string.
                            plaintext = srDecrypt.ReadToEnd();
                        }
                    }
                }
            }

            return plaintext;
        }
    }
}
Imports System.IO
Imports System.Security.Cryptography



Class RijndaelExample

    Public Shared Sub Main()
        Try

            Dim original As String = "Here is some data to encrypt!"

            ' Create a new instance of the Rijndael
            ' class.  This generates a new key and initialization 
            ' vector (IV).
            Using myRijndael = Rijndael.Create()

                ' Encrypt the string to an array of bytes.
                Dim encrypted As Byte() = EncryptStringToBytes(original, myRijndael.Key, myRijndael.IV)

                ' Decrypt the bytes to a string.
                Dim roundtrip As String = DecryptStringFromBytes(encrypted, myRijndael.Key, myRijndael.IV)

                'Display the original data and the decrypted data.
                Console.WriteLine("Original:   {0}", original)
                Console.WriteLine("Round Trip: {0}", roundtrip)
            End Using
        Catch e As Exception
            Console.WriteLine("Error: {0}", e.Message)
        End Try

    End Sub

    Shared Function EncryptStringToBytes(ByVal plainText As String, ByVal Key() As Byte, ByVal IV() As Byte) As Byte()
        ' Check arguments.
        If plainText Is Nothing OrElse plainText.Length <= 0 Then
            Throw New ArgumentNullException("plainText")
        End If
        If Key Is Nothing OrElse Key.Length <= 0 Then
            Throw New ArgumentNullException("Key")
        End If
        If IV Is Nothing OrElse IV.Length <= 0 Then
            Throw New ArgumentNullException("IV")
        End If
        Dim encrypted() As Byte
        ' Create an Rijndael object
        ' with the specified key and IV.
        Using rijAlg = Rijndael.Create()

            rijAlg.Key = Key
            rijAlg.IV = IV

            ' Create an encryptor to perform the stream transform.
            Dim encryptor As ICryptoTransform = rijAlg.CreateEncryptor(rijAlg.Key, rijAlg.IV)
            ' Create the streams used for encryption.
            Using msEncrypt As New MemoryStream()
                Using csEncrypt As New CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write)
                    Using swEncrypt As New StreamWriter(csEncrypt)

                        'Write all data to the stream.
                        swEncrypt.Write(plainText)
                    End Using
                    encrypted = msEncrypt.ToArray()
                End Using
            End Using
        End Using

        ' Return the encrypted bytes from the memory stream.
        Return encrypted

    End Function 'EncryptStringToBytes

    Shared Function DecryptStringFromBytes(ByVal cipherText() As Byte, ByVal Key() As Byte, ByVal IV() As Byte) As String
        ' Check arguments.
        If cipherText Is Nothing OrElse cipherText.Length <= 0 Then
            Throw New ArgumentNullException("cipherText")
        End If
        If Key Is Nothing OrElse Key.Length <= 0 Then
            Throw New ArgumentNullException("Key")
        End If
        If IV Is Nothing OrElse IV.Length <= 0 Then
            Throw New ArgumentNullException("IV")
        End If
        ' Declare the string used to hold
        ' the decrypted text.
        Dim plaintext As String = Nothing

        ' Create an Rijndael object
        ' with the specified key and IV.
        Using rijAlg = Rijndael.Create()
            rijAlg.Key = Key
            rijAlg.IV = IV

            ' Create a decryptor to perform the stream transform.
            Dim decryptor As ICryptoTransform = rijAlg.CreateDecryptor(rijAlg.Key, rijAlg.IV)

            ' Create the streams used for decryption.
            Using msDecrypt As New MemoryStream(cipherText)

                Using csDecrypt As New CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read)

                    Using srDecrypt As New StreamReader(csDecrypt)


                        ' Read the decrypted bytes from the decrypting stream
                        ' and place them in a string.
                        plaintext = srDecrypt.ReadToEnd()
                    End Using
                End Using
            End Using
        End Using

        Return plaintext

    End Function 'DecryptStringFromBytes 
End Class

Remarques

Le common language runtime utilise une conception orientée flux pour le chiffrement.The common language runtime uses a stream-oriented design for cryptography. Le cœur de cette conception est CryptoStream.The core of this design is CryptoStream. Tout objet de chiffrement qui implémente CryptoStream peut être chaîné avec n’importe quel objet qui implémente Stream, de sorte que la sortie diffusée en continu d’un objet peut être alimentée dans l’entrée d’un autre objet.Any cryptographic objects that implement CryptoStream can be chained together with any objects that implement Stream, so the streamed output from one object can be fed into the input of another object. Le résultat intermédiaire (la sortie du premier objet) n’a pas besoin d’être stocké séparément.The intermediate result (the output from the first object) does not need to be stored separately.

Important

Ce type implémente l'interface IDisposable.This type implements the IDisposable interface. Une fois que vous avez fini d’utiliser le type, vous devez le supprimer directement ou indirectement en appelant sa méthode Clear, qui à son tour appelle son implémentation de IDisposable.When you have finished using the type, you should dispose of it either directly or indirectly by calling its Clear method, which in turn calls its IDisposable implementation. Pour supprimer directement le type Clear, appelez sa méthode dans un bloc try/catch.To dispose of the type directly, call its Clear method in a try/catch block. Pour la supprimer indirectement, utilisez une construction de langage telle que using (dans C#) ou Using (dans Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Pour plus d’informations, consultez la section « Utilisation d’un objet qui implémente IDisposable » dans la rubrique de l’interface IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Vous devez toujours fermer explicitement votre objet CryptoStream une fois que vous avez fini de l’utiliser en appelant la méthode Clear.You should always explicitly close your CryptoStream object after you are done using it by calling the Clear method. Cela vide le flux sous-jacent et entraîne le traitement de tous les blocs de données restants par l’objet CryptoStream.Doing so flushes the underlying stream and causes all remaining blocks of data to be processed by the CryptoStream object. Toutefois, si une exception se produit avant l’appel de la méthode Close, l’objet CryptoStream peut ne pas être fermé.However, if an exception occurs before you call the Close method, the CryptoStream object might not be closed. Pour vous assurer que la méthode Close est toujours appelée, placez votre appel à la méthode Clear dans le bloc finally d’une instruction /catch try.To ensure that the Close method always gets called, place your call to the Clear method within the finally block of a try/catch statement.

Constructeurs

CryptoStream(Stream, ICryptoTransform, CryptoStreamMode)

Initialise une nouvelle instance de la classe CryptoStream avec un flux de données cible, la transformation à utiliser et le mode du flux.Initializes a new instance of the CryptoStream class with a target data stream, the transformation to use, and the mode of the stream.

CryptoStream(Stream, ICryptoTransform, CryptoStreamMode, Boolean)

Initialise une nouvelle instance de la classe CryptoStream.Initializes a new instance of the CryptoStream class.

Propriétés

CanRead

Obtient une valeur indiquant si le CryptoStream en cours est lisible.Gets a value indicating whether the current CryptoStream is readable.

CanSeek

Obtient une valeur indiquant si vous pouvez effectuer une recherche dans le CryptoStream en cours.Gets a value indicating whether you can seek within the current CryptoStream.

CanTimeout

Obtient une valeur qui détermine si le flux actuel peut dépasser le délai d'attente.Gets a value that determines whether the current stream can time out.

(Hérité de Stream)
CanWrite

Obtient une valeur indiquant si le CryptoStream en cours est accessible en écriture.Gets a value indicating whether the current CryptoStream is writable.

HasFlushedFinalBlock

Obtient une valeur indiquant si le dernier bloc de mémoire tampon a été écrit dans le flux sous-jacent.Gets a value indicating whether the final buffer block has been written to the underlying stream.

Length

Obtient la longueur en octets du flux.Gets the length in bytes of the stream.

Position

Obtient ou définit la position dans le flux actuel.Gets or sets the position within the current stream.

ReadTimeout

Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d’effectuer la lecture avant dépassement du délai d’attente.Gets or sets a value, in milliseconds, that determines how long the stream will attempt to read before timing out.

(Hérité de Stream)
WriteTimeout

Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d’écrire des données avant l’expiration du délai d’attente.Gets or sets a value, in milliseconds, that determines how long the stream will attempt to write before timing out.

(Hérité de Stream)

Méthodes

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)

Commence une opération de lecture asynchrone.Begins an asynchronous read operation. (Utilisez ReadAsync à la place.)(Consider using ReadAsync instead.)

BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Débute une opération d'écriture asynchrone.Begins an asynchronous write operation. (Utilisez WriteAsync à la place.)(Consider using WriteAsync instead.)

Clear()

Libère toutes les ressources utilisées par CryptoStream.Releases all resources used by the CryptoStream.

Close()

Ferme le flux actuel et libère toutes les ressources (comme les sockets et les handles de fichiers) associées à celui-ci.Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream.

CopyTo(Stream)

Lit les octets du flux actuel et les écrit dans un autre flux.Reads the bytes from the current stream and writes them to another stream.

(Hérité de Stream)
CopyTo(Stream, Int32)

Lit tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée.Reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Hérité de Stream)
CopyToAsync(Stream)

Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux.Asynchronously reads the bytes from the current stream and writes them to another stream.

(Hérité de Stream)
CopyToAsync(Stream, CancellationToken)

Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant un jeton d’annulation spécifié.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified cancellation token.

(Hérité de Stream)
CopyToAsync(Stream, Int32)

Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Hérité de Stream)
CopyToAsync(Stream, Int32, CancellationToken)

Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et d'un jeton d'annulation spécifiés.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token.

(Hérité de Stream)
CreateObjRef(Type)

Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Hérité de MarshalByRefObject)
CreateWaitHandle()

Alloue un objet WaitHandle.Allocates a WaitHandle object.

(Hérité de Stream)
Dispose()

Libère toutes les ressources utilisées par Stream.Releases all resources used by the Stream.

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

Libère les ressources non managées utilisées par CryptoStream et libère éventuellement les ressources managées.Releases the unmanaged resources used by the CryptoStream and optionally releases the managed resources.

DisposeAsync()

Libère de façon asynchrone les ressources non managées utilisées par CryptoStream.Asynchronously releases the unmanaged resources used by the CryptoStream.

EndRead(IAsyncResult)

Attend la fin de la lecture asynchrone en attente.Waits for the pending asynchronous read to complete. (Utilisez ReadAsync à la place.)(Consider using ReadAsync instead.)

EndWrite(IAsyncResult)

Termine une opération d'écriture asynchrone.Ends an asynchronous write operation. (Utilisez WriteAsync à la place.)(Consider using WriteAsync instead.)

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)
Finalize()

Autorise un objet à tenter de libérer des ressources et à exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par une opération garbage collection.Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection.

Flush()

Efface toutes les mémoires tampons pour le flux actuel et provoque l'écriture des données mises en mémoire tampon dans le périphérique sous-jacent.Clears all buffers for the current stream and causes any buffered data to be written to the underlying device.

FlushAsync()

Efface de façon asynchrone toutes les mémoires tampons pour ce flux et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent.Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device.

(Hérité de Stream)
FlushAsync(CancellationToken)

Efface toutes les mémoires tampons pour le flux actuel de manière asynchrone, provoque l'écriture des données mises en mémoire tampon dans le périphérique sous-jacent et surveille les demandes d'annulation.Clears all buffers for the current stream asynchronously, causes any buffered data to be written to the underlying device, and monitors cancellation requests.

FlushFinalBlock()

Met à jour la source de données sous-jacente ou le référentiel avec l'état actuel de la mémoire tampon, puis efface cette dernière.Updates the underlying data source or repository with the current state of the buffer, then clears the buffer.

GetHashCode()

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

(Hérité de Object)
GetLifetimeService()

Récupère l'objet de service de durée de vie en cours qui contrôle la stratégie de durée de vie de cette instance.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Hérité de MarshalByRefObject)
GetType()

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

(Hérité de Object)
InitializeLifetimeService()

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.Obtains a lifetime service object to control the lifetime policy for this instance.

(Hérité de MarshalByRefObject)
MemberwiseClone()

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

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

Crée une copie superficielle de l'objet MarshalByRefObject actuel.Creates a shallow copy of the current MarshalByRefObject object.

(Hérité de MarshalByRefObject)
ObjectInvariant()

Assure la prise en charge d'un Contract.Provides support for a Contract.

(Hérité de Stream)
Read(Byte[], Int32, Int32)

Lit une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus.Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

Read(Span<Byte>)

En cas de remplacement dans une classe dérivée, lit une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus.When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

(Hérité de Stream)
ReadAsync(Byte[], Int32, Int32)

Lit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus.Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

(Hérité de Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)

Lit une séquence d'octets à partir du flux actuel de manière asynchrone, avance la position dans le flux du nombre d'octets lus, et surveille les demandes d'annulation.Reads a sequence of bytes from the current stream asynchronously, advances the position within the stream by the number of bytes read, and monitors cancellation requests.

ReadAsync(Memory<Byte>, CancellationToken)

Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation.Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests.

(Hérité de Stream)
ReadByte()

Lit un octet du flux et avance d'un octet la position au sein du flux, ou retourne -1 si la fin du flux a été atteinte.Reads a byte from the stream and advances the position within the stream by one byte, or returns -1 if at the end of the stream.

Seek(Int64, SeekOrigin)

Définit la position dans le flux actuel.Sets the position within the current stream.

SetLength(Int64)

Définit la longueur du flux actuel.Sets the length of the current stream.

ToString()

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

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

Écrit une suite d'octets dans le CryptoStream actuel et avance la position actuelle dans ce flux du nombre d'octets écrits.Writes a sequence of bytes to the current CryptoStream and advances the current position within the stream by the number of bytes written.

Write(ReadOnlySpan<Byte>)

En cas de remplacement dans une classe dérivée, écrit une séquence d'octets dans le flux actuel et avance la position actuelle dans ce flux du nombre d'octets écrits.When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

(Hérité de Stream)
WriteAsync(Byte[], Int32, Int32)

Écrit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position actuelle dans le flux du nombre d'octets écrits.Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

(Hérité de Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)

Écrit une séquence d'octets à partir du flux actuel de façon asynchrone, avance la position actuelle dans le flux du nombre d'octets écrits et surveille les demandes d'annulation.Writes a sequence of bytes to the current stream asynchronously, advances the current position within the stream by the number of bytes written, and monitors cancellation requests.

WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation.Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests.

(Hérité de Stream)
WriteByte(Byte)

Écrit un octet à la position actuelle dans le flux et avance d'un octet la position dans le flux.Writes a byte to the current position in the stream and advances the position within the stream by one byte.

Implémentations d’interfaces explicites

IDisposable.Dispose()

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

S’applique à

Voir aussi