Cryptage memory stream

Version imprimable

Bonjour,

J'essaye de crypter et décrypter une chaine de caractère.

Je me suis inspiré du site suivant http://support.microsoft.com/kb/307010/fr

L'objet CryptoStream cryptostream fonctionne correctement avec du fileStream. J'ai pu constater que l'exemple fonctionnait. J'ai utilisé un memory stream à la place d'un FileStream et ceci ne fonctionne pas, aucun élément n'est écrit dans le memoryStream.

Je ne comprends pas pourquoi, le code est sensiblement le même et le memoryStream est un Stream comme le FileStream excepté un en mémoire et l'autre pour les fichiers.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
    static string EncryptFile(string chaineCharactereEntree,
                            string sKey)
    {
        string chaineEncrypt=null;
        try
        {
            DESCryptoServiceProvider DES = new DESCryptoServiceProvider();
            DES.Key = ASCIIEncoding.ASCII.GetBytes(sKey);
            DES.IV = ASCIIEncoding.ASCII.GetBytes(sKey);
            ICryptoTransform desencrypt = DES.CreateEncryptor();
            byte[] bytearrayinput = new byte[chaineCharactereEntree.Length];
 
            //memory stream utilisé en mémoire pour capter la chaine cryptée.
            MemoryStream ms = new MemoryStream(bytearrayinput);
            ms.Position = 0;
 
 
            CryptoStream cryptostream = new CryptoStream(ms,
                                                         desencrypt,
                                                         CryptoStreamMode.Write);
            //recupere la chaine de caractère et met dans un tableau de byte
            byte[] bytearrayinput1 = new byte[chaineCharactereEntree.Length];
            bytearrayinput1 = System.Text.Encoding.ASCII.GetBytes(chaineCharactereEntree);
 
            //ecrit dans le ms le tableau de byte dans le memory stream            
            cryptostream.Write(bytearrayinput1, 0, bytearrayinput1.Length);
            cryptostream.Flush();
            ms.Close();            
 
            //récupère le tableau de byte rempli et le converti en string
            byte[] byteFin = new byte[bytearrayinput.Length];
            ms.Write(byteFin, 0, byteFin.Length);    
            //on ferme le memory stream       
 
            return System.Text.Encoding.ASCII.GetString(byteFin);         
        }
        catch (Exception ex)
        {            
            throw ex;
        }
        return chaineEncrypt;
    }

Auriez-vous une idée?
Merci d'avance,

Cordialement,
Alexandre

je sais pas mais il y a un truc que je ne comprend pas dans ton code

Code:

1
2
3
4
5
6
7
 
            cryptostream.Flush();
            ms.Close();            
 
            //récupère le tableau de byte rempli et le converti en string
            byte[] byteFin = new byte[bytearrayinput.Length];
            ms.Write(byteFin, 0, byteFin.Length);

tu fermes ms et ensuite tu écrit quelque chose dans ms ?

Finalement oui la remarque était tout à fait approprié j'avais une erreur de memory isn't expandable.

