Hallo,

ich will euch hier ein wenig die Möglichkeit erklären wie man jeden belibigen Stream sehr einfach verschlüsseln kann. Ich werde es an Hand der XML Serialisierung verdeutlichen. Um das durchzuführen verwenden wir einfach die folgende Klasse: System.Security.Cryptography.CryptoStream. Wie wir das genau machen zeige ich an Hand von einem kleinen Testprojekt.

Normalerweise würden wir die XML so erstellen:

    public void Serialize(PersonCollection obj)
    {
        using (FileStream fs = File.Open(filename, FileMode.Create))
        {
            XmlSerializer xmlser = new XmlSerializer(obj.GetType());
            xmlser.Serialize(fs, obj);
            
            fs.Close();
        }
    }

Um diesen FileStream nun aber nicht im Klartext auf der Festplatte abzuspeichern verwenden wir einfach einen CryptoStream

    public void Serialize(PersonCollection obj)
    {
        using (FileStream fs = File.Open(filename, FileMode.Create))
        {
            UnicodeEncoding aUE = new UnicodeEncoding();
            byte[] key = aUE.GetBytes("password");
            RijndaelManaged myCryptor = new RijndaelManaged();
            
            using (System.Security.Cryptography.CryptoStream cs = new System.Security.Cryptography.CryptoStream(fs, myCryptor.CreateEncryptor(key, key), CryptoStreamMode.Write))
            {
                XmlSerializer xmlser = new XmlSerializer(obj.GetType());
                xmlser.Serialize(cs, obj);
            }
            fs.Close();
        }
    }

Wir erstellen uns also trotzdem weiterhin einen FileStream. Nur wird dieser nicht mehr vom XmlSerializer sondern vom CryptoStream verwendet und der XmlSerializer verwendet nun diesen CryptoStream. Man hängt also einfach die Verschlüsselung dazwischen.

Meine Erfahrung ist dass sich die Dauer mind. verdreifacht. Zum Schluss nochmal mein komplettes Testprojekt damit ihr gleich starten könnt.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using System.Xml.Serialization;

namespace CryptoStream
{
    class Program
    {
        static void Main(string[] args)
        {
            ISerializer serializerCrypted = new SerializerCrypted(Crypter.RijndaelManaged );
            ISerializer serializerNormal = new SerializerNormal();
            Stopwatch sw = new Stopwatch();

            #region Generate Data
            Person p = new Person();
            p.Age = 25;
            p.Name = "Lenz";
            p.Prename = "Christopher";

            PersonCollection pC = new PersonCollection();
            for (int i = 0; i < 100000; i++)
            {
                pC.Add(p);
            }
            #endregion

            #region Serialize Decrypted
            sw.Start();
            serializerCrypted.Serialize(pC);
            sw.Stop();
            Console.WriteLine("Serialize Decrypt: " + sw.ElapsedMilliseconds + "ms");
            sw.Reset();
            #endregion

            #region Deserialize Decrypted
            sw.Start();
            PersonCollection pcOut = serializerCrypted.Deserialize();
            sw.Stop();
            Console.WriteLine("Deserialize Decrypt: " + sw.ElapsedMilliseconds + "ms");
            sw.Reset();
            #endregion

            #region Serialize Normal
            sw.Start();
            serializerNormal.Serialize(pC);
            sw.Stop();
            Console.WriteLine("Serialize Uncrypted: " + sw.ElapsedMilliseconds + "ms");
            sw.Reset();
            #endregion

            #region Deserialize Normal
            sw.Start();
            pcOut = serializerNormal.Deserialize();
            sw.Stop();
            Console.WriteLine("Deserialize Uncrypted: " + sw.ElapsedMilliseconds + "ms");
            #endregion


            Console.WriteLine("Finished");
            Console.ReadLine();
        }
    }

    public class PersonCollection : List<Person>
    {
        
    }

    public class Person
    {
        public string Name { get; set; }
        public string Prename { get; set; }
        public int Age { get; set; }
    }

