Changeset 1255 for trunk/eraser6/Eraser/Program.cs

Timestamp:

10/3/2009 1:12:12 AM (4 years ago)

Author:

cjax

Message:

Replace the RegistrySettings? class with IFFSSettings class for our secure settings management.

File:

• trunk/eraser6/Eraser/Program.cs (modified) (9 diffs)

trunk/eraser6/Eraser/Program.cs

@@ -30 +30 @@
 using System.Runtime.Serialization;
 using System.Runtime.Serialization.Formatters.Binary;
+using System.Security.Permissions;
 using System.Globalization;
 using System.Reflection;
@@ -266 +267 @@
         /// File name of the Eraser task list.
         /// </summary>
-        private const string TaskListFileName = @"Task List.ersx";
+        private static readonly string TaskListFileName = @"Task List.ersx";
 
         /// <summary>
@@ -276 +277 @@
         /// Path to the Eraser settings key (relative to HKCU)
         /// </summary>
-        public const string SettingsPath = @"SOFTWARE\Eraser\Eraser 6";
+        public static readonly string SettingsPath = @"SOFTWARE\Eraser\Eraser 6";
+
+        /// <summary>
+        /// File name of the IFFS file container
+        /// </summary>
+        public static readonly string IFFSFileName = @"Settings.erdb";
+
+        /// <summary>
+        /// Path to eraser IFFS file container
+        /// </summary>
+        public static readonly string IFFSPath = Path.Combine(AppDataPath, IFFSFileName);
     }
 
@@ -348 +359 @@
                     //has been closed.
                     MainForm.FormClosed += OnExitInstance;
-
+                
                     if (ShowMainForm)
                         Application.Run(MainForm);
@@ -1020 +1031 @@
                     throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
                         "The file {0} does not exist.", param));
-                
+
                 files.Add(param);
                 return true;
@@ -1191 +1202 @@
         {
             AddTaskCommandLine taskArgs = (AddTaskCommandLine)Arguments;
-            
+
             //Create the task, and set the method to use.
             Task task = new Task();
-            ErasureMethod method = taskArgs.ErasureMethod == Guid.Empty ? 
+            ErasureMethod method = taskArgs.ErasureMethod == Guid.Empty ?
                 ErasureMethodManager.Default :
                 ErasureMethodManager.GetInstance(taskArgs.ErasureMethod);
@@ -1306 +1317 @@
     }
 
