Partager via


CryptoStream Classe

Définition

Définit un flux qui lie des flux de données à des transformations de chiffrement.

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
[<System.Runtime.InteropServices.ComVisible(true)>]
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. Cette méthode utilise la classe Aes avec le vecteur de Key et d’initialisation spécifiés (IV).

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

class AesExample
{
    public static void Main()
    {
        try
        {
            string original = "Here is some data to encrypt!";

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

                // Decrypt the bytes to a string.
                string roundtrip = DecryptStringFromBytes(encrypted, myAes.Key, myAes.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(nameof(plainText));
        if (Key == null || Key.Length <= 0)
            throw new ArgumentNullException(nameof(Key));
        if (IV == null || IV.Length <= 0)
            throw new ArgumentNullException(nameof(IV));
        byte[] encrypted;

        // Create a Aes object with the specified key and IV.
        using (Aes aesAlg = Aes.Create())
        {
            aesAlg.Key = Key;
            aesAlg.IV = IV;

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

            // Create the streams used for encryption.
            using (MemoryStream msEncrypt = new())
            {
                using (CryptoStream csEncrypt = new(msEncrypt, encryptor, CryptoStreamMode.Write))
                {
                    using (StreamWriter swEncrypt = new(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(nameof(cipherText));
        if (Key == null || Key.Length <= 0)
            throw new ArgumentNullException(nameof(Key));
        if (IV == null || IV.Length <= 0)
            throw new ArgumentNullException(nameof(IV));

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

        // Create a Aes object with the specified key and IV.
        using (Aes aesAlg = Aes.Create())
        {
            aesAlg.Key = Key;
            aesAlg.IV = IV;

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

            // Create the streams used for decryption.
            using (MemoryStream msDecrypt = new(cipherText))
            {
                using (CryptoStream csDecrypt = new(msDecrypt, decryptor, CryptoStreamMode.Read))
                {
                    using (StreamReader srDecrypt = new(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 AesExample

    Public Shared Sub Main()
        Try
            Dim original As String = "Here is some data to encrypt!"

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

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

                ' Decrypt the bytes to a string.
                Dim roundtrip As String = DecryptStringFromBytes(encrypted, myAes.Key, myAes.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(NameOf(plainText))
        End If
        If Key Is Nothing OrElse Key.Length <= 0 Then
            Throw New ArgumentNullException(NameOf(Key))
        End If
        If IV Is Nothing OrElse IV.Length <= 0 Then
            Throw New ArgumentNullException(NameOf(IV))
        End If
        Dim encrypted() As Byte

        ' Create an Aes object with the specified key and IV.
        Using aesAlg = Aes.Create()

            aesAlg.Key = Key
            aesAlg.IV = IV

            ' Create an encryptor to perform the stream transform.
            Dim encryptor As ICryptoTransform = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.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(NameOf(cipherText))
        End If
        If Key Is Nothing OrElse Key.Length <= 0 Then
            Throw New ArgumentNullException(NameOf(Key))
        End If
        If IV Is Nothing OrElse IV.Length <= 0 Then
            Throw New ArgumentNullException(NameOf(IV))
        End If

        ' Declare the string used to hold the decrypted text.
        Dim plaintext As String = Nothing

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

            ' Create a decryptor to perform the stream transform.
            Dim decryptor As ICryptoTransform = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.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. Le cœur de cette conception est CryptoStream. Tous les objets de chiffrement qui implémentent CryptoStream peuvent être chaînés avec tous les objets qui implémentent Stream, de sorte que la sortie diffusée d’un objet peut être transmise à l’entrée d’un autre objet. Le résultat intermédiaire (la sortie du premier objet) n’a pas besoin d’être stocké séparément.

Important

Dans .NET 6 et versions ultérieures, lorsque Stream.Read ou Stream.ReadAsync est appelé avec une mémoire tampon de longueur N, l’opération se termine lorsque au moins 1 octet a été lu à partir du flux, ou que le flux sous-jacent qu’il encapsule retourne 0 d’un appel à Read, indiquant qu’aucune autre donnée n’est disponible. Avant .NET 6, Stream.Read et Stream.ReadAsync n’ont pas retourné tant que tous les octets N n’avaient pas été lus à partir du flux ou que le flux sous-jacent a retourné 0 à partir d’un appel à Read. Si votre code part du principe que les méthodes Read ne retournent pas tant que tous les N octets n’ont pas été lus, il peut échouer à lire tout le contenu. Pour plus d’informations, consultez lectures partielles et zéro octets dans les flux.

Vous devez toujours fermer explicitement votre objet CryptoStream une fois que vous avez terminé de l’utiliser en appelant la méthode Clear. Cela vide le flux sous-jacent et provoque le traitement de tous les blocs de données restants par l’objet CryptoStream. Toutefois, si une exception se produit avant d’appeler la méthode Close, l’objet CryptoStream peut ne pas être fermé. 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 try/catch.

Ce type implémente l’interface IDisposable. Lorsque vous avez fini d’utiliser le type, vous devez le supprimer directement ou indirectement en appelant sa méthode Clear, qui appelle à son tour son implémentation IDisposable. Pour supprimer le type directement, appelez sa méthode Clear dans un bloc try/catch. Pour le supprimer indirectement, utilisez une construction de langage telle que using (en C#) ou Using (en Visual Basic).

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.

CryptoStream(Stream, ICryptoTransform, CryptoStreamMode, Boolean)

Initialise une nouvelle instance de la classe CryptoStream.

Propriétés

CanRead

Obtient une valeur indiquant si le CryptoStream actuel est lisible.

CanSeek

Obtient une valeur indiquant si vous pouvez rechercher dans le CryptoStreamactuel.

CanTimeout

Obtient une valeur qui détermine si le flux actuel peut expirer.

(Hérité de Stream)
CanWrite

Obtient une valeur indiquant si le CryptoStream actuel est accessible en écriture.

HasFlushedFinalBlock

Obtient une valeur indiquant si le bloc de mémoire tampon final a été écrit dans le flux sous-jacent.

Length

Obtient la longueur en octets du flux.

Position

Obtient ou définit la position dans le flux actuel.

ReadTimeout

Obtient ou définit une valeur, en millisecondes, qui détermine la durée pendant laquelle le flux tente de lire avant l’expiration du délai d’attente.

(Hérité de Stream)
WriteTimeout

Obtient ou définit une valeur, en millisecondes, qui détermine la durée pendant laquelle le flux tentera d’écrire avant l’expiration du délai d’attente.

(Hérité de Stream)

Méthodes

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

Commence une opération de lecture asynchrone. (Envisagez d’utiliser ReadAsync à la place.)

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

Commence une opération de lecture asynchrone. (Envisagez d’utiliser ReadAsync(Byte[], Int32, Int32) à la place.)

(Hérité de Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Commence une opération d’écriture asynchrone. (Envisagez d’utiliser WriteAsync à la place.)

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

Commence une opération d’écriture asynchrone. (Envisagez d’utiliser WriteAsync(Byte[], Int32, Int32) à la place.)

(Hérité de Stream)
Clear()

Libère toutes les ressources utilisées par le CryptoStream.

Close()

Ferme le flux actuel et libère toutes les ressources (telles que les sockets et les handles de fichiers) associées au flux actuel.

Close()

Ferme le flux actuel et libère toutes les ressources (telles que les sockets et les handles de fichiers) associées au flux actuel. Au lieu d’appeler cette méthode, vérifiez que le flux est correctement supprimé.

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

Lit les octets du flux actuel et les écrit dans un autre flux. Les deux positions de flux sont avancées par le nombre d’octets copiés.

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

Lit les octets du flux sous-jacent, applique les transformations de chiffrement pertinentes et écrit le résultat dans le flux de destination.

CopyTo(Stream, Int32)

Lit les octets du flux actuel et les écrit dans un autre flux à l’aide d’une taille de mémoire tampon spécifiée. Les deux positions de flux sont avancées par le nombre d’octets copiés.

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

Lit de manière asynchrone les octets du flux actuel et les écrit dans un autre flux. Les deux positions de flux sont avancées par le nombre d’octets copiés.

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

Lit de manière asynchrone les octets du flux actuel et les écrit dans un autre flux à l’aide d’un jeton d’annulation spécifié. Les deux positions de flux sont avancées par le nombre d’octets copiés.

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

Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux à l’aide d’une taille de mémoire tampon spécifiée. Les deux positions de flux sont avancées par le nombre d’octets copiés.

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

Lit de manière asynchrone les octets du flux sous-jacent, applique les transformations de chiffrement pertinentes et écrit le résultat dans le flux de destination.

CopyToAsync(Stream, Int32, CancellationToken)

Lit de manière asynchrone les octets du flux actuel et les écrit dans un autre flux à l’aide d’une taille de mémoire tampon et d’un jeton d’annulation spécifiés. Les deux positions de flux sont avancées par le nombre d’octets copiés.

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

Crée un objet qui contient toutes les informations pertinentes requises pour générer un proxy utilisé pour communiquer avec un objet distant.

(Hérité de MarshalByRefObject)
CreateWaitHandle()
Obsolète.
Obsolète.
Obsolète.

Alloue un objet WaitHandle.

(Hérité de Stream)
Dispose()

Libère toutes les ressources utilisées par le Stream.

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

Libère les ressources non managées utilisées par le CryptoStream et libère éventuellement les ressources managées.

DisposeAsync()

Libère de façon asynchrone les ressources non managées utilisées par le CryptoStream.

DisposeAsync()

Libère de façon asynchrone les ressources non managées utilisées par le Stream.

(Hérité de Stream)
EndRead(IAsyncResult)

Attend la fin de la lecture asynchrone en attente. (Envisagez d’utiliser ReadAsync à la place.)

EndRead(IAsyncResult)

Attend la fin de la lecture asynchrone en attente. (Envisagez d’utiliser ReadAsync(Byte[], Int32, Int32) à la place.)

(Hérité de Stream)
EndWrite(IAsyncResult)

Termine une opération d’écriture asynchrone. (Envisagez d’utiliser WriteAsync à la place.)

EndWrite(IAsyncResult)

Termine une opération d’écriture asynchrone. (Envisagez d’utiliser WriteAsync(Byte[], Int32, Int32) à la place.)

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

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

(Hérité de Object)
Finalize()

Permet à un objet d’essayer de libérer des ressources et d’effectuer d’autres opérations de nettoyage avant qu’il ne soit récupéré par garbage collection.

Flush()

Efface toutes les mémoires tampons du flux actuel et entraîne l’écriture de toutes les données mises en mémoire tampon sur l’appareil sous-jacent.

FlushAsync()

Efface de façon asynchrone toutes les mémoires tampons de ce flux et entraîne l’écriture de toutes les données mises en mémoire tampon sur l’appareil sous-jacent.

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

Efface toutes les mémoires tampons du flux actuel de manière asynchrone, entraîne l’écriture de toutes les données mises en mémoire tampon sur l’appareil sous-jacent et surveille les demandes d’annulation.

FlushAsync(CancellationToken)

Efface de façon asynchrone toutes les mémoires tampons de ce flux, entraîne l’écriture de toutes les données mises en mémoire tampon sur l’appareil sous-jacent et surveille les demandes d’annulation.

(Hérité de Stream)
FlushFinalBlock()

Met à jour la source de données ou le référentiel sous-jacent avec l’état actuel de la mémoire tampon, puis efface la mémoire tampon.

FlushFinalBlockAsync(CancellationToken)

Met à jour de façon asynchrone la source de données ou le référentiel sous-jacent avec l’état actuel de la mémoire tampon, puis efface la mémoire tampon.

GetHashCode()

Sert de fonction de hachage par défaut.

(Hérité de Object)
GetLifetimeService()
Obsolète.

Récupère l’objet de service de durée de vie actuel qui contrôle la stratégie de durée de vie de cette instance.

(Hérité de MarshalByRefObject)
GetType()

Obtient la Type de l’instance actuelle.

(Hérité de Object)
InitializeLifetimeService()
Obsolète.

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.

(Hérité de MarshalByRefObject)
MemberwiseClone()

Crée une copie superficielle du Objectactuel.

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

Crée une copie superficielle de l’objet MarshalByRefObject actuel.

(Hérité de MarshalByRefObject)
ObjectInvariant()
Obsolète.

Fournit la prise en charge d’un Contract.

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

Lit une séquence d’octets à partir du flux actuel et avance la position dans le flux en fonction du nombre d’octets lus.

Read(Span<Byte>)

En cas de substitution dans une classe dérivée, lit une séquence d’octets à partir du flux actuel et avance la position dans le flux par le nombre d’octets lus.

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

Lit de façon asynchrone une séquence d’octets à partir du flux actuel et avance la position dans le flux en fonction du nombre d’octets lus.

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

Lit une séquence d’octets du flux actuel de manière asynchrone, avance la position dans le flux en fonction du nombre d’octets lus et surveille les demandes d’annulation.

ReadAsync(Byte[], Int32, Int32, CancellationToken)

Lit de façon asynchrone une séquence d’octets à partir du flux actuel, avance la position dans le flux en fonction du nombre d’octets lus et surveille les demandes d’annulation.

(Hérité de Stream)
ReadAsync(Memory<Byte>, CancellationToken)

Lit de façon asynchrone une séquence d’octets à partir du flux actuel, avance la position dans le flux en fonction du nombre d’octets lus et surveille les demandes d’annulation.

ReadAsync(Memory<Byte>, CancellationToken)

Lit de façon asynchrone une séquence d’octets à partir du flux actuel, avance la position dans le flux en fonction du nombre d’octets lus et surveille les demandes d’annulation.

(Hérité de Stream)
ReadAtLeast(Span<Byte>, Int32, Boolean)

Lit au moins un nombre minimal d’octets du flux actuel et avance la position dans le flux par le nombre d’octets lus.

(Hérité de Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)

Lit de façon asynchrone au moins un nombre minimal d’octets à partir du flux actuel, avance la position dans le flux par le nombre d’octets lus et surveille les demandes d’annulation.

(Hérité de Stream)
ReadByte()

Lit un octet à partir du flux et avance la position dans le flux d’un octet, ou retourne -1 si à la fin du flux.

ReadByte()

Lit un octet à partir du flux et avance la position dans le flux d’un octet, ou retourne -1 si à la fin du flux.

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

Lit count nombre d’octets du flux actuel et avance la position dans le flux.

(Hérité de Stream)
ReadExactly(Span<Byte>)

Lit les octets du flux actuel et avance la position dans le flux jusqu’à ce que le buffer soit rempli.

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

Lit de façon asynchrone count nombre d’octets du flux actuel, avance la position dans le flux et surveille les demandes d’annulation.

(Hérité de Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)

Lit de manière asynchrone les octets du flux actuel, avance la position dans le flux jusqu’à ce que le buffer soit rempli et surveille les demandes d’annulation.

(Hérité de Stream)
Seek(Int64, SeekOrigin)

Définit la position dans le flux actuel.

SetLength(Int64)

Définit la longueur du flux actuel.

ToString()

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

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

Écrit une séquence d’octets dans le CryptoStream actuel et avance la position actuelle dans le flux par le nombre d’octets écrits.

Write(ReadOnlySpan<Byte>)

En cas de substitution dans une classe dérivée, écrit une séquence d’octets dans le flux actuel et avance la position actuelle dans ce flux par le nombre d’octets écrits.

(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 ce flux par le nombre d’octets écrits.

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

Écrit une séquence d’octets dans le flux actuel de manière asynchrone, avance la position actuelle dans le flux par le nombre d’octets écrits et surveille les demandes d’annulation.

WriteAsync(Byte[], Int32, Int32, CancellationToken)

Écrit de façon asynchrone une séquence d’octets dans le flux actuel, avance la position actuelle dans ce flux par le nombre d’octets écrits et surveille les demandes d’annulation.

(Hérité de Stream)
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 par le nombre d’octets écrits et surveille les demandes d’annulation.

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 par le nombre d’octets écrits et surveille les demandes d’annulation.

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

Écrit un octet à la position actuelle dans le flux et avance la position dans le flux d’un octet.

WriteByte(Byte)

Écrit un octet à la position actuelle dans le flux et avance la position dans le flux d’un octet.

(Hérité de Stream)

Implémentations d’interfaces explicites

IDisposable.Dispose()

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

Libère les ressources utilisées par l’instance actuelle de la classe CryptoStream.

Méthodes d’extension

CopyToAsync(Stream, PipeWriter, CancellationToken)

Lit de manière asynchrone les octets de l'Stream et les écrit dans le PipeWriterspécifié, à l’aide d’un jeton d’annulation.

ConfigureAwait(IAsyncDisposable, Boolean)

Configure la façon dont les attentes sur les tâches retournées à partir d’un jetable asynchrone sont effectuées.

S’applique à

Voir aussi