Changeset 569

Timestamp:

11/14/2008 2:14:26 PM (3 years ago)

Author:

lowjoel

Message:

Tighten the plugin loading criteria:
-Plugins are first loaded reflection-only, checking for the presence of the IPlugin interface being implemented. If it is not implemented, the DLL is skipped.
-The plugins are then checked for a public key. If the public key is different from the executing assembly, it is not trusted and therefore is foreign.
-Foreign plugins must be approved by the user explicitly before they are loaded.

The SettingsPanel? and the ManagerSettings? classes have therefore been updated.

Location:

branches/eraser6

Files:

• Eraser/SettingsPanel.Designer.cs (modified) (1 diff)
• Eraser/SettingsPanel.cs (modified) (3 diffs)
• Manager/Plugins.cs (modified) (6 diffs)
• Manager/Settings.cs (modified) (1 diff)

branches/eraser6/Eraser/SettingsPanel.Designer.cs

@@ -205 +205 @@
             // 
             resources.ApplyResources(this.pluginsManager, "pluginsManager");
+            this.pluginsManager.CheckBoxes = true;
             this.pluginsManager.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] {
             this.pluginsManagerColName,

branches/eraser6/Eraser/SettingsPanel.cs

@@ -59 +59 @@
         private void OnNewPluginLoaded(PluginInstance instance)
         {
-            ListViewItem item = pluginsManager.Items.Add(instance.Plugin.Name);
-            item.SubItems.Add(instance.Plugin.Author);
+            ListViewItem item = new ListViewItem();
+            if (instance.Plugin == null)
+            {
+                item.Text = System.IO.Path.GetFileNameWithoutExtension(instance.Assembly.Location);
+                item.SubItems.Add(instance.AssemblyInfo.Author);
+            }
+            else
+            {
+                item.Text = instance.Plugin.Name;
+                item.SubItems.Add(instance.Plugin.Author);
+            }
+
+            item.Checked = instance.Plugin != null ||
+                Manager.ManagerLibrary.Instance.Settings.ApprovedPlugins.IndexOf(
+                    instance.AssemblyInfo.GUID) != -1;
             item.SubItems.Add(instance.Assembly.GetName().Version.ToString());
-            item.SubItems.Add(instance.Path);
+            item.SubItems.Add(instance.Assembly.Location);
             item.Tag = instance;
+            pluginsManager.Items.Add(item);
         }
 
@@ -340 +354 @@
 
             EraserSettings settings = new EraserSettings();
+            ManagerSettings managerSettings = ManagerLibrary.Instance.Settings;
             if (((Language)uiLanguage.SelectedItem).Name != settings.Language)
             {
@@ -346 +361 @@
                     S._("Eraser"), MessageBoxButtons.OK, MessageBoxIcon.Information);
             }
-            ManagerLibrary.Instance.Settings.DefaultFileErasureMethod =
+            managerSettings.DefaultFileErasureMethod =
                 ((ErasureMethod)eraseFilesMethod.SelectedItem).GUID;
-            ManagerLibrary.Instance.Settings.DefaultUnusedSpaceErasureMethod =
+            managerSettings.DefaultUnusedSpaceErasureMethod =
                 ((ErasureMethod)eraseUnusedMethod.SelectedItem).GUID;
 
             PRNG newPRNG = (PRNG)erasePRNG.SelectedItem;
-            if (newPRNG.GUID != ManagerLibrary.Instance.Settings.ActivePRNG)
+            if (newPRNG.GUID != managerSettings.ActivePRNG)
             {
                 MessageBox.Show(S._("The new randomness data source will only be used when " +
                     "the next task is run.\nCurrently running tasks will use the old source."),
                     S._("Eraser"), MessageBoxButtons.OK, MessageBoxIcon.Information);
-                ManagerLibrary.Instance.Settings.ActivePRNG = newPRNG.GUID;
-            }
-            ManagerLibrary.Instance.Settings.EraseLockedFilesOnRestart =
-                lockedAllow.Checked;
-            ManagerLibrary.Instance.Settings.ConfirmEraseOnRestart =
-                lockedConfirm.Checked;
-
+                managerSettings.ActivePRNG = newPRNG.GUID;
+            }
+            managerSettings.EraseLockedFilesOnRestart = lockedAllow.Checked;
+            managerSettings.ConfirmEraseOnRestart = lockedConfirm.Checked;
+
+            managerSettings.PlausibleDeniability = plausibleDeniability.Checked;
             List<string> plausibleDeniabilityFilesList = new List<string>();
             foreach (string str in this.plausibleDeniabilityFiles.Items)
                 plausibleDeniabilityFilesList.Add(str);