Je suis arrivé à faire 2 méthodes néanmoins le décryptage ne redonne pas la même version que le cryptage.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
static Byte[] EncryptFile(string chaineCharactereEntree,
                               string sKey)
    {
        string chaineEncrypt=null;
        try
        {
            DESCryptoServiceProvider DES = new DESCryptoServiceProvider();
            DES.Key = ASCIIEncoding.ASCII.GetBytes(sKey);
            DES.IV = ASCIIEncoding.ASCII.GetBytes(sKey);
            ICryptoTransform desencrypt = DES.CreateEncryptor();
 
            //memory stream utilisé en mémoire pour capter la chaine cryptée.
            MemoryStream ms = new MemoryStream();            
 
 
            CryptoStream cryptostream = new CryptoStream(ms,
                                                         desencrypt,
                                                         CryptoStreamMode.Write);
            //recupere la chaine de caractère et met dans un tableau de byte
            byte[] bytearrayinput1 = System.Text.Encoding.UTF8.GetBytes(chaineCharactereEntree);
 
            //ecrit dans le ms le tableau de byte dans le memory stream            
            cryptostream.Write(bytearrayinput1, 0, bytearrayinput1.Length);
            cryptostream.FlushFinalBlock();
            cryptostream.Close();
            return ms.ToArray();
            //return Convert.ToBase64String(ms.ToArray());
 
        }
        catch (Exception ex)
        {            
            throw ex;
        }
    }
 
      static string DecryptFile(string crypter,
                                string sKey)
      {
          try
          {
              DESCryptoServiceProvider DES = new DESCryptoServiceProvider();
              //Une clé 64 bits et IV est nécessaire pour ce fournisseur.
              //Définit la clé secrète pour l'algorithme DES.
              DES.Key = ASCIIEncoding.ASCII.GetBytes(sKey);
              //Définit le vecteur d'initialisation.
              DES.IV = ASCIIEncoding.ASCII.GetBytes(sKey);
 
              //System.Text.UTF8Encoding encoder = new System.Text.UTF8Encoding();
              //System.Text.Decoder utf8Decode = encoder.GetDecoder();
 
              byte[] todecode_byte = Convert.FromBase64String(crypter);
              //int charCount = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length);             
 
              //byte[] bytearrayinput1 = new byte[charCount];
              //bytearrayinput1 = System.Text.Encoding.UTF8.GetBytes(crypter);
 
              MemoryStream ms = new MemoryStream();
 
              //Crée un décrypteur DES à partir de l'instance DES.
              ICryptoTransform desdecrypt = DES.CreateDecryptor();
              //Crée un flux crypto défini pour lire et effectue une
              //transformation de cryptage DES sur les octets entrants.
              CryptoStream cryptostreamDecr = new CryptoStream(ms,
                                                               desdecrypt,
                                                               CryptoStreamMode.Write);
              cryptostreamDecr.Write(todecode_byte, 0, todecode_byte.Length);              
              cryptostreamDecr.FlushFinalBlock();
              cryptostreamDecr.Close();
              return Convert.ToBase64String(ms.ToArray());
          }
          catch (Exception ex)
          {              
              throw ex;
          }
      }

ET là j'avoue je ne comprends pas vraiment je continue de chercher.

Cordialement,
Alexandre

03/07/2007, 17h23
Aspic

As tu essayé le cryptage selon Vigenere ?

Merci pour ta réponse,

Finalement,
je n'ai pas pu débloquer directement le problème.
je me suis donc rabattu sur l'exemple de la msdn et ceci correspond à mes besoins.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
 
using System;
using System.Collections.Generic;
using System.Text;
using System.Security.Cryptography;
using System.IO;
 
namespace cryptage
{
    public class EncryptTransformer
    {
        public enum EncryptionAlgorithm { Des = 1, Rc2, Rijndael, TripleDes };
        private EncryptionAlgorithm algorithmID;
        private byte[] initVec;
        private byte[] encKey;
 
        public byte[] IV
        {
            get { return initVec; }
            set { initVec = value; }
        }
        public byte[] Key
        {
            get { return encKey; }
        }
 
        public EncryptTransformer(EncryptionAlgorithm algId)
        {
            //Enregistrer l'algorithme utilisé.
            algorithmID = algId;
        }
 
