source: branches/eraser6/6.0/Eraser/SettingsPanel.cs @ 1447

Revision 1447, 14.5 KB checked in by lowjoel, 5 years ago (diff)

Do not explicitly allow or disallow a plugin based on whether the plugin is checked in the plugin settings list view. This is because signed plugins load automatically; if the signature changes or if root certificates change the plugin may then be a valid signed assembly. This also fixes the "double error message on startup" where users are greeted with the "invalid unused space and file erasure methods as well as PRNG" will be given the "plugins will only be loaded on restart" message (which makes no sense to the user)

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
Line 
1/*
2 * $Id$
3 * Copyright 2008-2009 The Eraser Project
4 * Original Author: Joel Low <lowjoel@users.sourceforge.net>
5 * Modified By: Kasra Nassiri <cjax@users.sourceforge.net> @10/18/2008
6 * Modified By:
7 *
8 * This file is part of Eraser.
9 *
10 * Eraser is free software: you can redistribute it and/or modify it under the
11 * terms of the GNU General Public License as published by the Free Software
12 * Foundation, either version 3 of the License, or (at your option) any later
13 * version.
14 *
15 * Eraser is distributed in the hope that it will be useful, but WITHOUT ANY
16 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
17 * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
18 *
19 * A copy of the GNU General Public License can be found at
20 * <http://www.gnu.org/licenses/>.
21 */
22
23using System;
24using System.Collections.Generic;
25using System.ComponentModel;
26using System.Data;
27using System.Drawing;
28using System.Text;
29using System.Windows.Forms;
30
31using Eraser.Manager;
32using Eraser.Manager.Plugin;
33using Microsoft.Win32;
34using System.Globalization;
35using Eraser.Util;
36using System.Threading;
37
38namespace Eraser
39{
40    internal partial class SettingsPanel : BasePanel
41    {
42        public SettingsPanel()
43        {
44            InitializeComponent();
45            UXThemeApi.UpdateControlTheme(this);
46
47            //For new plugins, register the callback.
48            Host.Instance.PluginLoaded += OnNewPluginLoaded;
49            ErasureMethodManager.MethodRegistered += OnMethodRegistered;
50            ErasureMethodManager.MethodUnregistered += OnMethodUnregistered;
51
52            //Load the values
53            LoadPluginDependantValues();
54            LoadSettings();
55        }
56
57        private void OnNewPluginLoaded(object sender, PluginLoadedEventArgs e)
58        {
59            ListViewItem item = new ListViewItem();
60            if (e.Instance.Plugin == null)
61            {
62                item.Text = System.IO.Path.GetFileNameWithoutExtension(e.Instance.Assembly.Location);
63                item.SubItems.Add(e.Instance.AssemblyInfo.Author);
64            }
65            else
66            {
67                item.Text = e.Instance.Plugin.Name;
68                item.SubItems.Add(e.Instance.Plugin.Author);
69            }
70
71            //The item is checked if the plugin was given the green light to load
72            item.Checked = e.Instance.Plugin != null ||
73                (Manager.ManagerLibrary.Settings.PluginApprovals.ContainsKey(
74                    e.Instance.AssemblyInfo.Guid) && Manager.ManagerLibrary.
75                    Settings.PluginApprovals[e.Instance.AssemblyInfo.Guid]
76                );
77
78            //Visually display the other metadata associated with the assembly
79            item.ImageIndex = e.Instance.AssemblyAuthenticode == null ? -1 : 0;
80            item.Group = e.Instance.IsCore ? pluginsManager.Groups[0] :
81                pluginsManager.Groups[1];
82            item.SubItems.Add(e.Instance.Assembly.GetName().Version.ToString());
83            item.SubItems.Add(e.Instance.Assembly.Location);
84            item.Tag = e.Instance;
85            pluginsManager.Items.Add(item);
86        }
87
88        private void OnMethodRegistered(object sender, ErasureMethodRegistrationEventArgs e)
89        {
90            ErasureMethod method = ErasureMethodManager.GetInstance(e.Guid);
91            eraseFilesMethod.Items.Add(method);
92            if (method is UnusedSpaceErasureMethod)
93                eraseUnusedMethod.Items.Add(method);
94        }
95
96        private void OnMethodUnregistered(object sender, ErasureMethodRegistrationEventArgs e)
97        {
98            foreach (object obj in eraseFilesMethod.Items)
99                if (((ErasureMethod)obj).Guid == e.Guid)
100                {
101                    eraseFilesMethod.Items.Remove(obj);
102                    break;
103                }
104
105            foreach (object obj in eraseUnusedMethod.Items)
106                if (((ErasureMethod)obj).Guid == e.Guid)
107                {
108                    eraseUnusedMethod.Items.Remove(obj);
109                    break;
110                }
111
112            if (eraseFilesMethod.SelectedIndex == -1)
113                eraseFilesMethod.SelectedIndex = 0;
114            if (eraseUnusedMethod.SelectedIndex == -1)
115                eraseUnusedMethod.SelectedIndex = 0;
116        }
117
118        private void LoadPluginDependantValues()
119        {
120            //Load the list of plugins
121            Host instance = Host.Instance;
122            IEnumerator<PluginInstance> i = instance.Plugins.GetEnumerator();
123            while (i.MoveNext())
124                OnNewPluginLoaded(this, new PluginLoadedEventArgs(i.Current));
125
126            //Refresh the list of languages
127            IList<Language> languages = LanguageManager.Items;
128            foreach (Language culture in languages)
129                uiLanguage.Items.Add(culture);
130
131            //Refresh the list of erasure methods
132            Dictionary<Guid, ErasureMethod> methods = ErasureMethodManager.Items;
133            foreach (ErasureMethod method in methods.Values)
134            {
135                eraseFilesMethod.Items.Add(method);
136                if (method is UnusedSpaceErasureMethod)
137                    eraseUnusedMethod.Items.Add(method);
138            }
139
140            //Refresh the list of PRNGs
141            Dictionary<Guid, Prng> prngs = PrngManager.Items;
142            foreach (Prng prng in prngs.Values)
143                erasePRNG.Items.Add(prng);
144        }
145
146        private void LoadSettings()
147        {
148            EraserSettings settings = EraserSettings.Get();
149            foreach (Object lang in uiLanguage.Items)
150                if (((Language)lang).Name == settings.Language)
151                {
152                    uiLanguage.SelectedItem = lang;
153                    break;
154                }
155
156            foreach (Object method in eraseFilesMethod.Items)
157                if (((ErasureMethod)method).Guid == ManagerLibrary.Settings.DefaultFileErasureMethod)
158                {
159                    eraseFilesMethod.SelectedItem = method;
160                    break;
161                }
162
163            foreach (Object method in eraseUnusedMethod.Items)
164                if (((ErasureMethod)method).Guid == ManagerLibrary.Settings.DefaultUnusedSpaceErasureMethod)
165                {
166                    eraseUnusedMethod.SelectedItem = method;
167                    break;
168                }
169
170            foreach (Object prng in erasePRNG.Items)
171                if (((Prng)prng).Guid == ManagerLibrary.Settings.ActivePrng)
172                {
173                    erasePRNG.SelectedItem = prng;
174                    break;
175                }
176
177            foreach (string path in ManagerLibrary.Settings.PlausibleDeniabilityFiles)
178                plausibleDeniabilityFiles.Items.Add(path);
179
180            uiContextMenu.Checked = settings.IntegrateWithShell;
181            lockedForceUnlock.Checked =
182                ManagerLibrary.Settings.ForceUnlockLockedFiles;
183            schedulerMissedImmediate.Checked =
184                ManagerLibrary.Settings.ExecuteMissedTasksImmediately;
185            schedulerMissedIgnore.Checked =
186                !ManagerLibrary.Settings.ExecuteMissedTasksImmediately;
187            plausibleDeniability.Checked =
188                ManagerLibrary.Settings.PlausibleDeniability;
189            plausibleDeniability_CheckedChanged(plausibleDeniability, new EventArgs());
190            schedulerClearCompleted.Checked = settings.ClearCompletedTasks;
191
192            List<string> defaultsList = new List<string>();
193
194            //Select an intelligent default if the settings are invalid.
195            if (uiLanguage.SelectedIndex == -1)
196            {
197                defaultsList.Add(S._("User interface language"));
198                foreach (Language lang in uiLanguage.Items)
199                    if ((CultureInfo)lang == CultureInfo.CurrentUICulture)
200                        uiLanguage.SelectedItem = lang;
201            }
202            if (eraseFilesMethod.SelectedIndex == -1)
203            {
204                if (eraseFilesMethod.Items.Count > 0)
205                {
206                    eraseFilesMethod.SelectedIndex = 0;
207                    ManagerLibrary.Settings.DefaultFileErasureMethod =
208                        ((ErasureMethod)eraseFilesMethod.SelectedItem).Guid;
209                }
210                defaultsList.Add(S._("Default file erasure method"));
211            }
212            if (eraseUnusedMethod.SelectedIndex == -1)
213            {
214                if (eraseUnusedMethod.Items.Count > 0)
215                {
216                    eraseUnusedMethod.SelectedIndex = 0;
217                    ManagerLibrary.Settings.DefaultUnusedSpaceErasureMethod =
218                        ((ErasureMethod)eraseUnusedMethod.SelectedItem).Guid;
219                }
220                defaultsList.Add(S._("Default unused space erasure method"));
221            }
222            if (erasePRNG.SelectedIndex == -1)
223            {
224                if (erasePRNG.Items.Count > 0)
225                {
226                    erasePRNG.SelectedIndex = 0;
227                    ManagerLibrary.Settings.ActivePrng =
228                        ((Prng)erasePRNG.SelectedItem).Guid;
229                }
230                defaultsList.Add(S._("Randomness data source"));
231            }
232
233            //Remind the user.
234            if (defaultsList.Count != 0)
235            {
236                string defaults = string.Empty;
237                foreach (string item in defaultsList)
238                    defaults += "\t" + item + "\n";
239                MessageBox.Show(S._("The following settings held invalid values:\n\n" +
240                    "{0}\nThese settings have now been set to naive defaults.\n\n" +
241                    "Please check that the new settings suit your required level of security.",
242                    defaults), S._("Eraser"), MessageBoxButtons.OK, MessageBoxIcon.Warning,
243                    MessageBoxDefaultButton.Button1,
244                    S.IsRightToLeft(this) ? MessageBoxOptions.RtlReading : 0);
245                saveSettings_Click(null, null);
246            }
247        }
248
249        private void plausableDeniabilityFilesRemoveUpdate()
250        {
251            plausibleDeniabilityFilesRemove.Enabled = plausibleDeniability.Checked &&
252                plausibleDeniabilityFiles.SelectedIndices.Count > 0;
253        }
254
255        private void plausibleDeniability_CheckedChanged(object sender, EventArgs e)
256        {
257            plausibleDeniabilityFiles.Enabled = plausibleDeniabilityFilesAddFile.Enabled =
258                plausibleDeniabilityFilesAddFolder.Enabled = plausibleDeniability.Checked;
259            plausableDeniabilityFilesRemoveUpdate();
260        }
261
262        private void plausibleDeniabilityFiles_SelectedIndexChanged(object sender, EventArgs e)
263        {
264            plausableDeniabilityFilesRemoveUpdate();
265        }
266
267        private void plausibleDeniabilityFilesAddFile_Click(object sender, EventArgs e)
268        {
269            if (openFileDialog.ShowDialog() == DialogResult.OK)
270                plausibleDeniabilityFiles.Items.AddRange(openFileDialog.FileNames);
271
272            plausableDeniabilityFilesRemoveUpdate();
273        }
274
275        private void plausibleDeniabilityFilesAddFolder_Click(object sender, EventArgs e)
276        {
277            try
278            {
279                if (folderBrowserDialog.ShowDialog() == DialogResult.OK)
280                    plausibleDeniabilityFiles.Items.Add(folderBrowserDialog.SelectedPath);
281                plausableDeniabilityFilesRemoveUpdate();
282            }
283            catch (NotSupportedException)
284            {
285                MessageBox.Show(this, S._("The path you selected is invalid."), S._("Eraser"),
286                    MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1,
287                    S.IsRightToLeft(this) ? MessageBoxOptions.RtlReading : 0);
288            }
289        }
290
291        private void plausibleDeniabilityFilesRemove_Click(object sender, EventArgs e)
292        {
293            if (plausibleDeniabilityFiles.SelectedIndex != -1)
294            {
295                ListBox.SelectedObjectCollection items =
296                    plausibleDeniabilityFiles.SelectedItems;
297                while (items.Count > 0)
298                {
299                    for (int i = 0; i < items.Count; i++)
300                        plausibleDeniabilityFiles.Items.Remove(items[i]);
301
302                    items = plausibleDeniabilityFiles.SelectedItems;
303                }
304
305                plausableDeniabilityFilesRemoveUpdate();
306            }
307        }
308
309        private void pluginsManager_ItemCheck(object sender, ItemCheckEventArgs e)
310        {
311            ListViewItem item = pluginsManager.Items[e.Index];
312            PluginInstance instance = (PluginInstance)item.Tag;
313            if (instance.IsCore)
314                e.NewValue = CheckState.Checked;
315        }
316
317        private void pluginsMenu_Opening(object sender, CancelEventArgs e)
318        {
319            if (pluginsManager.SelectedItems.Count == 1)
320            {
321                PluginInstance instance = (PluginInstance)pluginsManager.SelectedItems[0].Tag;
322                e.Cancel = instance.Plugin == null || !instance.Plugin.Configurable;
323            }
324            else
325                e.Cancel = true;
326        }
327
328        private void settingsToolStripMenuItem_Click(object sender, EventArgs e)
329        {
330            if (pluginsManager.SelectedItems.Count != 1)
331                return;
332
333            PluginInstance instance = (PluginInstance)pluginsManager.SelectedItems[0].Tag;
334            instance.Plugin.DisplaySettings(this);
335        }
336
337        private void saveSettings_Click(object sender, EventArgs e)
338        {
339            EraserSettings settings = EraserSettings.Get();
340            ManagerSettings managerSettings = ManagerLibrary.Settings;
341
342            //Save the settings that don't fail first.
343            managerSettings.ForceUnlockLockedFiles = lockedForceUnlock.Checked;
344            managerSettings.ExecuteMissedTasksImmediately = schedulerMissedImmediate.Checked;
345            settings.ClearCompletedTasks = schedulerClearCompleted.Checked;
346
347            bool pluginApprovalsChanged = false;
348            IDictionary<Guid, bool> pluginApprovals = managerSettings.PluginApprovals;
349            foreach (ListViewItem item in pluginsManager.Items)
350            {
351                PluginInstance plugin = (PluginInstance)item.Tag;
352                Guid guid = plugin.AssemblyInfo.Guid;
353                if (!pluginApprovals.ContainsKey(guid))
354                {
355                    if (plugin.Plugin.Loaded != item.Checked)
356                    {
357                        pluginApprovals.Add(guid, item.Checked);
358                        pluginApprovalsChanged = true;
359                    }
360                }
361                else if (pluginApprovals[guid] != item.Checked)
362                {
363                    pluginApprovals[guid] = item.Checked;
364                    pluginApprovalsChanged = true;
365                }
366            }
367
368            if (pluginApprovalsChanged)
369            {
370                MessageBox.Show(this, S._("Plugins which have just been approved will only be loaded " +
371                    "the next time Eraser is started."), S._("Eraser"), MessageBoxButtons.OK,
372                    MessageBoxIcon.Information, MessageBoxDefaultButton.Button1,
373                    S.IsRightToLeft(this) ? MessageBoxOptions.RtlReading : 0);
374            }
375
376            //Error checks for the rest that do.
377            errorProvider.Clear();
378            if (uiLanguage.SelectedIndex == -1)
379            {
380                errorProvider.SetError(uiLanguage, S._("An invalid language was selected."));
381                return;
382            }
383            else if (eraseFilesMethod.SelectedIndex == -1)
384            {
385                errorProvider.SetError(eraseFilesMethod, S._("An invalid file erasure method " +
386                    "was selected."));
387                return;
388            }
389            else if (eraseUnusedMethod.SelectedIndex == -1)
390            {
391                errorProvider.SetError(eraseUnusedMethod, S._("An invalid unused disk space " +
392                    "erasure method was selected."));
393                return;
394            }
395            else if (erasePRNG.SelectedIndex == -1)
396            {
397                errorProvider.SetError(erasePRNG, S._("An invalid randomness data " +
398                    "source was selected."));
399                return;
400            }
401            else if (plausibleDeniability.Checked && plausibleDeniabilityFiles.Items.Count == 0)
402            {
403                errorProvider.SetError(plausibleDeniabilityFiles, S._("Erasures with plausible deniability " +
404                    "was selected, but no files were selected to be used as decoys."));
405                errorProvider.SetIconPadding(plausibleDeniabilityFiles, -16);
406                return;
407            }
408
409            if (((Language)uiLanguage.SelectedItem).Name != settings.Language)
410            {
411                settings.Language = ((Language)uiLanguage.SelectedItem).Name;
412                MessageBox.Show(this, S._("The new UI language will take only effect when " +
413                    "Eraser is restarted."), S._("Eraser"), MessageBoxButtons.OK,
414                    MessageBoxIcon.Information, MessageBoxDefaultButton.Button1,
415                    S.IsRightToLeft(this) ? MessageBoxOptions.RtlReading : 0);
416            }
417            settings.IntegrateWithShell = uiContextMenu.Checked;
418
419            managerSettings.DefaultFileErasureMethod =
420                ((ErasureMethod)eraseFilesMethod.SelectedItem).Guid;
421            managerSettings.DefaultUnusedSpaceErasureMethod =
422                ((ErasureMethod)eraseUnusedMethod.SelectedItem).Guid;
423
424            Prng newPRNG = (Prng)erasePRNG.SelectedItem;
425            if (newPRNG.Guid != managerSettings.ActivePrng)
426            {
427                MessageBox.Show(this, S._("The new randomness data source will only be used when " +
428                    "the next task is run.\nCurrently running tasks will use the old source."),
429                    S._("Eraser"), MessageBoxButtons.OK, MessageBoxIcon.Information,
430                    MessageBoxDefaultButton.Button1,
431                    S.IsRightToLeft(this) ? MessageBoxOptions.RtlReading : 0);
432                managerSettings.ActivePrng = newPRNG.Guid;
433            }
434           
435            managerSettings.PlausibleDeniability = plausibleDeniability.Checked;
436            IList<string> plausibleDeniabilityFilesList = managerSettings.PlausibleDeniabilityFiles;
437            foreach (string str in this.plausibleDeniabilityFiles.Items)
438                plausibleDeniabilityFilesList.Add(str);
439        }
440    }
441}
442
Note: See TracBrowser for help on using the repository browser.