-            ManagerLibrary.Instance.Settings.PlausibleDeniabilityFiles = plausibleDeniabilityFilesList;
-
-            ManagerLibrary.Instance.Settings.ExecuteMissedTasksImmediately =
-                schedulerMissedImmediate.Checked;
-            ManagerLibrary.Instance.Settings.PlausibleDeniability =
-                plausibleDeniability.Checked;
+            managerSettings.PlausibleDeniabilityFiles = plausibleDeniabilityFilesList;
+
+            managerSettings.ExecuteMissedTasksImmediately = schedulerMissedImmediate.Checked;
+
+            foreach (ListViewItem item in pluginsManager.Items)
+            {
+                PluginInstance plugin = (PluginInstance)item.Tag;
+                if (item.Checked)
+                {
+                    if (managerSettings.ApprovedPlugins.IndexOf(plugin.AssemblyInfo.GUID) == -1)
+                        managerSettings.ApprovedPlugins.Add(plugin.AssemblyInfo.GUID);
+                }
+                else
+                    managerSettings.ApprovedPlugins.Remove(plugin.AssemblyInfo.GUID);
+            }
         }
     }

branches/eraser6/Manager/Plugins.cs

@@ -26 +26 @@
 using System.Reflection;
 using System.Windows.Forms;
+using System.Runtime.InteropServices;
 
 namespace Eraser.Manager.Plugin
@@ -106 +107 @@
         public override void Load()
         {
-            AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(AssemblyResolve);
+            AppDomain.CurrentDomain.AssemblyResolve += AssemblyResolve;
+            AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += ResolveReflectionDependency;
             string pluginsFolder = Path.Combine(
                 Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), //Assembly location
@@ -116 +118 @@
                 FileInfo file = new FileInfo(fileName);
                 if (file.Extension.Equals(".dll"))
-                    LoadPlugin(file.FullName);
+                    try
+                    {
+                        LoadPlugin(file.FullName);
+                    }
+                    catch (BadImageFormatException)
+                    {
+                    }
+                    catch (FileLoadException)
+                    {
+                    }
             }
         }
@@ -140 +151 @@
         public override void LoadPlugin(string filePath)
         {
-            //Load the plugin
-            Assembly assembly = Assembly.LoadFrom(filePath);
+            //Create the PluginInstance structure
+            Assembly reflectAssembly = Assembly.ReflectionOnlyLoadFrom(filePath);
+            PluginInstance instance = new PluginInstance(reflectAssembly, null);
+            Type typePlugin = null;
 
             //Iterate over every exported type, checking if it implements IPlugin
-            foreach (Type type in assembly.GetTypes())
-            {
-                if (!type.IsPublic || type.IsAbstract)
-                    //Not interesting.
-                    continue;
-
+            foreach (Type type in instance.Assembly.GetExportedTypes())
+            {
                 //Check for an implementation of IPlugin
                 Type typeInterface = type.GetInterface("Eraser.Manager.Plugin.IPlugin", true);
                 if (typeInterface != null)
                 {
-                    //Create the PluginInstance structure
-                    PluginInstance instance = new PluginInstance(assembly, filePath, null);
-
-                    //Add the plugin to the list of loaded plugins
-                    lock (plugins)
-                        plugins.Add(instance);
-
-                    //Initialize the plugin
-                    IPlugin pluginInterface = (IPlugin)Activator.CreateInstance(
-                        assembly.GetType(type.ToString()));
-                    pluginInterface.Initialize(this);
-                    instance.Plugin = pluginInterface;
-
-                    //And broadcast the plugin load event
-                    OnPluginLoaded(instance);
+                    typePlugin = type;
+                    break;
                 }
             }
+
+            //If the typePlugin type is empty the assembly doesn't implement IPlugin; we
+            //aren't interested.
+            if (typePlugin == null)
+                return;
+
+            //OK this assembly is a plugin
+            lock (plugins)
+                plugins.Add(instance);
+
+            //First check the plugin for the presence of a signature.
+            if (reflectAssembly.GetName().GetPublicKey().Length == 0)
+            {
+                //If the user did not allow the plug-in to load, don't load it.
+                if (ManagerLibrary.Instance.Settings.ApprovedPlugins.
+                    IndexOf(instance.AssemblyInfo.GUID) == -1)
+                {
+                    return;
+                }
+            }
+
+            //Load the plugin
+            instance.Assembly = Assembly.LoadFrom(filePath);
+
+            //Initialize the plugin
+            IPlugin pluginInterface = (IPlugin)Activator.CreateInstance(
+                instance.Assembly.GetType(typePlugin.ToString()));
+            pluginInterface.Initialize(this);
+            instance.Plugin = pluginInterface;
+
+            //And broadcast the plugin load event
+            OnPluginLoaded(instance);
         }
 
@@ -182 +210 @@
         }
 