        public ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey)
        {
            // Sélectionner le fournisseur.
            switch (algorithmID)
            {
                case EncryptionAlgorithm.Des:
                    {
                        DES des = new DESCryptoServiceProvider();
                        des.Mode = CipherMode.CBC;
 
                        // Vérifier si une clé a été fournie.
                        if (null == bytesKey)
                        {
                            encKey = des.Key;
                        }
                        else
                        {
                            des.Key = bytesKey;
                            encKey = des.Key;
                        }
                        // Vérifier si le client a fourni un vecteur d'initialisation.
                        if (null == initVec)
                        { // Demander à l'algorithme d'en créer un.
                            initVec = des.IV;
                        }
                        else
                        { //Non, le fournir à l'algorithme.
                            des.IV = initVec;
                        }
                        return des.CreateEncryptor();
                    }
 
                case EncryptionAlgorithm.TripleDes:
                    {
                        TripleDES des3 = new TripleDESCryptoServiceProvider();
                        des3.Mode = CipherMode.CBC;
                        // Vérifier si une clé a été fournie.
                        if (null == bytesKey)
                        {
                            encKey = des3.Key;
                        }
                        else
                        {
                            des3.Key = bytesKey;
                            encKey = des3.Key;
                        }
                        // Vérifier si le client a fourni un vecteur d'initialisation.
                        if (null == initVec)
                        { //Oui, demander à l'algo. d'en créer un.
                            initVec = des3.IV;
                        }
                        else
                        { //Non, le fournir à l'algo.
                            des3.IV = initVec;
                        }
                        return des3.CreateEncryptor();
                    }
 
                case EncryptionAlgorithm.Rc2:
                    {
                        RC2 rc2 = new RC2CryptoServiceProvider();
                        rc2.Mode = CipherMode.CBC;
                        // Vérifier si une clé a été fournie.
                        if (null == bytesKey)
                        {
                            encKey = rc2.Key;
                        }
                        else
                        {
                            rc2.Key = bytesKey;
                            encKey = rc2.Key;
                        }
                        // Vérifier si le client a fourni un vecteur d'initialisation.
                        if (null == initVec)
                        { //Oui, demander à l'algo. d'en créer un.
                            initVec = rc2.IV;
                        }
                        else
                        { //Non, le fournir à l'algo.
                            rc2.IV = initVec;
                        }
                        return rc2.CreateEncryptor();
                    }
 
                case EncryptionAlgorithm.Rijndael:
                    {
                        Rijndael rijndael = new RijndaelManaged();
                        rijndael.Mode = CipherMode.CBC;
                        // Vérifier si une clé a été fournie.
                        if (null == bytesKey)
                        {
                            encKey = rijndael.Key;
                        }
                        else
                        {
                            rijndael.Key = bytesKey;
                            encKey = rijndael.Key;
                        }
                        // Vérifier si le client a fourni un vecteur d'initialisation.
                        if (null == initVec)
                        { //Oui, demander à l'algo. d'en créer un.
                            initVec = rijndael.IV;
                        }
                        else
                        { //Non, le fournir à l'algo.
                            rijndael.IV = initVec;
                        }
                        return rijndael.CreateEncryptor();
                    }
                default:
                    {
                        throw new CryptographicException("ID de l'algorithme '" + algorithmID + "' non pris en charge.");
                    }
            }
        }
    }
 
    public class DecryptTransformer
    {
        private cryptage.EncryptTransformer.EncryptionAlgorithm algorithmID;
        private byte[] initVec;
 
        public byte[] IV
        {
            set { initVec = value; }
        }
 
        public DecryptTransformer(cryptage.EncryptTransformer.EncryptionAlgorithm deCryptId)
        {
            algorithmID = deCryptId;
        }
 
        public ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey)
        {
            // Sélectionner le fournisseur.
            switch (algorithmID)
            {
                case cryptage.EncryptTransformer.EncryptionAlgorithm.Des:
                    {
                        DES des = new DESCryptoServiceProvider();
                        des.Mode = CipherMode.CBC;
                        des.Key = bytesKey;
                        des.IV = initVec;
                        return des.CreateDecryptor();
                    }
                case cryptage.EncryptTransformer.EncryptionAlgorithm.TripleDes:
                    {
                        TripleDES des3 = new TripleDESCryptoServiceProvider();
                        des3.Mode = CipherMode.CBC;
                        return des3.CreateDecryptor(bytesKey, initVec);
                    }
                case cryptage.EncryptTransformer.EncryptionAlgorithm.Rc2:
                    {
                        RC2 rc2 = new RC2CryptoServiceProvider();
                        rc2.Mode = CipherMode.CBC;
                        return rc2.CreateDecryptor(bytesKey, initVec);
                    }
                case cryptage.EncryptTransformer.EncryptionAlgorithm.Rijndael:
                    {
                        Rijndael rijndael = new RijndaelManaged();
                        rijndael.Mode = CipherMode.CBC;
                        return rijndael.CreateDecryptor(bytesKey, initVec);
                    }
                default:
                    {
                        throw new CryptographicException("ID de l'algorithme '" + algorithmID + "' non pris en charge.");
                    }
            }
        } //end GetCryptoServiceProvider
    }
 
    public class Encryptor
    {
        private EncryptTransformer transformer;
        private byte[] initVec;
        private byte[] encKey;
 
        public byte[] IV
        {
            get { return initVec; }
            set { initVec = value; }
        }
 
        public byte[] Key
        {
            get { return encKey; }
        }
 
 
 
        public Encryptor(cryptage.EncryptTransformer.EncryptionAlgorithm algId)
        {
            transformer = new EncryptTransformer(algId);
        }
 
        public byte[] Encrypt(byte[] bytesData, byte[] bytesKey)
        {
            //Configurer le flux qui contiendra les données cryptées.
            MemoryStream memStreamEncryptedData = new MemoryStream();
 
            transformer.IV = initVec;
            ICryptoTransform transform = transformer.GetCryptoServiceProvider(bytesKey);
            CryptoStream encStream = new CryptoStream(memStreamEncryptedData,
                                                      transform,
                                                      CryptoStreamMode.Write);
            try
            {
                //Crypter les données, les écrire dans le flux de mémoire.
                encStream.Write(bytesData, 0, bytesData.Length);
            }
            catch (Exception ex)
            {
                throw new Exception("Erreur lors de l'écriture des données cryptées dans le flux : \n"
                                    + ex.Message);
            }
 
            //Définir le vecteur d'initialisation et la clé à récupérer par le client.
            encKey = transformer.Key;
            initVec = transformer.IV;
            encStream.FlushFinalBlock();
            encStream.Close();
 
            //Renvoyer les données.
            return memStreamEncryptedData.ToArray();
        }//end Encrypt
    }
 
    public class Decryptor
    {
        private DecryptTransformer transformer;
        private byte[] initVec;
 
        public byte[] IV
        {
            set { initVec = value; }
        }
 
        public Decryptor(cryptage.EncryptTransformer.EncryptionAlgorithm algId)
        {
            transformer = new DecryptTransformer(algId);
        }
 
        public byte[] Decrypt(byte[] bytesData, byte[] bytesKey)
        {
          //Configurer le flux de mémoire pour les données décryptées.
          MemoryStream memStreamDecryptedData = new MemoryStream();
 
          //Transmettre le vecteur d'initialisation.
          transformer.IV = initVec;
          ICryptoTransform transform = transformer.GetCryptoServiceProvider(bytesKey);
          CryptoStream decStream = new CryptoStream(memStreamDecryptedData, 
                                                    transform, 
                                                    CryptoStreamMode.Write);
          try
          {
            decStream.Write(bytesData, 0, bytesData.Length);
          }
          catch(Exception ex)
          {
            throw new Exception("Erreur lors de l'écriture des données cryptées dans le flux : \n" + ex.Message);
          }
          decStream.FlushFinalBlock();
          decStream.Close();
          // Renvoyer les données.
          return memStreamDecryptedData.ToArray();
        } //end Decrypt
    }
}