    internal interface ISerializer
    {
        void Serialize(PersonCollection obj);
        PersonCollection Deserialize();
    }

    internal enum Crypter
    {
        AesManaged,
        RijndaelManaged,
        DES,
        TripleDES
    }

    internal class SerializerCrypted : ISerializer
    {
        private string filename = @"C:\SampleCrypted.xml";
        public Crypter CrypterMode { get; set; }

        public SerializerCrypted(Crypter crypter)
        {
            this.CrypterMode = crypter;
        }

        private ICryptoTransform EncrypterTransform
        {
            get
            {
                UnicodeEncoding aUE = new UnicodeEncoding();
                byte[] key = aUE.GetBytes("password");
            
                switch (CrypterMode)
                {
                    case Crypter.AesManaged: return new AesManaged().CreateEncryptor(key, key);
                    case Crypter.RijndaelManaged: return new RijndaelManaged().CreateEncryptor(key, key);
                    case Crypter.DES: return new DESCryptoServiceProvider().CreateEncryptor(key, key);
                    case Crypter.TripleDES: return new TripleDESCryptoServiceProvider().CreateEncryptor(key, key);
                    default: return new RijndaelManaged().CreateEncryptor(key, key);
                }
            }
        }

        public ICryptoTransform DecrypterTransform
        {
            get
            {
                UnicodeEncoding aUE = new UnicodeEncoding();
                byte[] key = aUE.GetBytes("password");

                switch (CrypterMode)
                {
                    case Crypter.AesManaged: return new AesManaged().CreateDecryptor(key, key);
                    case Crypter.RijndaelManaged: return new RijndaelManaged().CreateDecryptor(key, key);
                    case Crypter.DES: return new DESCryptoServiceProvider().CreateDecryptor(key, key);
                    case Crypter.TripleDES: return new TripleDESCryptoServiceProvider().CreateDecryptor(key, key);
                    default: return new RijndaelManaged().CreateDecryptor(key, key);
                }
            }
        }

        public void Serialize(PersonCollection obj)
        {
            using (FileStream fs = File.Open(filename, FileMode.Create))
            {
                using (
                    System.Security.Cryptography.CryptoStream cs = new System.Security.Cryptography.CryptoStream(fs, EncrypterTransform, CryptoStreamMode.Write))
                {
                    XmlSerializer xmlser = new XmlSerializer(obj.GetType());
                    xmlser.Serialize(cs, obj);
                }
                fs.Close();
            }
        }

        public PersonCollection Deserialize()
        {
            FileStream aFileStream = new FileStream(filename, FileMode.Open);
            System.Security.Cryptography.CryptoStream aCryptoStream = new System.Security.Cryptography.CryptoStream(aFileStream, DecrypterTransform, CryptoStreamMode.Read);

            //Restore the data set to memory.
            PersonCollection result = new PersonCollection();
            XmlSerializer deserializer = new XmlSerializer(typeof(PersonCollection));
            TextReader textReader = new StreamReader(aCryptoStream);
            result = (PersonCollection)deserializer.Deserialize(textReader);
            textReader.Close();

            return result;
        }
    }

    internal class SerializerNormal : ISerializer
    {
        string filename = @"C:\SampleUncrypted.xml";

        public void Serialize(PersonCollection obj)
        {
            using (FileStream fs = File.Open(filename, FileMode.Create))
            {
                XmlSerializer xmlser = new XmlSerializer(obj.GetType());
                xmlser.Serialize(fs, obj);
                
                fs.Close();
            }
        }

        public PersonCollection Deserialize()
        {
            FileStream aFileStream = new FileStream(filename, FileMode.Open);
            
            //Restore the data set to memory.
            PersonCollection result = new PersonCollection();
            XmlSerializer deserializer = new XmlSerializer(typeof(PersonCollection));
            TextReader textReader = new StreamReader(aFileStream);
            result = (PersonCollection)deserializer.Deserialize(textReader);
            textReader.Close();

            return result;
        }
    }
}