+        Assembly ResolveReflectionDependency(object sender, ResolveEventArgs args)
+        {
+            return Assembly.ReflectionOnlyLoad(args.Name);
+        }
+
         private List<PluginInstance> plugins = new List<PluginInstance>();
     }
@@ -190 +223 @@
     public class PluginInstance
     {
-        internal PluginInstance(Assembly assembly, string path, IPlugin plugin)
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="assembly">The assembly representing this plugin.</param>
+        /// <param name="path">The path to the ass</param>
+        /// <param name="plugin"></param>
+        internal PluginInstance(Assembly assembly, IPlugin plugin)
         {
             Assembly = assembly;
-            Path = path;
             Plugin = plugin;
         }
 
-        public Assembly Assembly;
-        public string Path;
-        public IPlugin Plugin;
+        /// <summary>
+        /// Gets the Assembly this plugin instance came from.
+        /// </summary>
+        public Assembly Assembly
+        {
+            get
+            {
+                return assembly;
+            }
+            internal set
+            {
+                assembly = value;
+
+                assemblyInfo.Version = assembly.GetName().Version;
+                IList<CustomAttributeData> attributes = CustomAttributeData.GetCustomAttributes(assembly);
+                foreach (CustomAttributeData attr in attributes)
+                    if (attr.Constructor.DeclaringType == typeof(GuidAttribute))
+                        assemblyInfo.GUID = new Guid((string)attr.ConstructorArguments[0].Value);
+                    else if (attr.Constructor.DeclaringType == typeof(AssemblyCompanyAttribute))
+                        assemblyInfo.Author = (string)attr.ConstructorArguments[0].Value;
+            }
+        }
+
+        /// <summary>
+        /// Gets the attributes of the assembly, loading from reflection-only sources.
+        /// </summary>
+        public AssemblyInfo AssemblyInfo
+        {
+            get
+            {
+                return assemblyInfo;
+            }
+            internal set
+            {
+                assemblyInfo = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets the IPlugin interface which the plugin exposed.
+        /// </summary>
+        public IPlugin Plugin
+        {
+            get
+            {
+                return plugin;
+            }
+            internal set
+            {
+                plugin = value;
+            }
+        }
+
+        private Assembly assembly;
+        private AssemblyInfo assemblyInfo;
+        private IPlugin plugin;
+    }
+
+    /// <summary>
+    /// Reflection-only information retrieved from the assembly.
+    /// </summary>
+    public struct AssemblyInfo
+    {
+        /// <summary>
+        /// The GUID of the assembly.
+        /// </summary>
+        public Guid GUID;
+
+        /// <summary>
+        /// The publisher of the assembly.
+        /// </summary>
+        public string Author;
+
+        /// <summary>
+        /// The version of the assembly.
+        /// </summary>
+        public Version Version;
     }
 

branches/eraser6/Manager/Settings.cs

@@ -250 +250 @@
 
         /// <summary>
+        /// The GUIDs of unsigned plug-ins which the user has explicitly approved.
+        /// </summary>
+        public List<Guid> ApprovedPlugins
+        {
+            get
+            {
+                if (settings["ApprovedPlugins"] == null)
+                    return new List<Guid>();
+                return (List<Guid>)settings["ApprovedPlugins"];
+            }
+            set
+            {
+                settings["ApprovedPlugins"] = value;
+            }
+        }
+
+        /// <summary>
         /// The Settings object which is the data store of this object.
         /// </summary>