Voila les deux methode que j'utilise

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
    private const string kv = "CryptDecryptDeveloppez.com";
public static string Encrypt(string password)
    {
        string initVector = string.Empty;
        string key = string.Empty;
        initVector = key = kv;
 
        TripleDESCryptoServiceProvider tripleDES = new TripleDESCryptoServiceProvider();
        if (initVector.Length >= 8)
        {
            initVector = initVector.Substring(0, 8);
        }
        else
        {
            initVector = initVector.PadLeft(8);
        }
 
        if (key.Length >= 24)
        {
            key = key.Substring(0, 24);
        }
        else
        {
            key = key.PadLeft(24);
        }
 
        tripleDES.IV = Encoding.ASCII.GetBytes(initVector);
        tripleDES.Key = Encoding.ASCII.GetBytes(key);
 
        byte[] bs = null;
 
        using (MemoryStream ms = new MemoryStream())
        {
            CryptoStream cs = new CryptoStream(ms, tripleDES.CreateEncryptor(tripleDES.Key, tripleDES.IV), CryptoStreamMode.Write);
            using (StreamWriter sw = new StreamWriter(cs))
            {
                sw.Write(password);
            }
            bs = ms.ToArray();
        }
        return Convert.ToBase64String(bs);
    }
 
    public static string Decrypt(string password)
    {
        string initVector = string.Empty;
        string key = string.Empty;
        initVector = key = kv;
 
        byte[] encrypted = Convert.FromBase64String(password);
 
        TripleDESCryptoServiceProvider tripleDES = new TripleDESCryptoServiceProvider();
        if (initVector.Length >= 8)
        {
            initVector = initVector.Substring(0, 8);
        }
        else
        {
            initVector = initVector.PadLeft(8);
        }
 
        if (key.Length >= 24)
        {
            key = key.Substring(0, 24);
        }
        else
        {
            key = key.PadLeft(24);
        }
        tripleDES.IV = Encoding.ASCII.GetBytes(initVector);
        tripleDES.Key = Encoding.ASCII.GetBytes(key);
 
        string decryptedText = string.Empty;
 
        using (MemoryStream ms = new MemoryStream(encrypted))
        {
            CryptoStream cs = new CryptoStream(ms, tripleDES.CreateDecryptor(tripleDES.Key, tripleDES.IV), CryptoStreamMode.Read);
            using (StreamReader sr = new StreamReader(cs))
            {
                decryptedText = sr.ReadToEnd();
            }
        }
        return decryptedText;
    }

J'espese que cela va t'aider.

A+
:)