+    /// <summary>
+    /// This class provides a File Based Win32 Registry using .NET
+    /// binary serialization.
+    /// </summary>
     internal class Settings : Manager.SettingsManager
     {
         /// <summary>
-        /// Registry-based storage backing for the Settings class.
-        /// </summary>
-        private class RegistrySettings : Manager.Settings, IDisposable
+        /// IFFS based setting managment
+        /// </summary>
+        private class IFFSSettings : Manager.Settings, IDisposable
         {
             /// <summary>
@@ -1317 +1332 @@
             /// </summary>
             /// <param name="key">The registry key to look for the settings in.</param>
-            public RegistrySettings(RegistryKey key)
-            {
-                this.key = key;
+            public IFFSSettings(IFFS.Handle handle)
+            {
+                this.handle = handle;
             }
 
             #region IDisposable Members
 
-            ~RegistrySettings()
+            ~IFFSSettings()
             {
                 Dispose(false);
@@ -1338 +1353 @@
             {
                 if (disposing)
-                    key.Close();
+                    handle.Close();
+
+                foreach (var hFile in hFiles.Values)
+                    hFile.Close();
+
+                hFiles.Clear();
             }
 
             #endregion
 
+            private Dictionary<String, IFFS.Handle> hFiles = new Dictionary<string, IFFS.Handle>();
             public override object this[string setting]
             {
                 get
                 {
-                    //Get the raw registry value
-                    object rawResult = key.GetValue(setting, null);
-
-                    //Check if it is a serialised object
-                    byte[] resultArray = rawResult as byte[];
-                    if (resultArray != null)
+                    IFFS.Handle hFile = null;
+
+                    // Open a handle to the settings file
+                    if (hFiles.ContainsKey(setting))
                     {
-                        using (MemoryStream stream = new MemoryStream(resultArray))
-                            try
-                            {
-                                return new BinaryFormatter().Deserialize(stream);
-                            }
-                            catch (SerializationException)
-                            {
-                                key.DeleteValue(setting);
-                                MessageBox.Show(S._("Could not load the setting {0} for plugin {1}. " +
-                                    "The setting has been lost.", key, pluginID.ToString()),
-                                    S._("Eraser"), MessageBoxButtons.OK, MessageBoxIcon.Error,
-                                    MessageBoxDefaultButton.Button1,
-                                    S.IsRightToLeft(null) ? MessageBoxOptions.RtlReading : 0);
-                            }
+                        hFile = hFiles[setting];
                     }
                     else
                     {
-                        return rawResult;
+                        hFiles.Add(setting, hFile = IFFS.Open(handle, setting));
                     }
 
+                    try
+                    {
+                        if (hFile.IsValid)
+                        {
+                            return IFFS.GetFileData(hFile);
+                        }
+                    }
+                    catch
+                    {
+                        hFiles.Remove(setting);
+                        hFile.Close();
+                        throw;
+                    }
+
                     return null;
                 }
                 set
                 {
-                    if (value == null)
+                    IFFS.Handle hFile = null;
+
+                    if (hFiles.ContainsKey(setting))
                     {
-                        key.DeleteValue(setting);
+                        hFile = hFiles[setting];
                     }
                     else
                     {
-                        if (value is bool)
-                            key.SetValue(setting, value, RegistryValueKind.DWord);
-                        else if ((value is int) || (value is uint))
-                            key.SetValue(setting, value, RegistryValueKind.DWord);
-                        else if ((value is long) || (value is ulong))
-                            key.SetValue(setting, value, RegistryValueKind.QWord);
-                        else if (value is string)
-                            key.SetValue(setting, value, RegistryValueKind.String);
-                        else
-                            using (MemoryStream stream = new MemoryStream())
+                        hFiles.Add(setting, hFile = IFFS.CreateFile(handle, setting));
+                    }
+
+                    if (!hFile.IsValid && hFiles.ContainsKey(setting))
+                    {
+                        hFiles.Remove(setting);
+                        hFile.Close();
+                        this[setting] = value;
+                    }
+                    else
+                        try
+                        {
+                            if (value == null)
                             {
-                                new BinaryFormatter().Serialize(stream, value);
-                                key.SetValue(setting, stream.ToArray(), RegistryValueKind.Binary);
+                                IFFS.Delete(hFile);
                             }
+                            else
+                            {
+                                IFFS.FileNode file = IFFS.GetFile(hFile);
+                                file.Data = value;
+                                file.DataType = Type.GetTypeFromHandle(Type.GetTypeHandle(value));
+                            }
+                        }
+                        catch
+                        {
+                            hFile.Close();
+                            hFiles.Remove(setting);
+                            throw;
+                        }
+                }
+            }
+
+            /// <summary>
+            /// The handle where the data is stored.
+            /// </summary>
+            private IFFS.Handle handle;
+        }
+
+        public override void Save()
+        {
+            Stream.Position = 0;
+            Stream.SetLength(0);
+            Instance.Serialize(Stream);
+        }
+
+#if DEBUG
+        private static bool MonteCarloTestHasRun = false;
+
+        private void MonteCarloTest()
+        {
+            Random rand = new Random();
+            const int MAX_ITERATIONS = 64;
+
+            IFFS.Handle hMonteCarlo = IFFS.CreateDirectory(Instance.RootHandle, "MonteCarlo");
+
+            if (!MonteCarloTestHasRun)
+                for (int iterations = 0; iterations < MAX_ITERATIONS; iterations++)
+                {
+                    const int MAX_VALUE = 1024 * 16;
+
+                    for (int i = 0; i < MAX_VALUE; i++)
+                        IFFS.CreateFile(hMonteCarlo, i.ToString());
+
+                    for (int i = 0; i < MAX_VALUE; i++)
+                    {
+                        IFFS.Handle hFile = IFFS.Open(hMonteCarlo, rand.Next(0, MAX_VALUE).ToString());
+                        IFFS.GetFile(hFile).Data = i;
                     }
-                }
-            }
-
-            /// <summary>
-            /// The GUID of the plugin whose settings this object is storing.
-            /// </summary>
-            private Guid pluginID;
-
-            /// <summary>
-            /// The registry key where the data is stored.
-            /// </summary>
-            private RegistryKey key;
-        }
-
-        public override void Save()
-        {
-        }
+
+                    Save();
+                }
+
+            if (!IFFS.Delete(hMonteCarlo) && !MonteCarloTestHasRun)
+                throw new Exception();
+            else
+                Save();
+
+            MonteCarloTestHasRun = true;
+        }
+#endif
 
         protected override Manager.Settings GetSettings(Guid guid)
         {
-            RegistryKey eraserKey = null;
-
-            try
-            {
-                //Open the registry key containing the settings
-                eraserKey = Registry.CurrentUser.OpenSubKey(Program.SettingsPath, true);
-                if (eraserKey == null)
-                    eraserKey = Registry.CurrentUser.CreateSubKey(Program.SettingsPath);
-
-                RegistryKey pluginsKey = eraserKey.OpenSubKey(guid.ToString(), true);
-                if (pluginsKey == null)
-                    pluginsKey = eraserKey.CreateSubKey(guid.ToString());
-
-                //Return the Settings object.
-                return new RegistrySettings(pluginsKey);
-            }
-            finally
-            {
-                if (eraserKey != null)
-                    eraserKey.Close();
+            IFFS.Handle hPlugin = IFFS.CreateDirectory(Instance.RootHandle, guid.ToString());
+
+            return new IFFSSettings(hPlugin);
+        }
+
+        /// <summary>
+        /// Our encrypted filestream handle
+        /// </summary>
+        protected static CryptoFileStream Stream { get; set; }
+
+        /// <summary>
+        /// Create a new instance of the IFFS manager.
+        /// </summary>
+        /// <param name="key">key for the underlying cryptostream</param>
+        /// <param name="iv">iv for the underlying cryptostream</param>
+        /// <throws>SerializationException</throws>
+        /// <returns></returns>
+        static IFFS CreateIFFSInstance(byte[] key, byte[] iv)
+        {           
+            // create a new file stream for our settings
+            Stream = new CryptoFileStream(key, iv,
+                Program.IFFSPath,
+                FileMode.OpenOrCreate,/* doesnt matter if it was not created before */
+                FileAccess.ReadWrite, /* we need IO for get/set */
+                FileShare.None);      /* make sure we fully lock this file */
+            
+            IFFS newInstance = null;
+                        
+            if (Stream.Length != 0)
+            {
+                long OriginalPosition = Stream.Position;
+                try
+                {
+                    newInstance = new IFFS(Stream);
+                }
+                catch (SerializationException)
+                {
+                    // XXX for future ref, if this happens could be
+                    // due to invalid credentials dont erase the 
+                    // settings. 
+                    // lets roll back
+                    Stream.Position = OriginalPosition;
+                    throw;
+                }
+            }
+
+            if (newInstance == null)
+            {
+                return new IFFS();
+            }
+            else
+            {
+                return newInstance;
+            }
+        }
+
+        /// <summary>
+        /// Global IFFS instance management methods
+        /// </summary>
+        private static IFFS instance = null;
+        protected static IFFS Instance
+        {
+            get
+            {
+                if (instance != null)
+                {
+                    return instance;
+                }
+
+                /// XXX currently no user login is implemented
+                /// predefined and determinable key and iv is
+                /// generated. 
+
+                // Hash algorithm
+                System.Security.Cryptography.SHA512Managed Hash = new System.Security.Cryptography.SHA512Managed();
+
+                // use a per user seed for our key/iv generation
+                string UserID = System.Security.Principal.WindowsIdentity.GetCurrent().User.Value;
+
+                // Key and IV for our CryptoStream
+                byte[] defaultKey = Hash.ComputeHash(Encoding.UTF8.GetBytes(UserID));
+                byte[] defaultIV = Hash.ComputeHash(defaultKey);
+
+                try
+                {
+                    instance = CreateIFFSInstance(defaultKey, defaultIV);
+                }
+                catch (SerializationException)
+                {
+                    // this happens when serialization fails
+                    // howerver if the wrong credentials were
+                    // supplied this is not a corrupt archive.
+                    // lets ask the user on the appropriate action.
+
+                    string message = S._("Could not load the setting. To clear current settings click 'ok'");
+                    DialogResult answer = MessageBox.Show(message, S._("Eraser"),
+                        MessageBoxButtons.RetryCancel, MessageBoxIcon.Error,
+                        MessageBoxDefaultButton.Button1,
+                        S.IsRightToLeft(null) ? MessageBoxOptions.RtlReading : 0);
+
+                    if (answer == DialogResult.Cancel)
+                    {
+                        throw new NotImplementedException("Not Implemented");
+                    }
+                    else // (answer == DialogResult.Ok)
+                    {
+                        // nothing to do
+                    }
+                }
+
+                if (instance == null)
+                {
+                    return instance = new IFFS();
+                }
+                
+                return instance;
+            }
+            set
+            {
+                instance = value;
             }
         }