summaryrefslogtreecommitdiff
path: root/Mount/Mount.c
diff options
context:
space:
mode:
Diffstat (limited to 'Mount/Mount.c')
-rw-r--r--Mount/Mount.c8999
1 files changed, 8999 insertions, 0 deletions
diff --git a/Mount/Mount.c b/Mount/Mount.c
new file mode 100644
index 0000000..081441b
--- /dev/null
+++ b/Mount/Mount.c
@@ -0,0 +1,8999 @@
+/*
+ Legal Notice: Some portions of the source code contained in this file were
+ derived from the source code of Encryption for the Masses 2.02a, which is
+ Copyright (c) 1998-2000 Paul Le Roux and which is governed by the 'License
+ Agreement for Encryption for the Masses'. Modifications and additions to
+ the original source code (contained in this file) and all other portions
+ of this file are Copyright (c) 2003-2012 TrueCrypt Developers Association
+ and are governed by the TrueCrypt License 3.0 the full text of which is
+ contained in the file License.txt included in TrueCrypt binary and source
+ code distribution packages. */
+
+#include "Tcdefs.h"
+
+#include <time.h>
+#include <math.h>
+#include <dbt.h>
+#include <fcntl.h>
+#include <io.h>
+#include <shlobj.h>
+#include <sys/stat.h>
+#include <windowsx.h>
+
+#include "Apidrvr.h"
+#include "BootEncryption.h"
+#include "Cmdline.h"
+#include "Crypto.h"
+#include "Dlgcode.h"
+#include "Combo.h"
+#include "Favorites.h"
+#include "Hotkeys.h"
+#include "Keyfiles.h"
+#include "Language.h"
+#include "MainCom.h"
+#include "Mount.h"
+#include "Pkcs5.h"
+#include "Random.h"
+#include "Registry.h"
+#include "Resource.h"
+#include "Password.h"
+#include "Xml.h"
+#include "../Boot/Windows/BootCommon.h"
+#include "../Common/Dictionary.h"
+#include "../Common/Common.h"
+#include "../Common/Resource.h"
+#include "../Common/SecurityToken.h"
+#include "../Platform/Finally.h"
+#include "../Platform/ForEach.h"
+
+using namespace TrueCrypt;
+
+enum timer_ids
+{
+ TIMER_ID_MAIN = 0xff,
+ TIMER_ID_KEYB_LAYOUT_GUARD
+};
+
+enum hidden_os_read_only_notif_mode
+{
+ TC_HIDDEN_OS_READ_ONLY_NOTIF_MODE_NONE = 0,
+ TC_HIDDEN_OS_READ_ONLY_NOTIF_MODE_COMPACT,
+ TC_HIDDEN_OS_READ_ONLY_NOTIF_MODE_DISABLED
+};
+
+#define TIMER_INTERVAL_MAIN 500
+#define TIMER_INTERVAL_KEYB_LAYOUT_GUARD 10
+
+BootEncryption *BootEncObj = NULL;
+BootEncryptionStatus BootEncStatus;
+BootEncryptionStatus RecentBootEncStatus;
+
+BOOL bExplore = FALSE; /* Display explorer window after mount */
+BOOL bBeep = FALSE; /* Donot beep after mount */
+char szFileName[TC_MAX_PATH+1]; /* Volume to mount */
+char szDriveLetter[3]; /* Drive Letter to mount */
+char commandLineDrive = 0;
+BOOL bCacheInDriver = FALSE; /* Cache any passwords we see */
+BOOL bCacheInDriverDefault = FALSE;
+BOOL bHistoryCmdLine = FALSE; /* History control is always disabled */
+BOOL bUseDifferentTrayIconIfVolMounted = TRUE;
+BOOL bCloseDismountedWindows=TRUE; /* Close all open explorer windows of dismounted volume */
+BOOL bWipeCacheOnExit = FALSE; /* Wipe password from chace on exit */
+BOOL bWipeCacheOnAutoDismount = TRUE;
+BOOL bEnableBkgTask = FALSE;
+BOOL bCloseBkgTaskWhenNoVolumes = FALSE;
+BOOL bDismountOnLogOff = TRUE;
+BOOL bDismountOnScreenSaver = TRUE;
+BOOL bDismountOnPowerSaving = FALSE;
+BOOL bForceAutoDismount = TRUE;
+BOOL bForceMount = FALSE; /* Mount volume even if host file/device already in use */
+BOOL bForceUnmount = FALSE; /* Unmount volume even if it cannot be locked */
+BOOL bWipe = FALSE; /* Wipe driver passwords */
+BOOL bAuto = FALSE; /* Do everything without user input */
+BOOL LogOn = FALSE;
+BOOL bAutoMountDevices = FALSE; /* Auto-mount devices */
+BOOL bAutoMountFavorites = FALSE;
+BOOL bPlaySoundOnSuccessfulHkDismount = TRUE;
+BOOL bDisplayBalloonOnSuccessfulHkDismount = TRUE;
+BOOL bHibernationPreventionNotified = FALSE; /* TRUE if the user has been notified that hibernation was prevented (system encryption) during the session. */
+BOOL bHiddenSysLeakProtNotifiedDuringSession = FALSE; /* TRUE if the user has been notified during the session that unencrypted filesystems and non-hidden TrueCrypt volumes are mounted as read-only under hidden OS. */
+BOOL CloseSecurityTokenSessionsAfterMount = FALSE;
+BOOL DisableSystemCrashDetection = FALSE;
+BOOL SystemCrashDetected = FALSE;
+
+BOOL Quit = FALSE; /* Exit after processing command line */
+BOOL ComServerMode = FALSE;
+BOOL ServiceMode = FALSE;
+BOOL UsePreferences = TRUE;
+
+int HiddenSysLeakProtectionNotificationStatus = TC_HIDDEN_OS_READ_ONLY_NOTIF_MODE_NONE;
+int MaxVolumeIdleTime = -120;
+int nCurrentShowType = 0; /* current display mode, mount, unmount etc */
+int nSelectedDriveIndex = -1; /* Item number of selected drive */
+
+int cmdUnmountDrive = 0; /* Volume drive letter to unmount (-1 = all) */
+Password VolumePassword; /* Password used for mounting volumes */
+Password CmdVolumePassword; /* Password passed from command line */
+BOOL CmdVolumePasswordValid = FALSE;
+MountOptions CmdMountOptions;
+BOOL CmdMountOptionsValid = FALSE;
+MountOptions mountOptions;
+MountOptions defaultMountOptions;
+KeyFile *FirstCmdKeyFile;
+
+HBITMAP hbmLogoBitmapRescaled = NULL;
+char OrigKeyboardLayout [8+1] = "00000409";
+BOOL bKeyboardLayoutChanged = FALSE; /* TRUE if the keyboard layout was changed to the standard US keyboard layout (from any other layout). */
+BOOL bKeybLayoutAltKeyWarningShown = FALSE; /* TRUE if the user has been informed that it is not possible to type characters by pressing keys while the right Alt key is held down. */
+
+static KeyFilesDlgParam hidVolProtKeyFilesParam;
+
+static MOUNT_LIST_STRUCT LastKnownMountList;
+VOLUME_NOTIFICATIONS_LIST VolumeNotificationsList;
+static DWORD LastKnownLogicalDrives;
+
+static HANDLE TaskBarIconMutex = NULL;
+static BOOL MainWindowHidden = FALSE;
+static int pwdChangeDlgMode = PCDM_CHANGE_PASSWORD;
+static int bSysEncPwdChangeDlgMode = FALSE;
+static int bPrebootPasswordDlgMode = FALSE;
+static int NoCmdLineArgs;
+static BOOL CmdLineVolumeSpecified;
+static int LastDriveListVolumeColumnWidth;
+
+static void localcleanup (void)
+{
+ // Wipe command line
+ char *c = GetCommandLineA ();
+ wchar_t *wc = GetCommandLineW ();
+ burn(c, strlen (c));
+ burn(wc, wcslen (wc) * sizeof (wchar_t));
+
+ /* Delete buffered bitmaps (if any) */
+ if (hbmLogoBitmapRescaled != NULL)
+ {
+ DeleteObject ((HGDIOBJ) hbmLogoBitmapRescaled);
+ hbmLogoBitmapRescaled = NULL;
+ }
+
+ /* These items should have already been cleared by the functions that used them, but we're going to
+ clear them for extra security. */
+ burn (&VolumePassword, sizeof (VolumePassword));
+ burn (&CmdVolumePassword, sizeof (CmdVolumePassword));
+ burn (&mountOptions, sizeof (mountOptions));
+ burn (&defaultMountOptions, sizeof (defaultMountOptions));
+ burn (&szFileName, sizeof(szFileName));
+
+ /* Cleanup common code resources */
+ cleanup ();
+
+ if (BootEncObj != NULL)
+ {
+ delete BootEncObj;
+ BootEncObj = NULL;
+ }
+
+ RandStop (TRUE);
+}
+
+void RefreshMainDlg (HWND hwndDlg)
+{
+ int drive = (char) (HIWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))));
+
+ MoveEditToCombo (GetDlgItem (hwndDlg, IDC_VOLUME), bHistory);
+ LoadDriveLetters (GetDlgItem (hwndDlg, IDC_DRIVELIST), drive);
+ EnableDisableButtons (hwndDlg);
+}
+
+void EndMainDlg (HWND hwndDlg)
+{
+ MoveEditToCombo (GetDlgItem (hwndDlg, IDC_VOLUME), bHistory);
+
+ if (UsePreferences)
+ SaveSettings (hwndDlg);
+
+ if (bWipeCacheOnExit)
+ {
+ DWORD dwResult;
+ DeviceIoControl (hDriver, TC_IOCTL_WIPE_PASSWORD_CACHE, NULL, 0, NULL, 0, &dwResult, NULL);
+ }
+
+ if (!bHistory)
+ {
+ SetWindowText (GetDlgItem (hwndDlg, IDC_VOLUME), "");
+ ClearHistory (GetDlgItem (hwndDlg, IDC_VOLUME));
+ }
+
+ if (TaskBarIconMutex != NULL)
+ {
+ MainWindowHidden = TRUE;
+ ShowWindow (hwndDlg, SW_HIDE);
+ }
+ else
+ {
+ KillTimer (hwndDlg, TIMER_ID_MAIN);
+ TaskBarIconRemove (hwndDlg);
+ EndDialog (hwndDlg, 0);
+ }
+}
+
+static void InitMainDialog (HWND hwndDlg)
+{
+ MENUITEMINFOW info;
+ char *popupTexts[] = {"MENU_VOLUMES", "MENU_SYSTEM_ENCRYPTION", "MENU_FAVORITES", "MENU_TOOLS", "MENU_SETTINGS", "MENU_HELP", "MENU_WEBSITE", 0};
+ wchar_t *str;
+ int i;
+
+ /* Call the common dialog init code */
+ InitDialog (hwndDlg);
+ LocalizeDialog (hwndDlg, NULL);
+
+ SetWindowLongPtr (hwndDlg, DWLP_USER, (LONG_PTR) (IsAdmin() ? TC_MAIN_WINDOW_FLAG_ADMIN_PRIVILEGES : 0));
+
+ DragAcceptFiles (hwndDlg, TRUE);
+
+ SendMessage (GetDlgItem (hwndDlg, IDC_VOLUME), CB_LIMITTEXT, TC_MAX_PATH, 0);
+ SetWindowTextW (hwndDlg, (IsAdmin() && !IsBuiltInAdmin() && IsUacSupported() && !IsNonInstallMode()) ? (wstring (lpszTitle) + L" [" + GetString ("ADMINISTRATOR") + L"]").c_str() : lpszTitle);
+
+ // Help file name
+ InitHelpFileName();
+
+ // Localize menu strings
+ for (i = 40001; str = (wchar_t *)GetDictionaryValueByInt (i); i++)
+ {
+ info.cbSize = sizeof (info);
+ info.fMask = MIIM_TYPE;
+ info.fType = MFT_STRING;
+ info.dwTypeData = str;
+ info.cch = wcslen (str);
+
+ SetMenuItemInfoW (GetMenu (hwndDlg), i, FALSE, &info);
+ }
+
+ for (i = 0; popupTexts[i] != 0; i++)
+ {
+ str = GetString (popupTexts[i]);
+
+ info.cbSize = sizeof (info);
+ info.fMask = MIIM_TYPE;
+
+ if (strcmp (popupTexts[i], "MENU_WEBSITE") == 0)
+ info.fType = MFT_STRING | MFT_RIGHTJUSTIFY;
+ else
+ info.fType = MFT_STRING;
+
+ if (strcmp (popupTexts[i], "MENU_FAVORITES") == 0)
+ FavoriteVolumesMenu = GetSubMenu (GetMenu (hwndDlg), i);
+
+ info.dwTypeData = str;
+ info.cch = wcslen (str);
+
+ SetMenuItemInfoW (GetMenu (hwndDlg), i, TRUE, &info);
+ }
+
+ try
+ {
+ LoadFavoriteVolumes();
+ }
+ catch (Exception &e)
+ {
+ e.Show (NULL);
+ }
+
+ // Resize the logo bitmap if the user has a non-default DPI
+ if (ScreenDPI != USER_DEFAULT_SCREEN_DPI
+ && hbmLogoBitmapRescaled == NULL) // If not re-called (e.g. after language pack change)
+ {
+ hbmLogoBitmapRescaled = RenderBitmap (MAKEINTRESOURCE (IDB_LOGO_288DPI),
+ GetDlgItem (hwndDlg, IDC_LOGO),
+ 0, 0, 0, 0, FALSE, TRUE);
+ }
+
+ BuildTree (GetDlgItem (hwndDlg, IDC_DRIVELIST));
+
+ if (*szDriveLetter != 0)
+ {
+ SelectItem (GetDlgItem (hwndDlg, IDC_DRIVELIST), *szDriveLetter);
+
+ if(nSelectedDriveIndex > SendMessage (GetDlgItem (hwndDlg, IDC_DRIVELIST), LVM_GETITEMCOUNT, 0, 0)/2)
+ SendMessage(GetDlgItem (hwndDlg, IDC_DRIVELIST), LVM_SCROLL, 0, 10000);
+ }
+
+ SendMessage (GetDlgItem (hwndDlg, IDC_NO_HISTORY), BM_SETCHECK, bHistory ? BST_UNCHECKED : BST_CHECKED, 0);
+ EnableDisableButtons (hwndDlg);
+}
+
+void EnableDisableButtons (HWND hwndDlg)
+{
+ HWND hOKButton = GetDlgItem (hwndDlg, IDOK);
+ WORD x;
+
+ x = LOWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST)));
+
+ EnableMenuItem (GetMenu (hwndDlg), IDM_MOUNT_VOLUME, MF_ENABLED);
+ EnableMenuItem (GetMenu (hwndDlg), IDM_MOUNT_VOLUME_OPTIONS, MF_ENABLED);
+ EnableMenuItem (GetMenu (hwndDlg), IDM_BACKUP_VOL_HEADER, MF_ENABLED);
+ EnableMenuItem (GetMenu (hwndDlg), IDM_RESTORE_VOL_HEADER, MF_ENABLED);
+ EnableMenuItem (GetMenu (hwndDlg), IDM_CHANGE_PASSWORD, MF_ENABLED);
+ EnableWindow (hOKButton, TRUE);
+
+ switch (x)
+ {
+ case TC_MLIST_ITEM_NONSYS_VOL:
+ {
+ SetWindowTextW (hOKButton, GetString ("UNMOUNT_BUTTON"));
+ EnableWindow (hOKButton, TRUE);
+ EnableMenuItem (GetMenu (hwndDlg), IDM_UNMOUNT_VOLUME, MF_ENABLED);
+
+ EnableWindow (GetDlgItem (hwndDlg, IDC_VOLUME_PROPERTIES), TRUE);
+ EnableMenuItem (GetMenu (hwndDlg), IDM_VOLUME_PROPERTIES, MF_ENABLED);
+ }
+ break;
+
+ case TC_MLIST_ITEM_SYS_PARTITION:
+ case TC_MLIST_ITEM_SYS_DRIVE:
+ EnableWindow (hOKButton, FALSE);
+ SetWindowTextW (hOKButton, GetString ("MOUNT_BUTTON"));
+ EnableWindow (GetDlgItem (hwndDlg, IDC_VOLUME_PROPERTIES), TRUE);
+ EnableMenuItem (GetMenu (hwndDlg), IDM_UNMOUNT_VOLUME, MF_GRAYED);
+ break;
+
+ case TC_MLIST_ITEM_FREE:
+ default:
+ SetWindowTextW (hOKButton, GetString ("MOUNT_BUTTON"));
+ EnableWindow (GetDlgItem (hwndDlg, IDC_VOLUME_PROPERTIES), FALSE);
+ EnableMenuItem (GetMenu (hwndDlg), IDM_VOLUME_PROPERTIES, MF_GRAYED);
+ EnableMenuItem (GetMenu (hwndDlg), IDM_UNMOUNT_VOLUME, MF_GRAYED);
+ }
+
+ EnableWindow (GetDlgItem (hwndDlg, IDC_WIPE_CACHE), !IsPasswordCacheEmpty());
+ EnableMenuItem (GetMenu (hwndDlg), IDM_WIPE_CACHE, IsPasswordCacheEmpty() ? MF_GRAYED:MF_ENABLED);
+ EnableMenuItem (GetMenu (hwndDlg), IDM_CLEAR_HISTORY, IsComboEmpty (GetDlgItem (hwndDlg, IDC_VOLUME)) ? MF_GRAYED:MF_ENABLED);
+}
+
+BOOL VolumeSelected (HWND hwndDlg)
+{
+ return (GetWindowTextLength (GetDlgItem (hwndDlg, IDC_VOLUME)) > 0);
+}
+
+/* Returns TRUE if the last partition/drive selected via the Select Device dialog box was the system
+partition/drive and if it is encrypted.
+ WARNING: This function is very fast but not always reliable (for example, if the user manually types
+ a device path before Select Device is invoked during the session; after the Select Device dialog
+ has been invoked at least once, the correct system device paths are cached). Therefore, it must NOT
+ be used before performing any dangerous operations (such as header backup restore or formatting a
+ supposedly non-system device) -- instead use IsSystemDevicePath(path, hwndDlg, TRUE) for such
+ purposes. This function can be used only for preliminary GUI checks requiring very fast responses. */
+BOOL ActiveSysEncDeviceSelected (void)
+{
+ try
+ {
+ BootEncStatus = BootEncObj->GetStatus();
+
+ if (BootEncStatus.DriveEncrypted)
+ {
+ int retCode = 0;
+
+ GetWindowText (GetDlgItem (MainDlg, IDC_VOLUME), szFileName, sizeof (szFileName));
+
+ retCode = IsSystemDevicePath (szFileName, MainDlg, FALSE);
+
+ return (WholeSysDriveEncryption(FALSE) ? (retCode == 2 || retCode == 1) : (retCode == 1));
+ }
+ }
+ catch (Exception &e)
+ {
+ e.Show (MainDlg);
+ }
+
+ return FALSE;
+}
+
+void LoadSettings (HWND hwndDlg)
+{
+ EnableHwEncryption ((ReadDriverConfigurationFlags() & TC_DRIVER_CONFIG_DISABLE_HARDWARE_ENCRYPTION) ? FALSE : TRUE);
+
+ WipeAlgorithmId savedWipeAlgorithm = TC_WIPE_NONE;
+
+ LoadSysEncSettings (hwndDlg);
+
+ if (LoadNonSysInPlaceEncSettings (&savedWipeAlgorithm) != 0)
+ bInPlaceEncNonSysPending = TRUE;
+
+ // If the config file has already been loaded during this session
+ if (ConfigBuffer != NULL)
+ {
+ free (ConfigBuffer);
+ ConfigBuffer = NULL;
+ }
+
+ // Options
+ bExplore = ConfigReadInt ("OpenExplorerWindowAfterMount", FALSE);
+ bUseDifferentTrayIconIfVolMounted = ConfigReadInt ("UseDifferentTrayIconIfVolumesMounted", TRUE);
+
+ bHistory = ConfigReadInt ("SaveVolumeHistory", FALSE);
+
+ bCacheInDriverDefault = bCacheInDriver = ConfigReadInt ("CachePasswords", FALSE);
+ bWipeCacheOnExit = ConfigReadInt ("WipePasswordCacheOnExit", FALSE);
+ bWipeCacheOnAutoDismount = ConfigReadInt ("WipeCacheOnAutoDismount", TRUE);
+
+ bStartOnLogon = ConfigReadInt ("StartOnLogon", FALSE);
+ bMountDevicesOnLogon = ConfigReadInt ("MountDevicesOnLogon", FALSE);
+ bMountFavoritesOnLogon = ConfigReadInt ("MountFavoritesOnLogon", FALSE);
+
+ bEnableBkgTask = ConfigReadInt ("EnableBackgroundTask", TRUE);
+ bCloseBkgTaskWhenNoVolumes = ConfigReadInt ("CloseBackgroundTaskOnNoVolumes", FALSE);
+
+ bDismountOnLogOff = ConfigReadInt ("DismountOnLogOff", !(IsServerOS() && IsAdmin()));
+ bDismountOnPowerSaving = ConfigReadInt ("DismountOnPowerSaving", FALSE);
+ bDismountOnScreenSaver = ConfigReadInt ("DismountOnScreenSaver", FALSE);
+ bForceAutoDismount = ConfigReadInt ("ForceAutoDismount", TRUE);
+ MaxVolumeIdleTime = ConfigReadInt ("MaxVolumeIdleTime", -60);
+
+ HiddenSectorDetectionStatus = ConfigReadInt ("HiddenSectorDetectionStatus", 0);
+
+ defaultKeyFilesParam.EnableKeyFiles = ConfigReadInt ("UseKeyfiles", FALSE);
+
+ bPreserveTimestamp = defaultMountOptions.PreserveTimestamp = ConfigReadInt ("PreserveTimestamps", TRUE);
+ defaultMountOptions.Removable = ConfigReadInt ("MountVolumesRemovable", FALSE);
+ defaultMountOptions.ReadOnly = ConfigReadInt ("MountVolumesReadOnly", FALSE);
+ defaultMountOptions.ProtectHiddenVolume = FALSE;
+ defaultMountOptions.PartitionInInactiveSysEncScope = FALSE;
+ defaultMountOptions.RecoveryMode = FALSE;
+ defaultMountOptions.UseBackupHeader = FALSE;
+
+ mountOptions = defaultMountOptions;
+
+ CloseSecurityTokenSessionsAfterMount = ConfigReadInt ("CloseSecurityTokenSessionsAfterMount", 0);
+ DisableSystemCrashDetection = ConfigReadInt ("DisableSystemCrashDetection", FALSE);
+
+ if (IsHiddenOSRunning())
+ HiddenSysLeakProtectionNotificationStatus = ConfigReadInt ("HiddenSystemLeakProtNotifStatus", TC_HIDDEN_OS_READ_ONLY_NOTIF_MODE_NONE);
+
+ // Drive letter - command line arg overrides registry
+ if (szDriveLetter[0] == 0)
+ ConfigReadString ("LastSelectedDrive", "", szDriveLetter, sizeof (szDriveLetter));
+
+ ConfigReadString ("SecurityTokenLibrary", "", SecurityTokenLibraryPath, sizeof (SecurityTokenLibraryPath) - 1);
+ if (SecurityTokenLibraryPath[0])
+ InitSecurityTokenLibrary();
+
+ // Hotkeys
+ bPlaySoundOnSuccessfulHkDismount = ConfigReadInt ("PlaySoundOnHotkeyMountDismount", TRUE);
+ bDisplayBalloonOnSuccessfulHkDismount = ConfigReadInt ("DisplayMsgBoxOnHotkeyDismount", TRUE);
+ Hotkeys [HK_AUTOMOUNT_DEVICES].vKeyModifiers = ConfigReadInt ("HotkeyModAutoMountDevices", 0);
+ Hotkeys [HK_AUTOMOUNT_DEVICES].vKeyCode = ConfigReadInt ("HotkeyCodeAutoMountDevices", 0);
+ Hotkeys [HK_DISMOUNT_ALL].vKeyModifiers = ConfigReadInt ("HotkeyModDismountAll", 0);
+ Hotkeys [HK_DISMOUNT_ALL].vKeyCode = ConfigReadInt ("HotkeyCodeDismountAll", 0);
+ Hotkeys [HK_WIPE_CACHE].vKeyModifiers = ConfigReadInt ("HotkeyModWipeCache", 0);
+ Hotkeys [HK_WIPE_CACHE].vKeyCode = ConfigReadInt ("HotkeyCodeWipeCache", 0);
+ Hotkeys [HK_DISMOUNT_ALL_AND_WIPE].vKeyModifiers = ConfigReadInt ("HotkeyModDismountAllWipe", 0);
+ Hotkeys [HK_DISMOUNT_ALL_AND_WIPE].vKeyCode = ConfigReadInt ("HotkeyCodeDismountAllWipe", 0);
+ Hotkeys [HK_FORCE_DISMOUNT_ALL_AND_WIPE].vKeyModifiers = ConfigReadInt ("HotkeyModForceDismountAllWipe", 0);
+ Hotkeys [HK_FORCE_DISMOUNT_ALL_AND_WIPE].vKeyCode = ConfigReadInt ("HotkeyCodeForceDismountAllWipe", 0);
+ Hotkeys [HK_FORCE_DISMOUNT_ALL_AND_WIPE_AND_EXIT].vKeyModifiers = ConfigReadInt ("HotkeyModForceDismountAllWipeExit", 0);
+ Hotkeys [HK_FORCE_DISMOUNT_ALL_AND_WIPE_AND_EXIT].vKeyCode = ConfigReadInt ("HotkeyCodeForceDismountAllWipeExit", 0);
+ Hotkeys [HK_MOUNT_FAVORITE_VOLUMES].vKeyModifiers = ConfigReadInt ("HotkeyModMountFavoriteVolumes", 0);
+ Hotkeys [HK_MOUNT_FAVORITE_VOLUMES].vKeyCode = ConfigReadInt ("HotkeyCodeMountFavoriteVolumes", 0);
+ Hotkeys [HK_SHOW_HIDE_MAIN_WINDOW].vKeyModifiers = ConfigReadInt ("HotkeyModShowHideMainWindow", 0);
+ Hotkeys [HK_SHOW_HIDE_MAIN_WINDOW].vKeyCode = ConfigReadInt ("HotkeyCodeShowHideMainWindow", 0);
+ Hotkeys [HK_CLOSE_SECURITY_TOKEN_SESSIONS].vKeyModifiers = ConfigReadInt ("HotkeyModCloseSecurityTokenSessions", 0);
+ Hotkeys [HK_CLOSE_SECURITY_TOKEN_SESSIONS].vKeyCode = ConfigReadInt ("HotkeyCodeCloseSecurityTokenSessions", 0);
+
+ // History
+ if (bHistoryCmdLine != TRUE)
+ {
+ LoadCombo (GetDlgItem (hwndDlg, IDC_VOLUME));
+ if (CmdLineVolumeSpecified)
+ SetWindowText (GetDlgItem (hwndDlg, IDC_VOLUME), szFileName);
+ }
+}
+
+void SaveSettings (HWND hwndDlg)
+{
+ WaitCursor ();
+
+ char szTmp[32] = {0};
+ LPARAM lLetter;
+
+ // Options
+ ConfigWriteBegin ();
+
+ ConfigWriteInt ("OpenExplorerWindowAfterMount", bExplore);
+ ConfigWriteInt ("UseDifferentTrayIconIfVolumesMounted", bUseDifferentTrayIconIfVolMounted);
+ ConfigWriteInt ("SaveVolumeHistory", !IsButtonChecked (GetDlgItem (hwndDlg, IDC_NO_HISTORY)));
+
+ ConfigWriteInt ("CachePasswords", bCacheInDriverDefault);
+ ConfigWriteInt ("WipePasswordCacheOnExit", bWipeCacheOnExit);
+ ConfigWriteInt ("WipeCacheOnAutoDismount", bWipeCacheOnAutoDismount);
+
+ ConfigWriteInt ("StartOnLogon", bStartOnLogon);
+ ConfigWriteInt ("MountDevicesOnLogon", bMountDevicesOnLogon);
+ ConfigWriteInt ("MountFavoritesOnLogon", bMountFavoritesOnLogon);
+
+ ConfigWriteInt ("MountVolumesReadOnly", defaultMountOptions.ReadOnly);
+ ConfigWriteInt ("MountVolumesRemovable", defaultMountOptions.Removable);
+ ConfigWriteInt ("PreserveTimestamps", defaultMountOptions.PreserveTimestamp);
+
+ ConfigWriteInt ("EnableBackgroundTask", bEnableBkgTask);
+ ConfigWriteInt ("CloseBackgroundTaskOnNoVolumes", bCloseBkgTaskWhenNoVolumes);
+
+ ConfigWriteInt ("DismountOnLogOff", bDismountOnLogOff);
+ ConfigWriteInt ("DismountOnPowerSaving", bDismountOnPowerSaving);
+ ConfigWriteInt ("DismountOnScreenSaver", bDismountOnScreenSaver);
+ ConfigWriteInt ("ForceAutoDismount", bForceAutoDismount);
+ ConfigWriteInt ("MaxVolumeIdleTime", MaxVolumeIdleTime);
+
+ ConfigWriteInt ("HiddenSectorDetectionStatus", HiddenSectorDetectionStatus);
+
+ ConfigWriteInt ("UseKeyfiles", defaultKeyFilesParam.EnableKeyFiles);
+
+ if (IsHiddenOSRunning())
+ ConfigWriteInt ("HiddenSystemLeakProtNotifStatus", HiddenSysLeakProtectionNotificationStatus);
+
+ // Drive Letter
+ lLetter = GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST));
+ if (LOWORD (lLetter) != 0xffff)
+ sprintf (szTmp, "%c:", (char) HIWORD (lLetter));
+ ConfigWriteString ("LastSelectedDrive", szTmp);
+
+ ConfigWriteInt ("CloseSecurityTokenSessionsAfterMount", CloseSecurityTokenSessionsAfterMount);
+ ConfigWriteInt ("DisableSystemCrashDetection", DisableSystemCrashDetection);
+
+ // Hotkeys
+ ConfigWriteInt ("HotkeyModAutoMountDevices", Hotkeys[HK_AUTOMOUNT_DEVICES].vKeyModifiers);
+ ConfigWriteInt ("HotkeyCodeAutoMountDevices", Hotkeys[HK_AUTOMOUNT_DEVICES].vKeyCode);
+ ConfigWriteInt ("HotkeyModDismountAll", Hotkeys[HK_DISMOUNT_ALL].vKeyModifiers);
+ ConfigWriteInt ("HotkeyCodeDismountAll", Hotkeys[HK_DISMOUNT_ALL].vKeyCode);
+ ConfigWriteInt ("HotkeyModWipeCache", Hotkeys[HK_WIPE_CACHE].vKeyModifiers);
+ ConfigWriteInt ("HotkeyCodeWipeCache", Hotkeys[HK_WIPE_CACHE].vKeyCode);
+ ConfigWriteInt ("HotkeyModDismountAllWipe", Hotkeys[HK_DISMOUNT_ALL_AND_WIPE].vKeyModifiers);
+ ConfigWriteInt ("HotkeyCodeDismountAllWipe", Hotkeys[HK_DISMOUNT_ALL_AND_WIPE].vKeyCode);
+ ConfigWriteInt ("HotkeyModForceDismountAllWipe", Hotkeys[HK_FORCE_DISMOUNT_ALL_AND_WIPE].vKeyModifiers);
+ ConfigWriteInt ("HotkeyCodeForceDismountAllWipe", Hotkeys[HK_FORCE_DISMOUNT_ALL_AND_WIPE].vKeyCode);
+ ConfigWriteInt ("HotkeyModForceDismountAllWipeExit", Hotkeys[HK_FORCE_DISMOUNT_ALL_AND_WIPE_AND_EXIT].vKeyModifiers);
+ ConfigWriteInt ("HotkeyCodeForceDismountAllWipeExit", Hotkeys[HK_FORCE_DISMOUNT_ALL_AND_WIPE_AND_EXIT].vKeyCode);
+ ConfigWriteInt ("HotkeyModMountFavoriteVolumes", Hotkeys[HK_MOUNT_FAVORITE_VOLUMES].vKeyModifiers);
+ ConfigWriteInt ("HotkeyCodeMountFavoriteVolumes", Hotkeys[HK_MOUNT_FAVORITE_VOLUMES].vKeyCode);
+ ConfigWriteInt ("HotkeyModShowHideMainWindow", Hotkeys[HK_SHOW_HIDE_MAIN_WINDOW].vKeyModifiers);
+ ConfigWriteInt ("HotkeyCodeShowHideMainWindow", Hotkeys[HK_SHOW_HIDE_MAIN_WINDOW].vKeyCode);
+ ConfigWriteInt ("HotkeyModCloseSecurityTokenSessions", Hotkeys[HK_CLOSE_SECURITY_TOKEN_SESSIONS].vKeyModifiers);
+ ConfigWriteInt ("HotkeyCodeCloseSecurityTokenSessions", Hotkeys[HK_CLOSE_SECURITY_TOKEN_SESSIONS].vKeyCode);
+ ConfigWriteInt ("PlaySoundOnHotkeyMountDismount", bPlaySoundOnSuccessfulHkDismount);
+ ConfigWriteInt ("DisplayMsgBoxOnHotkeyDismount", bDisplayBalloonOnSuccessfulHkDismount);
+
+ // Language
+ if (GetPreferredLangId () != NULL)
+ ConfigWriteString ("Language", GetPreferredLangId ());
+
+ // PKCS#11 Library Path
+ ConfigWriteString ("SecurityTokenLibrary", SecurityTokenLibraryPath[0] ? SecurityTokenLibraryPath : "");
+
+ ConfigWriteEnd ();
+
+ // History
+ DumpCombo (GetDlgItem (hwndDlg, IDC_VOLUME), IsButtonChecked (GetDlgItem (hwndDlg, IDC_NO_HISTORY)));
+
+ NormalCursor ();
+}
+
+// Returns TRUE if system encryption or decryption had been or is in progress and has not been completed
+static BOOL SysEncryptionOrDecryptionRequired (void)
+{
+ /* If you update this function, revise SysEncryptionOrDecryptionRequired() in Tcformat.c as well. */
+
+ try
+ {
+ BootEncStatus = BootEncObj->GetStatus();
+ }
+ catch (Exception &e)
+ {
+ e.Show (MainDlg);
+ }
+
+ return (SystemEncryptionStatus == SYSENC_STATUS_ENCRYPTING
+ || SystemEncryptionStatus == SYSENC_STATUS_DECRYPTING
+ ||
+ (
+ BootEncStatus.DriveMounted
+ &&
+ (
+ BootEncStatus.ConfiguredEncryptedAreaStart != BootEncStatus.EncryptedAreaStart
+ || BootEncStatus.ConfiguredEncryptedAreaEnd != BootEncStatus.EncryptedAreaEnd
+ )
+ )
+ );
+}
+
+// Returns TRUE if the system partition/drive is completely encrypted
+static BOOL SysDriveOrPartitionFullyEncrypted (BOOL bSilent)
+{
+ /* If you update this function, revise SysDriveOrPartitionFullyEncrypted() in Tcformat.c as well. */
+
+ try
+ {
+ BootEncStatus = BootEncObj->GetStatus();
+ }
+ catch (Exception &e)
+ {
+ if (!bSilent)
+ e.Show (MainDlg);
+ }
+
+ return (!BootEncStatus.SetupInProgress
+ && BootEncStatus.ConfiguredEncryptedAreaEnd != 0
+ && BootEncStatus.ConfiguredEncryptedAreaEnd != -1
+ && BootEncStatus.ConfiguredEncryptedAreaStart == BootEncStatus.EncryptedAreaStart
+ && BootEncStatus.ConfiguredEncryptedAreaEnd == BootEncStatus.EncryptedAreaEnd);
+}
+
+// Returns TRUE if the system partition/drive is being filtered by the TrueCrypt driver and the key data
+// was successfully decrypted (the device is fully ready to be encrypted or decrypted). Note that this
+// function does not examine whether the system device is encrypted or not (or to what extent).
+static BOOL SysEncDeviceActive (BOOL bSilent)
+{
+ try
+ {
+ BootEncStatus = BootEncObj->GetStatus();
+ }
+ catch (Exception &e)
+ {
+ if (!bSilent)
+ e.Show (MainDlg);
+
+ return FALSE;
+ }
+
+ return (BootEncStatus.DriveMounted);
+}
+
+// Returns TRUE if the entire system drive (as opposed to the system partition only) is (or is to be) encrypted
+BOOL WholeSysDriveEncryption (BOOL bSilent)
+{
+ try
+ {
+ BootEncStatus = BootEncObj->GetStatus();
+
+ return (BootEncStatus.ConfiguredEncryptedAreaStart == TC_BOOT_LOADER_AREA_SIZE
+ && BootEncStatus.ConfiguredEncryptedAreaEnd >= BootEncStatus.BootDriveLength.QuadPart - 1);
+ }
+ catch (Exception &e)
+ {
+ if (!bSilent)
+ e.Show (MainDlg);
+
+ return FALSE;
+ }
+}
+
+// Returns the size of the system drive/partition (if encrypted) in bytes
+unsigned __int64 GetSysEncDeviceSize (BOOL bSilent)
+{
+ try
+ {
+ BootEncStatus = BootEncObj->GetStatus();
+ }
+ catch (Exception &e)
+ {
+ if (!bSilent)
+ e.Show (MainDlg);
+ }
+
+ return (BootEncStatus.ConfiguredEncryptedAreaEnd - BootEncStatus.ConfiguredEncryptedAreaStart + 1);
+}
+
+// Returns the current size of the encrypted area of the system drive/partition in bytes
+unsigned __int64 GetSysEncDeviceEncryptedPartSize (BOOL bSilent)
+{
+ try
+ {
+ BootEncStatus = BootEncObj->GetStatus();
+ }
+ catch (Exception &e)
+ {
+ if (!bSilent)
+ e.Show (MainDlg);
+ }
+
+ return (BootEncStatus.EncryptedAreaEnd - BootEncStatus.EncryptedAreaStart + 1);
+}
+
+
+static void PopulateSysEncContextMenu (HMENU popup, BOOL bToolsOnly)
+{
+ try
+ {
+ BootEncStatus = BootEncObj->GetStatus();
+ }
+ catch (Exception &e)
+ {
+ e.Show (MainDlg);
+ }
+
+ if (!bToolsOnly && !IsHiddenOSRunning())
+ {
+ if (SysEncryptionOrDecryptionRequired ())
+ {
+ if (!BootEncStatus.SetupInProgress)
+ AppendMenuW (popup, MF_STRING, IDM_SYSENC_RESUME, GetString ("IDM_SYSENC_RESUME"));
+
+ if (SystemEncryptionStatus != SYSENC_STATUS_DECRYPTING)
+ AppendMenuW (popup, MF_STRING, IDM_PERMANENTLY_DECRYPT_SYS, GetString ("PERMANENTLY_DECRYPT"));
+
+ AppendMenuW (popup, MF_STRING, IDM_ENCRYPT_SYSTEM_DEVICE, GetString ("ENCRYPT"));
+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);
+ }
+ }
+
+ AppendMenuW (popup, MF_STRING, IDM_CHANGE_SYS_PASSWORD, GetString ("IDM_CHANGE_SYS_PASSWORD"));
+ AppendMenuW (popup, MF_STRING, IDM_CHANGE_SYS_HEADER_KEY_DERIV_ALGO, GetString ("IDM_CHANGE_SYS_HEADER_KEY_DERIV_ALGO"));
+
+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);
+ AppendMenuW (popup, MF_STRING, IDM_SYS_ENC_SETTINGS, GetString ("IDM_SYS_ENC_SETTINGS"));
+
+ if (!IsHiddenOSRunning())
+ {
+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);
+ AppendMenuW (popup, MF_STRING, IDM_CREATE_RESCUE_DISK, GetString ("IDM_CREATE_RESCUE_DISK"));
+ AppendMenuW (popup, MF_STRING, IDM_VERIFY_RESCUE_DISK, GetString ("IDM_VERIFY_RESCUE_DISK"));
+ }
+
+ if (!bToolsOnly)
+ {
+ if (SysDriveOrPartitionFullyEncrypted (FALSE) && !IsHiddenOSRunning())
+ {
+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);
+ AppendMenuW (popup, MF_STRING, IDM_PERMANENTLY_DECRYPT_SYS, GetString ("PERMANENTLY_DECRYPT"));
+ }
+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);
+ AppendMenuW (popup, MF_STRING, IDM_VOLUME_PROPERTIES, GetString ("IDPM_PROPERTIES"));
+ }
+}
+
+
+// WARNING: This function may take a long time to complete. To prevent data corruption, it MUST be called before
+// mounting a partition (as a regular volume) that is within key scope of system encryption.
+// Returns TRUE if the partition can be mounted as a partition within key scope of inactive system encryption.
+// If devicePath is empty, the currently selected partition in the GUI is checked.
+BOOL CheckSysEncMountWithoutPBA (const char *devicePath, BOOL quiet)
+{
+ BOOL tmpbDevice;
+ char szDevicePath [TC_MAX_PATH+1];
+ char szDiskFile [TC_MAX_PATH+1];
+
+ if (strlen (devicePath) < 2)
+ {
+ GetWindowText (GetDlgItem (MainDlg, IDC_VOLUME), szDevicePath, sizeof (szDevicePath));
+ CreateFullVolumePath (szDiskFile, szDevicePath, &tmpbDevice);
+
+ if (!tmpbDevice)
+ {
+ if (!quiet)
+ Warning ("NO_SYSENC_PARTITION_SELECTED");
+
+ return FALSE;
+ }
+
+ if (LOWORD (GetSelectedLong (GetDlgItem (MainDlg, IDC_DRIVELIST))) != TC_MLIST_ITEM_FREE)
+ {
+ if (!quiet)
+ Warning ("SELECT_FREE_DRIVE");
+
+ return FALSE;
+ }
+ }
+ else
+ strncpy (szDevicePath, devicePath, sizeof (szDevicePath));
+
+ char *partionPortion = strrchr (szDevicePath, '\\');
+
+ if (!partionPortion
+ || !_stricmp (partionPortion, "\\Partition0"))
+ {
+ // Only partitions are supported (not whole drives)
+ if (!quiet)
+ Warning ("NO_SYSENC_PARTITION_SELECTED");
+
+ return FALSE;
+ }
+
+ try
+ {
+ BootEncStatus = BootEncObj->GetStatus();
+
+ if (BootEncStatus.DriveMounted)
+ {
+ int retCode = 0;
+ int driveNo;
+ char parentDrivePath [TC_MAX_PATH+1];
+
+ if (sscanf (szDevicePath, "\\Device\\Harddisk%d\\Partition", &driveNo) != 1)
+ {
+ if (!quiet)
+ Error ("INVALID_PATH");
+
+ return FALSE;
+ }
+
+ _snprintf (parentDrivePath,
+ sizeof (parentDrivePath),
+ "\\Device\\Harddisk%d\\Partition0",
+ driveNo);
+
+ WaitCursor ();
+
+ // This is critical (re-mounting a mounted system volume as a normal volume could cause data corruption)
+ // so we force the slower but reliable method
+ retCode = IsSystemDevicePath (parentDrivePath, MainDlg, TRUE);
+
+ NormalCursor();
+
+ if (retCode != 2)
+ return TRUE;
+ else
+ {
+ // The partition is located on active system drive
+
+ if (!quiet)
+ Warning ("MOUNT_WITHOUT_PBA_VOL_ON_ACTIVE_SYSENC_DRIVE");
+
+ return FALSE;
+ }
+ }
+ else
+ return TRUE;
+ }
+ catch (Exception &e)
+ {
+ NormalCursor();
+ e.Show (MainDlg);
+ }
+
+ return FALSE;
+}
+
+
+// Returns TRUE if the host drive of the specified partition contains a portion of the TrueCrypt Boot Loader
+// and if the drive is not within key scope of active system encryption (e.g. the system drive of the running OS).
+// If bPrebootPasswordDlgMode is TRUE, this function returns FALSE (because the check would be redundant).
+BOOL TCBootLoaderOnInactiveSysEncDrive (void)
+{
+ try
+ {
+ int driveNo;
+ char szDevicePath [TC_MAX_PATH+1];
+ char parentDrivePath [TC_MAX_PATH+1];
+
+ if (bPrebootPasswordDlgMode)
+ return FALSE;
+
+ GetWindowText (GetDlgItem (MainDlg, IDC_VOLUME), szDevicePath, sizeof (szDevicePath));
+
+ if (sscanf (szDevicePath, "\\Device\\Harddisk%d\\Partition", &driveNo) != 1)
+ return FALSE;
+
+ _snprintf (parentDrivePath,
+ sizeof (parentDrivePath),
+ "\\Device\\Harddisk%d\\Partition0",
+ driveNo);
+
+ BootEncStatus = BootEncObj->GetStatus();
+
+ if (BootEncStatus.DriveMounted
+ && IsSystemDevicePath (parentDrivePath, MainDlg, FALSE) == 2)
+ {
+ // The partition is within key scope of active system encryption
+ return FALSE;
+ }
+
+ return ((BOOL) BootEncObj->IsBootLoaderOnDrive (parentDrivePath));
+ }
+ catch (...)
+ {
+ return FALSE;
+ }
+
+}
+
+
+BOOL SelectItem (HWND hTree, char nLetter)
+{
+ if (nLetter == 0)
+ {
+ // The caller specified an invalid drive letter (typically because it is unknown).
+ // Find out which drive letter is currently selected in the list and use it.
+ nLetter = (char) (HIWORD (GetSelectedLong (hTree)));
+ }
+
+ int i;
+ LVITEM item;
+
+ for (i = 0; i < ListView_GetItemCount(hTree); i++)
+ {
+ memset(&item, 0, sizeof(LVITEM));
+ item.mask = LVIF_PARAM;
+ item.iItem = i;
+
+ if (ListView_GetItem (hTree, &item) == FALSE)
+ return FALSE;
+ else
+ {
+ if (HIWORD (item.lParam) == nLetter)
+ {
+ memset(&item, 0, sizeof(LVITEM));
+ item.state = LVIS_FOCUSED|LVIS_SELECTED;
+ item.stateMask = LVIS_FOCUSED|LVIS_SELECTED;
+ item.mask = LVIF_STATE;
+ item.iItem = i;
+ SendMessage(hTree, LVM_SETITEMSTATE, i, (LPARAM) &item);
+ return TRUE;
+ }
+ }
+ }
+
+ return TRUE;
+}
+
+
+static void LaunchVolCreationWizard (HWND hwndDlg, const char *arg)
+{
+ char t[TC_MAX_PATH] = {'"',0};
+ char *tmp;
+
+ GetModuleFileName (NULL, t+1, sizeof(t)-1);
+
+ tmp = strrchr (t, '\\');
+ if (tmp)
+ {
+ STARTUPINFO si;
+ PROCESS_INFORMATION pi;
+ ZeroMemory (&si, sizeof (si));
+
+ strcpy (++tmp, "TrueCrypt Format.exe\"");
+
+ if (!FileExists(t))
+ Error ("VOL_CREATION_WIZARD_NOT_FOUND"); // Display a user-friendly error message and advise what to do
+
+ if (strlen (arg) > 0)
+ {
+ strcat (t, " ");
+ strcat (t, arg);
+ }
+
+ if (!CreateProcess (NULL, (LPSTR) t, NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS, NULL, NULL, &si, &pi))
+ {
+ handleWin32Error (hwndDlg);
+ }
+ else
+ {
+ CloseHandle (pi.hProcess);
+ CloseHandle (pi.hThread);
+ }
+ }
+}
+
+
+// Fills drive list
+// drive>0 = update only the corresponding drive subitems
+void LoadDriveLetters (HWND hTree, int drive)
+{
+ // Remember the top-most visible item
+ int lastTopMostVisibleItem = ListView_GetTopIndex (hTree);
+
+ char *szDriveLetters[]=
+ {"A:", "B:", "C:", "D:",
+ "E:", "F:", "G:", "H:", "I:", "J:", "K:",
+ "L:", "M:", "N:", "O:", "P:", "Q:", "R:",
+ "S:", "T:", "U:", "V:", "W:", "X:", "Y:",
+ "Z:"};
+
+ DWORD dwResult;
+ BOOL bResult;
+ DWORD dwUsedDrives;
+ MOUNT_LIST_STRUCT driver;
+ VOLUME_PROPERTIES_STRUCT propSysEnc;
+ char sysDriveLetter = 0;
+
+ BOOL bSysEnc = FALSE;
+ BOOL bWholeSysDriveEncryption = FALSE;
+
+ LVITEM listItem;
+ int item = 0;
+ char i;
+
+ try
+ {
+ BootEncStatus = BootEncObj->GetStatus();
+ if (bSysEnc = BootEncStatus.DriveMounted)
+ {
+ BootEncObj->GetVolumeProperties (&propSysEnc);
+ }
+ }
+ catch (...)
+ {
+ bSysEnc = FALSE;
+ }
+
+ ZeroMemory (&driver, sizeof (driver));
+ bResult = DeviceIoControl (hDriver, TC_IOCTL_GET_MOUNTED_VOLUMES, &driver,
+ sizeof (driver), &driver, sizeof (driver), &dwResult,
+ NULL);
+ memcpy (&LastKnownMountList, &driver, sizeof (driver));
+
+ if (bResult == FALSE)
+ {
+ KillTimer (MainDlg, TIMER_ID_MAIN);
+ handleWin32Error (hTree);
+ AbortProcessSilent();
+ }
+
+ LastKnownLogicalDrives = dwUsedDrives = GetLogicalDrives ();
+ if (dwUsedDrives == 0)
+ Warning ("DRIVELETTERS");
+
+ if(drive == 0)
+ ListView_DeleteAllItems(hTree);
+
+ if (bSysEnc)
+ {
+ bWholeSysDriveEncryption = WholeSysDriveEncryption (TRUE);
+
+ sysDriveLetter = GetSystemDriveLetter ();
+ }
+
+ /* System drive */
+
+ if (bWholeSysDriveEncryption)
+ {
+ int curDrive = 0;
+
+ if (drive > 0)
+ {
+ LVITEM tmp;
+ memset(&tmp, 0, sizeof(LVITEM));
+ tmp.mask = LVIF_PARAM;
+ tmp.iItem = item;
+ if (ListView_GetItem (hTree, &tmp))
+ curDrive = HIWORD(tmp.lParam);
+ }
+
+ {
+ char szTmp[1024];
+ wchar_t szTmpW[1024];
+
+ memset(&listItem, 0, sizeof(listItem));
+
+ listItem.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
+ listItem.iImage = 2;
+ listItem.iItem = item++;
+
+ listItem.pszText = szTmp;
+ strcpy (szTmp, " ");
+
+ listItem.lParam = MAKELONG (TC_MLIST_ITEM_SYS_DRIVE, ENC_SYSDRIVE_PSEUDO_DRIVE_LETTER);
+
+ if(drive == 0)
+ ListView_InsertItem (hTree, &listItem);
+ else
+ ListView_SetItem (hTree, &listItem);
+
+ listItem.mask=LVIF_TEXT;
+
+ // Fully encrypted
+ if (SysDriveOrPartitionFullyEncrypted (TRUE))
+ {
+ wcscpy (szTmpW, GetString ("SYSTEM_DRIVE"));
+ }
+ else
+ {
+ // Partially encrypted
+
+ if (BootEncStatus.SetupInProgress)
+ {
+ // Currently encrypting/decrypting
+
+ if (BootEncStatus.SetupMode != SetupDecryption)
+ {
+ _snwprintf (szTmpW,
+ sizeof szTmpW/2,
+ GetString ("SYSTEM_DRIVE_ENCRYPTING"),
+ (double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0);
+ }
+ else
+ {
+ _snwprintf (szTmpW,
+ sizeof szTmpW/2,
+ GetString ("SYSTEM_DRIVE_DECRYPTING"),
+ 100.0 - ((double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0));
+ }
+ }
+ else
+ {
+ _snwprintf (szTmpW,
+ sizeof szTmpW/2,
+ GetString ("SYSTEM_DRIVE_PARTIALLY_ENCRYPTED"),
+ (double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0);
+ }
+ }
+
+ ListSubItemSetW (hTree, listItem.iItem, 1, szTmpW);
+
+ GetSizeString (GetSysEncDeviceSize(TRUE), szTmpW);
+ ListSubItemSetW (hTree, listItem.iItem, 2, szTmpW);
+
+ EAGetName (szTmp, propSysEnc.ea);
+ listItem.iSubItem = 3;
+ ListView_SetItem (hTree, &listItem);
+
+ ListSubItemSetW (hTree, listItem.iItem, 4, GetString (IsHiddenOSRunning() ? "HIDDEN" : "SYSTEM_VOLUME_TYPE_ADJECTIVE"));
+ }
+ }
+
+ /* Drive letters */
+
+ for (i = 2; i < 26; i++)
+ {
+ int curDrive = 0;
+
+ BOOL bSysEncPartition = (bSysEnc && !bWholeSysDriveEncryption && sysDriveLetter == *((char *) szDriveLetters[i]));
+
+ if (drive > 0)
+ {
+ LVITEM tmp;
+ memset(&tmp, 0, sizeof(LVITEM));
+ tmp.mask = LVIF_PARAM;
+ tmp.iItem = item;
+ if (ListView_GetItem (hTree, &tmp))
+ curDrive = HIWORD(tmp.lParam);
+ }
+
+ if (driver.ulMountedDrives & (1 << i)
+ || bSysEncPartition)
+ {
+ char szTmp[1024];
+ wchar_t szTmpW[1024];
+ wchar_t *ws;
+
+ memset(&listItem, 0, sizeof(listItem));
+
+ listItem.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
+ listItem.iImage = bSysEncPartition ? 2 : 1;
+ listItem.iItem = item++;
+
+ if (drive > 0 && drive != curDrive)
+ continue;
+
+ listItem.lParam = MAKELONG (
+ bSysEncPartition ? TC_MLIST_ITEM_SYS_PARTITION : TC_MLIST_ITEM_NONSYS_VOL,
+ i + 'A');
+
+ listItem.pszText = szDriveLetters[i];
+
+ if (drive == 0)
+ ListView_InsertItem (hTree, &listItem);
+ else
+ ListView_SetItem (hTree, &listItem);
+
+ listItem.mask=LVIF_TEXT;
+ listItem.pszText = szTmp;
+
+ if (bSysEncPartition)
+ {
+ // Fully encrypted
+ if (SysDriveOrPartitionFullyEncrypted (TRUE))
+ {
+ wcscpy (szTmpW, GetString (IsHiddenOSRunning() ? "HIDDEN_SYSTEM_PARTITION" : "SYSTEM_PARTITION"));
+ }
+ else
+ {
+ // Partially encrypted
+
+ if (BootEncStatus.SetupInProgress)
+ {
+ // Currently encrypting/decrypting
+
+ if (BootEncStatus.SetupMode != SetupDecryption)
+ {
+ _snwprintf (szTmpW,
+ sizeof szTmpW/2,
+ GetString ("SYSTEM_PARTITION_ENCRYPTING"),
+ (double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0);
+ }
+ else
+ {
+ _snwprintf (szTmpW,
+ sizeof szTmpW/2,
+ GetString ("SYSTEM_PARTITION_DECRYPTING"),
+ 100.0 - ((double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0));
+ }
+ }
+ else
+ {
+ _snwprintf (szTmpW,
+ sizeof szTmpW/2,
+ GetString ("SYSTEM_PARTITION_PARTIALLY_ENCRYPTED"),
+ (double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0);
+ }
+ }
+
+ ListSubItemSetW (hTree, listItem.iItem, 1, szTmpW);
+ }
+ else
+ {
+ ToSBCS (driver.wszVolume[i]);
+ char *path = (char *) driver.wszVolume[i];
+
+ if (memcmp (path, "\\??\\", 4) == 0)
+ path += 4;
+
+ listItem.iSubItem = 1;
+
+ wstring label = GetFavoriteVolumeLabel (path);
+ if (!label.empty())
+ ListSubItemSetW (hTree, listItem.iItem, 1, (wchar_t *) label.c_str());
+ else
+ ListSubItemSet (hTree, listItem.iItem, 1, (char *) FitPathInGfxWidth (hTree, hUserFont, ListView_GetColumnWidth (hTree, 1) - GetTextGfxWidth (hTree, L"___", hUserFont), path).c_str());
+ }
+
+ GetSizeString (bSysEncPartition ? GetSysEncDeviceSize(TRUE) : driver.diskLength[i], szTmpW);
+ ListSubItemSetW (hTree, listItem.iItem, 2, szTmpW);
+
+ EAGetName (szTmp, bSysEncPartition ? propSysEnc.ea : driver.ea[i]);
+ listItem.iSubItem = 3;
+ ListView_SetItem (hTree, &listItem);
+
+ if (bSysEncPartition)
+ {
+ ws = GetString (IsHiddenOSRunning() ? "HIDDEN" : "SYSTEM_VOLUME_TYPE_ADJECTIVE");
+ VolumeNotificationsList.bHidVolDamagePrevReported[i] = FALSE;
+ ListSubItemSetW (hTree, listItem.iItem, 4, ws);
+ }
+ else
+ {
+ switch (driver.volumeType[i])
+ {
+ case PROP_VOL_TYPE_NORMAL:
+ ws = GetString ("NORMAL");
+ break;
+ case PROP_VOL_TYPE_HIDDEN:
+ ws = GetString ("HIDDEN");
+ break;
+ case PROP_VOL_TYPE_OUTER:
+ ws = GetString ("OUTER"); // Normal/outer volume (hidden volume protected)
+ break;
+ case PROP_VOL_TYPE_OUTER_VOL_WRITE_PREVENTED:
+ ws = GetString ("OUTER_VOL_WRITE_PREVENTED"); // Normal/outer volume (hidden volume protected AND write denied)
+ break;
+ default:
+ ws = L"?";
+ }
+ ListSubItemSetW (hTree, listItem.iItem, 4, ws);
+
+ if (driver.volumeType[i] == PROP_VOL_TYPE_OUTER_VOL_WRITE_PREVENTED) // Normal/outer volume (hidden volume protected AND write denied)
+ {
+ if (!VolumeNotificationsList.bHidVolDamagePrevReported[i])
+ {
+ wchar_t szTmp[4096];
+
+ VolumeNotificationsList.bHidVolDamagePrevReported[i] = TRUE;
+ swprintf (szTmp, GetString ("DAMAGE_TO_HIDDEN_VOLUME_PREVENTED"), i+'A');
+ SetForegroundWindow (GetParent(hTree));
+ MessageBoxW (GetParent(hTree), szTmp, lpszTitle, MB_ICONWARNING | MB_SETFOREGROUND | MB_TOPMOST);
+ }
+ }
+ else
+ {
+ VolumeNotificationsList.bHidVolDamagePrevReported[i] = FALSE;
+ }
+ }
+ }
+ else
+ {
+ VolumeNotificationsList.bHidVolDamagePrevReported[i] = FALSE;
+
+ if (!(dwUsedDrives & 1 << i))
+ {
+ if(drive > 0 && drive != HIWORD (GetSelectedLong (hTree)))
+ {
+ item++;
+ continue;
+ }
+
+ memset(&listItem,0,sizeof(listItem));
+
+ listItem.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
+ listItem.iImage = 0;
+ listItem.iItem = item++;
+ listItem.pszText = szDriveLetters[i];
+ listItem.lParam = MAKELONG (TC_MLIST_ITEM_FREE, i + 'A');
+
+ if(drive == 0)
+ ListView_InsertItem (hTree, &listItem);
+ else
+ ListView_SetItem (hTree, &listItem);
+
+ listItem.mask=LVIF_TEXT;
+ listItem.pszText = "";
+ listItem.iSubItem = 1;
+ ListView_SetItem (hTree, &listItem);
+ listItem.iSubItem = 2;
+ ListView_SetItem (hTree, &listItem);
+ listItem.iSubItem = 3;
+ ListView_SetItem (hTree, &listItem);
+ listItem.iSubItem = 4;
+ ListView_SetItem (hTree, &listItem);
+
+ }
+ }
+ }
+
+ // Restore the original scroll position (the topmost item that was visible when we were called) and the
+ // last selected item.
+ SetListScrollHPos (hTree, lastTopMostVisibleItem);
+ SelectItem (hTree, 0);
+}
+
+static void PasswordChangeEnable (HWND hwndDlg, int button, int passwordId, BOOL keyFilesEnabled,
+ int newPasswordId, int newVerifyId, BOOL newKeyFilesEnabled)
+{
+ char password[MAX_PASSWORD + 1];
+ char newPassword[MAX_PASSWORD + 1];
+ char newVerify[MAX_PASSWORD + 1];
+ BOOL bEnable = TRUE;
+
+ GetWindowText (GetDlgItem (hwndDlg, passwordId), password, sizeof (password));
+
+ if (pwdChangeDlgMode == PCDM_CHANGE_PKCS5_PRF)
+ newKeyFilesEnabled = keyFilesEnabled;
+
+ switch (pwdChangeDlgMode)
+ {
+ case PCDM_REMOVE_ALL_KEYFILES_FROM_VOL:
+ case PCDM_ADD_REMOVE_VOL_KEYFILES:
+ case PCDM_CHANGE_PKCS5_PRF:
+ memcpy (newPassword, password, sizeof (newPassword));
+ memcpy (newVerify, password, sizeof (newVerify));
+ break;
+
+ default:
+ GetWindowText (GetDlgItem (hwndDlg, newPasswordId), newPassword, sizeof (newPassword));
+ GetWindowText (GetDlgItem (hwndDlg, newVerifyId), newVerify, sizeof (newVerify));
+ }
+
+ if (!keyFilesEnabled && strlen (password) < MIN_PASSWORD)
+ bEnable = FALSE;
+ else if (strcmp (newPassword, newVerify) != 0)
+ bEnable = FALSE;
+ else if (!newKeyFilesEnabled && strlen (newPassword) < MIN_PASSWORD)
+ bEnable = FALSE;
+
+ burn (password, sizeof (password));
+ burn (newPassword, sizeof (newPassword));
+ burn (newVerify, sizeof (newVerify));
+
+ EnableWindow (GetDlgItem (hwndDlg, button), bEnable);
+}
+
+
+/* Except in response to the WM_INITDIALOG message, the dialog box procedure
+ should return nonzero if it processes the message, and zero if it does
+ not. - see DialogProc */
+BOOL CALLBACK PasswordChangeDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+ static KeyFilesDlgParam newKeyFilesParam;
+
+ WORD lw = LOWORD (wParam);
+ WORD hw = HIWORD (wParam);
+
+ switch (msg)
+ {
+ case WM_INITDIALOG:
+ {
+ LPARAM nIndex;
+ HWND hComboBox = GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID);
+ int i;
+
+ ZeroMemory (&newKeyFilesParam, sizeof (newKeyFilesParam));
+
+ SetWindowTextW (hwndDlg, GetString ("IDD_PASSWORDCHANGE_DLG"));
+ LocalizeDialog (hwndDlg, "IDD_PASSWORDCHANGE_DLG");
+
+ SendMessage (GetDlgItem (hwndDlg, IDC_OLD_PASSWORD), EM_LIMITTEXT, MAX_PASSWORD, 0);
+ SendMessage (GetDlgItem (hwndDlg, IDC_PASSWORD), EM_LIMITTEXT, MAX_PASSWORD, 0);
+ SendMessage (GetDlgItem (hwndDlg, IDC_VERIFY), EM_LIMITTEXT, MAX_PASSWORD, 0);
+ EnableWindow (GetDlgItem (hwndDlg, IDOK), FALSE);
+
+ SetCheckBox (hwndDlg, IDC_ENABLE_KEYFILES, KeyFilesEnable);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_KEYFILES), TRUE);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_NEW_KEYFILES), TRUE);
+
+ SendMessage (hComboBox, CB_RESETCONTENT, 0, 0);
+
+ nIndex = SendMessageW (hComboBox, CB_ADDSTRING, 0, (LPARAM) GetString ("UNCHANGED"));
+ SendMessage (hComboBox, CB_SETITEMDATA, nIndex, (LPARAM) 0);
+
+ for (i = FIRST_PRF_ID; i <= LAST_PRF_ID; i++)
+ {
+ if (!HashIsDeprecated (i))
+ {
+ nIndex = SendMessage (hComboBox, CB_ADDSTRING, 0, (LPARAM) get_pkcs5_prf_name(i));
+ SendMessage (hComboBox, CB_SETITEMDATA, nIndex, (LPARAM) i);
+ }
+ }
+
+ SendMessage (hComboBox, CB_SETCURSEL, 0, 0);
+
+ switch (pwdChangeDlgMode)
+ {
+ case PCDM_CHANGE_PKCS5_PRF:
+ SetWindowTextW (hwndDlg, GetString ("IDD_PCDM_CHANGE_PKCS5_PRF"));
+ LocalizeDialog (hwndDlg, "IDD_PCDM_CHANGE_PKCS5_PRF");
+ EnableWindow (GetDlgItem (hwndDlg, IDC_PASSWORD), FALSE);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_VERIFY), FALSE);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_ENABLE_NEW_KEYFILES), FALSE);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_SHOW_PASSWORD_CHPWD_NEW), FALSE);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_NEW_KEYFILES), FALSE);
+ EnableWindow (GetDlgItem (hwndDlg, IDT_NEW_PASSWORD), FALSE);
+ EnableWindow (GetDlgItem (hwndDlg, IDT_CONFIRM_PASSWORD), FALSE);
+ break;
+
+ case PCDM_ADD_REMOVE_VOL_KEYFILES:
+ SetWindowTextW (hwndDlg, GetString ("IDD_PCDM_ADD_REMOVE_VOL_KEYFILES"));
+ LocalizeDialog (hwndDlg, "IDD_PCDM_ADD_REMOVE_VOL_KEYFILES");
+ newKeyFilesParam.EnableKeyFiles = TRUE;
+ EnableWindow (GetDlgItem (hwndDlg, IDC_PASSWORD), FALSE);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_VERIFY), FALSE);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_SHOW_PASSWORD_CHPWD_NEW), FALSE);
+ EnableWindow (GetDlgItem (hwndDlg, IDT_NEW_PASSWORD), FALSE);
+ EnableWindow (GetDlgItem (hwndDlg, IDT_CONFIRM_PASSWORD), FALSE);
+ break;
+
+ case PCDM_REMOVE_ALL_KEYFILES_FROM_VOL:
+ newKeyFilesParam.EnableKeyFiles = FALSE;
+ SetWindowTextW (hwndDlg, GetString ("IDD_PCDM_REMOVE_ALL_KEYFILES_FROM_VOL"));
+ LocalizeDialog (hwndDlg, "IDD_PCDM_REMOVE_ALL_KEYFILES_FROM_VOL");
+ KeyFilesEnable = TRUE;
+ SetCheckBox (hwndDlg, IDC_ENABLE_KEYFILES, TRUE);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_KEYFILES), TRUE);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_ENABLE_KEYFILES), TRUE);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_PASSWORD), FALSE);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_VERIFY), FALSE);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_ENABLE_NEW_KEYFILES), FALSE);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_SHOW_PASSWORD_CHPWD_NEW), FALSE);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_NEW_KEYFILES), FALSE);
+ EnableWindow (GetDlgItem (hwndDlg, IDT_NEW_PASSWORD), FALSE);
+ EnableWindow (GetDlgItem (hwndDlg, IDT_CONFIRM_PASSWORD), FALSE);
+ EnableWindow (GetDlgItem (hwndDlg, IDT_PKCS5_PRF), FALSE);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), FALSE);
+ break;
+
+ case PCDM_CHANGE_PASSWORD:
+ default:
+ // NOP
+ break;
+ };
+
+ if (bSysEncPwdChangeDlgMode)
+ {
+ ToBootPwdField (hwndDlg, IDC_PASSWORD);
+ ToBootPwdField (hwndDlg, IDC_VERIFY);
+ ToBootPwdField (hwndDlg, IDC_OLD_PASSWORD);
+
+ if ((DWORD) GetKeyboardLayout (NULL) != 0x00000409 && (DWORD) GetKeyboardLayout (NULL) != 0x04090409)
+ {
+ DWORD keybLayout = (DWORD) LoadKeyboardLayout ("00000409", KLF_ACTIVATE);
+
+ if (keybLayout != 0x00000409 && keybLayout != 0x04090409)
+ {
+ Error ("CANT_CHANGE_KEYB_LAYOUT_FOR_SYS_ENCRYPTION");
+ EndDialog (hwndDlg, IDCANCEL);
+ return 0;
+ }
+
+ bKeyboardLayoutChanged = TRUE;
+ }
+
+ ShowWindow(GetDlgItem(hwndDlg, IDC_SHOW_PASSWORD_CHPWD_NEW), SW_HIDE);
+ ShowWindow(GetDlgItem(hwndDlg, IDC_SHOW_PASSWORD_CHPWD_ORI), SW_HIDE);
+
+ if (SetTimer (hwndDlg, TIMER_ID_KEYB_LAYOUT_GUARD, TIMER_INTERVAL_KEYB_LAYOUT_GUARD, NULL) == 0)
+ {
+ Error ("CANNOT_SET_TIMER");
+ EndDialog (hwndDlg, IDCANCEL);
+ return 0;
+ }
+
+ newKeyFilesParam.EnableKeyFiles = FALSE;
+ KeyFilesEnable = FALSE;
+ SetCheckBox (hwndDlg, IDC_ENABLE_KEYFILES, FALSE);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_ENABLE_KEYFILES), FALSE);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_ENABLE_NEW_KEYFILES), FALSE);
+ }
+
+ CheckCapsLock (hwndDlg, FALSE);
+
+ return 0;
+ }
+
+ case WM_TIMER:
+ switch (wParam)
+ {
+ case TIMER_ID_KEYB_LAYOUT_GUARD:
+ if (bSysEncPwdChangeDlgMode)
+ {
+ DWORD keybLayout = (DWORD) GetKeyboardLayout (NULL);
+
+ /* Watch the keyboard layout */
+
+ if (keybLayout != 0x00000409 && keybLayout != 0x04090409)
+ {
+ // Keyboard layout is not standard US
+
+ // Attempt to wipe passwords stored in the input field buffers
+ char tmp[MAX_PASSWORD+1];
+ memset (tmp, 'X', MAX_PASSWORD);
+ tmp [MAX_PASSWORD] = 0;
+ SetWindowText (GetDlgItem (hwndDlg, IDC_OLD_PASSWORD), tmp);
+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), tmp);
+ SetWindowText (GetDlgItem (hwndDlg, IDC_VERIFY), tmp);
+
+ SetWindowText (GetDlgItem (hwndDlg, IDC_OLD_PASSWORD), "");
+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), "");
+ SetWindowText (GetDlgItem (hwndDlg, IDC_VERIFY), "");
+
+ keybLayout = (DWORD) LoadKeyboardLayout ("00000409", KLF_ACTIVATE);
+
+ if (keybLayout != 0x00000409 && keybLayout != 0x04090409)
+ {
+ KillTimer (hwndDlg, TIMER_ID_KEYB_LAYOUT_GUARD);
+ Error ("CANT_CHANGE_KEYB_LAYOUT_FOR_SYS_ENCRYPTION");
+ EndDialog (hwndDlg, IDCANCEL);
+ return 1;
+ }
+
+ bKeyboardLayoutChanged = TRUE;
+
+ wchar_t szTmp [4096];
+ wcscpy (szTmp, GetString ("KEYB_LAYOUT_CHANGE_PREVENTED"));
+ wcscat (szTmp, L"\n\n");
+ wcscat (szTmp, GetString ("KEYB_LAYOUT_SYS_ENC_EXPLANATION"));
+ MessageBoxW (MainDlg, szTmp, lpszTitle, MB_ICONWARNING | MB_SETFOREGROUND | MB_TOPMOST);
+ }
+
+
+ /* Watch the right Alt key (which is used to enter various characters on non-US keyboards) */
+
+ if (bKeyboardLayoutChanged && !bKeybLayoutAltKeyWarningShown)
+ {
+ if (GetAsyncKeyState (VK_RMENU) < 0)
+ {
+ bKeybLayoutAltKeyWarningShown = TRUE;
+
+ wchar_t szTmp [4096];
+ wcscpy (szTmp, GetString ("ALT_KEY_CHARS_NOT_FOR_SYS_ENCRYPTION"));
+ wcscat (szTmp, L"\n\n");
+ wcscat (szTmp, GetString ("KEYB_LAYOUT_SYS_ENC_EXPLANATION"));
+ MessageBoxW (MainDlg, szTmp, lpszTitle, MB_ICONINFORMATION | MB_SETFOREGROUND | MB_TOPMOST);
+ }
+ }
+ }
+ return 1;
+ }
+ return 0;
+
+ case WM_COMMAND:
+ if (lw == IDCANCEL)
+ {
+ // Attempt to wipe passwords stored in the input field buffers
+ char tmp[MAX_PASSWORD+1];
+ memset (tmp, 'X', MAX_PASSWORD);
+ tmp[MAX_PASSWORD] = 0;
+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), tmp);
+ SetWindowText (GetDlgItem (hwndDlg, IDC_OLD_PASSWORD), tmp);
+ SetWindowText (GetDlgItem (hwndDlg, IDC_VERIFY), tmp);
+ RestoreDefaultKeyFilesParam ();
+
+ EndDialog (hwndDlg, IDCANCEL);
+ return 1;
+ }
+
+ if (hw == EN_CHANGE)
+ {
+ PasswordChangeEnable (hwndDlg, IDOK,
+ IDC_OLD_PASSWORD,
+ KeyFilesEnable && FirstKeyFile != NULL,
+ IDC_PASSWORD, IDC_VERIFY,
+ newKeyFilesParam.EnableKeyFiles && newKeyFilesParam.FirstKeyFile != NULL);
+
+ return 1;
+ }
+
+ if (lw == IDC_KEYFILES)
+ {
+ if (bSysEncPwdChangeDlgMode)
+ {
+ Warning ("KEYFILES_NOT_SUPPORTED_FOR_SYS_ENCRYPTION");
+ return 1;
+ }
+
+ KeyFilesDlgParam param;
+ param.EnableKeyFiles = KeyFilesEnable;
+ param.FirstKeyFile = FirstKeyFile;
+
+ if (IDOK == DialogBoxParamW (hInst,
+ MAKEINTRESOURCEW (IDD_KEYFILES), hwndDlg,
+ (DLGPROC) KeyFilesDlgProc, (LPARAM) &param))
+ {
+ KeyFilesEnable = param.EnableKeyFiles;
+ FirstKeyFile = param.FirstKeyFile;
+
+ SetCheckBox (hwndDlg, IDC_ENABLE_KEYFILES, KeyFilesEnable);
+ }
+
+ PasswordChangeEnable (hwndDlg, IDOK,
+ IDC_OLD_PASSWORD,
+ KeyFilesEnable && FirstKeyFile != NULL,
+ IDC_PASSWORD, IDC_VERIFY,
+ newKeyFilesParam.EnableKeyFiles && newKeyFilesParam.FirstKeyFile != NULL);
+
+ return 1;
+ }
+
+
+ if (lw == IDC_NEW_KEYFILES)
+ {
+ if (bSysEncPwdChangeDlgMode)
+ {
+ Warning ("KEYFILES_NOT_SUPPORTED_FOR_SYS_ENCRYPTION");
+ return 1;
+ }
+
+ if (IDOK == DialogBoxParamW (hInst,
+ MAKEINTRESOURCEW (IDD_KEYFILES), hwndDlg,
+ (DLGPROC) KeyFilesDlgProc, (LPARAM) &newKeyFilesParam))
+ {
+ SetCheckBox (hwndDlg, IDC_ENABLE_NEW_KEYFILES, newKeyFilesParam.EnableKeyFiles);
+
+ VerifyPasswordAndUpdate (hwndDlg, GetDlgItem (hwndDlg, IDOK), GetDlgItem (hwndDlg, IDC_PASSWORD),
+ GetDlgItem (hwndDlg, IDC_VERIFY), NULL, NULL,
+ newKeyFilesParam.EnableKeyFiles && newKeyFilesParam.FirstKeyFile != NULL);
+ }
+
+ PasswordChangeEnable (hwndDlg, IDOK,
+ IDC_OLD_PASSWORD,
+ KeyFilesEnable && FirstKeyFile != NULL,
+ IDC_PASSWORD, IDC_VERIFY,
+ newKeyFilesParam.EnableKeyFiles && newKeyFilesParam.FirstKeyFile != NULL);
+
+ return 1;
+ }
+
+ if (lw == IDC_ENABLE_KEYFILES)
+ {
+ KeyFilesEnable = GetCheckBox (hwndDlg, IDC_ENABLE_KEYFILES);
+
+ PasswordChangeEnable (hwndDlg, IDOK,
+ IDC_OLD_PASSWORD,
+ KeyFilesEnable && FirstKeyFile != NULL,
+ IDC_PASSWORD, IDC_VERIFY,
+ newKeyFilesParam.EnableKeyFiles && newKeyFilesParam.FirstKeyFile != NULL);
+
+ return 1;
+ }
+
+ if (lw == IDC_ENABLE_NEW_KEYFILES)
+ {
+ newKeyFilesParam.EnableKeyFiles = GetCheckBox (hwndDlg, IDC_ENABLE_NEW_KEYFILES);
+
+ PasswordChangeEnable (hwndDlg, IDOK,
+ IDC_OLD_PASSWORD,
+ KeyFilesEnable && FirstKeyFile != NULL,
+ IDC_PASSWORD, IDC_VERIFY,
+ newKeyFilesParam.EnableKeyFiles && newKeyFilesParam.FirstKeyFile != NULL);
+
+ return 1;
+ }
+
+ if (hw == CBN_SELCHANGE)
+ {
+ switch (lw)
+ {
+ case IDC_PKCS5_PRF_ID:
+ if (bSysEncPwdChangeDlgMode)
+ {
+ int new_hash_algo_id = SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETITEMDATA,
+ SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETCURSEL, 0, 0), 0);
+
+ if (new_hash_algo_id != 0 && new_hash_algo_id != DEFAULT_HASH_ALGORITHM_BOOT)
+ {
+ int new_hash_algo_id = DEFAULT_HASH_ALGORITHM_BOOT;
+ Info ("ALGO_NOT_SUPPORTED_FOR_SYS_ENCRYPTION");
+ SelectAlgo (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), &new_hash_algo_id);
+ }
+ }
+ break;
+ }
+ return 1;
+
+ }
+
+ if (lw == IDC_SHOW_PASSWORD_CHPWD_ORI)
+ {
+ SendMessage (GetDlgItem (hwndDlg, IDC_OLD_PASSWORD),
+ EM_SETPASSWORDCHAR,
+ GetCheckBox (hwndDlg, IDC_SHOW_PASSWORD_CHPWD_ORI) ? 0 : '*',
+ 0);
+ InvalidateRect (GetDlgItem (hwndDlg, IDC_OLD_PASSWORD), NULL, TRUE);
+ return 1;
+ }
+
+ if (lw == IDC_SHOW_PASSWORD_CHPWD_NEW)
+ {
+ SendMessage (GetDlgItem (hwndDlg, IDC_PASSWORD),
+ EM_SETPASSWORDCHAR,
+ GetCheckBox (hwndDlg, IDC_SHOW_PASSWORD_CHPWD_NEW) ? 0 : '*',
+ 0);
+ SendMessage (GetDlgItem (hwndDlg, IDC_VERIFY),
+ EM_SETPASSWORDCHAR,
+ GetCheckBox (hwndDlg, IDC_SHOW_PASSWORD_CHPWD_NEW) ? 0 : '*',
+ 0);
+ InvalidateRect (GetDlgItem (hwndDlg, IDC_PASSWORD), NULL, TRUE);
+ InvalidateRect (GetDlgItem (hwndDlg, IDC_VERIFY), NULL, TRUE);
+ return 1;
+ }
+
+ if (lw == IDOK)
+ {
+ HWND hParent = GetParent (hwndDlg);
+ Password oldPassword;
+ Password newPassword;
+ int nStatus;
+ int pkcs5 = SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETITEMDATA,
+ SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETCURSEL, 0, 0), 0);
+
+ if (!CheckPasswordCharEncoding (GetDlgItem (hwndDlg, IDC_PASSWORD), NULL))
+ {
+ Error ("UNSUPPORTED_CHARS_IN_PWD");
+ return 1;
+ }
+
+ if (pwdChangeDlgMode == PCDM_CHANGE_PKCS5_PRF)
+ {
+ newKeyFilesParam.EnableKeyFiles = KeyFilesEnable;
+ }
+ else if (!(newKeyFilesParam.EnableKeyFiles && newKeyFilesParam.FirstKeyFile != NULL)
+ && pwdChangeDlgMode == PCDM_CHANGE_PASSWORD)
+ {
+ if (!CheckPasswordLength (hwndDlg, GetDlgItem (hwndDlg, IDC_PASSWORD)))
+ return 1;
+ }
+
+ GetWindowText (GetDlgItem (hParent, IDC_VOLUME), szFileName, sizeof (szFileName));
+
+ GetWindowText (GetDlgItem (hwndDlg, IDC_OLD_PASSWORD), (LPSTR) oldPassword.Text, sizeof (oldPassword.Text));
+ oldPassword.Length = strlen ((char *) oldPassword.Text);
+
+ switch (pwdChangeDlgMode)
+ {
+ case PCDM_REMOVE_ALL_KEYFILES_FROM_VOL:
+ case PCDM_ADD_REMOVE_VOL_KEYFILES:
+ case PCDM_CHANGE_PKCS5_PRF:
+ memcpy (newPassword.Text, oldPassword.Text, sizeof (newPassword.Text));
+ newPassword.Length = strlen ((char *) oldPassword.Text);
+ break;
+
+ default:
+ GetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), (LPSTR) newPassword.Text, sizeof (newPassword.Text));
+ newPassword.Length = strlen ((char *) newPassword.Text);
+ }
+
+ WaitCursor ();
+
+ if (KeyFilesEnable)
+ KeyFilesApply (&oldPassword, FirstKeyFile);
+
+ if (newKeyFilesParam.EnableKeyFiles)
+ {
+ if (!KeyFilesApply (&newPassword, pwdChangeDlgMode == PCDM_CHANGE_PKCS5_PRF ? FirstKeyFile : newKeyFilesParam.FirstKeyFile))
+ {
+ nStatus = ERR_DONT_REPORT;
+ goto err;
+ }
+ }
+
+ if (bSysEncPwdChangeDlgMode)
+ {
+ // System
+
+ pkcs5 = 0; // PKCS-5 PRF unchanged (currently system encryption supports only RIPEMD-160)
+
+ try
+ {
+ nStatus = BootEncObj->ChangePassword (&oldPassword, &newPassword, pkcs5);
+ }
+ catch (Exception &e)
+ {
+ e.Show (MainDlg);
+ nStatus = ERR_OS_ERROR;
+ }
+ }
+ else
+ {
+ // Non-system
+
+ nStatus = ChangePwd (szFileName, &oldPassword, &newPassword, pkcs5, hwndDlg);
+
+ if (nStatus == ERR_OS_ERROR
+ && GetLastError () == ERROR_ACCESS_DENIED
+ && IsUacSupported ()
+ && IsVolumeDeviceHosted (szFileName))
+ {
+ nStatus = UacChangePwd (szFileName, &oldPassword, &newPassword, pkcs5, hwndDlg);
+ }
+ }
+
+err:
+ burn (&oldPassword, sizeof (oldPassword));
+ burn (&newPassword, sizeof (newPassword));
+
+ NormalCursor ();
+
+ if (nStatus == 0)
+ {
+ // Attempt to wipe passwords stored in the input field buffers
+ char tmp[MAX_PASSWORD+1];
+ memset (tmp, 'X', MAX_PASSWORD);
+ tmp[MAX_PASSWORD] = 0;
+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), tmp);
+ SetWindowText (GetDlgItem (hwndDlg, IDC_OLD_PASSWORD), tmp);
+ SetWindowText (GetDlgItem (hwndDlg, IDC_VERIFY), tmp);
+
+ KeyFileRemoveAll (&newKeyFilesParam.FirstKeyFile);
+ RestoreDefaultKeyFilesParam ();
+
+ if (bSysEncPwdChangeDlgMode)
+ {
+ KillTimer (hwndDlg, TIMER_ID_KEYB_LAYOUT_GUARD);
+ }
+
+ EndDialog (hwndDlg, IDOK);
+ }
+ return 1;
+ }
+ return 0;
+ }
+
+ return 0;
+}
+
+static char PasswordDlgVolume[MAX_PATH];
+static BOOL PasswordDialogDisableMountOptions;
+static char *PasswordDialogTitleStringId;
+
+/* Except in response to the WM_INITDIALOG message, the dialog box procedure
+ should return nonzero if it processes the message, and zero if it does
+ not. - see DialogProc */
+BOOL CALLBACK PasswordDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+ WORD lw = LOWORD (wParam);
+ static Password *szXPwd;
+
+ switch (msg)
+ {
+ case WM_INITDIALOG:
+ {
+ szXPwd = (Password *) lParam;
+ LocalizeDialog (hwndDlg, "IDD_PASSWORD_DLG");
+ DragAcceptFiles (hwndDlg, TRUE);
+
+ if (PasswordDialogTitleStringId)
+ {
+ SetWindowTextW (hwndDlg, GetString (PasswordDialogTitleStringId));
+ }
+ else if (strlen (PasswordDlgVolume) > 0)
+ {
+ wchar_t s[1024];
+ RECT rect;
+ GetWindowRect (hwndDlg, &rect);
+
+ wstring label = GetFavoriteVolumeLabel (PasswordDlgVolume);
+ if (!label.empty())
+ {
+ wsprintfW (s, GetString ("ENTER_PASSWORD_FOR_LABEL"), label.c_str());
+ }
+ else
+ {
+ wsprintfW (s, GetString ("ENTER_PASSWORD_FOR"), "___");
+ wsprintfW (s, GetString ("ENTER_PASSWORD_FOR"), FitPathInGfxWidth (hwndDlg, WindowTitleBarFont, rect.right - rect.left - GetTextGfxWidth (hwndDlg, s, WindowTitleBarFont), PasswordDlgVolume).c_str());
+ }
+
+ SetWindowTextW (hwndDlg, s);
+ }
+
+ SendMessage (GetDlgItem (hwndDlg, IDC_PASSWORD), EM_LIMITTEXT, MAX_PASSWORD, 0);
+ SendMessage (GetDlgItem (hwndDlg, IDC_CACHE), BM_SETCHECK, bCacheInDriver ? BST_CHECKED:BST_UNCHECKED, 0);
+
+ SetCheckBox (hwndDlg, IDC_KEYFILES_ENABLE, KeyFilesEnable);
+
+ mountOptions.PartitionInInactiveSysEncScope = bPrebootPasswordDlgMode;
+
+ if (bPrebootPasswordDlgMode)
+ {
+ SendMessage (hwndDlg, TC_APPMSG_PREBOOT_PASSWORD_MODE, 0, 0);
+ }
+
+ if (PasswordDialogDisableMountOptions)
+ {
+ EnableWindow (GetDlgItem (hwndDlg, IDC_CACHE), FALSE);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_MOUNT_OPTIONS), FALSE);
+ }
+
+ if (!SetForegroundWindow (hwndDlg) && (FavoriteMountOnArrivalInProgress || LogOn))
+ {
+ SetWindowPos (hwndDlg, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
+
+ FLASHWINFO flash;
+ flash.cbSize = sizeof (flash);
+ flash.dwFlags = FLASHW_ALL | FLASHW_TIMERNOFG;
+ flash.dwTimeout = 0;
+ flash.hwnd = hwndDlg;
+ flash.uCount = 0;
+
+ FlashWindowEx (&flash);
+
+ SetWindowPos (hwndDlg, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
+ }
+ }
+ return 0;
+
+ case TC_APPMSG_PREBOOT_PASSWORD_MODE:
+ {
+ ToBootPwdField (hwndDlg, IDC_PASSWORD);
+
+ // Attempt to wipe the password stored in the input field buffer
+ char tmp[MAX_PASSWORD+1];
+ memset (tmp, 'X', MAX_PASSWORD);
+ tmp [MAX_PASSWORD] = 0;
+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), tmp);
+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), "");
+
+ sprintf (OrigKeyboardLayout, "%08X", (DWORD) GetKeyboardLayout (NULL) & 0xFFFF);
+
+ DWORD keybLayout = (DWORD) LoadKeyboardLayout ("00000409", KLF_ACTIVATE);
+
+ if (keybLayout != 0x00000409 && keybLayout != 0x04090409)
+ {
+ Error ("CANT_CHANGE_KEYB_LAYOUT_FOR_SYS_ENCRYPTION");
+ EndDialog (hwndDlg, IDCANCEL);
+ return 1;
+ }
+
+ if (SetTimer (hwndDlg, TIMER_ID_KEYB_LAYOUT_GUARD, TIMER_INTERVAL_KEYB_LAYOUT_GUARD, NULL) == 0)
+ {
+ Error ("CANNOT_SET_TIMER");
+ EndDialog (hwndDlg, IDCANCEL);
+ return 1;
+ }
+
+ SetCheckBox (hwndDlg, IDC_SHOW_PASSWORD, FALSE);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_SHOW_PASSWORD), FALSE);
+
+ SendMessage (GetDlgItem (hwndDlg, IDC_PASSWORD), EM_SETPASSWORDCHAR, '*', 0);
+ InvalidateRect (GetDlgItem (hwndDlg, IDC_PASSWORD), NULL, TRUE);
+
+ bPrebootPasswordDlgMode = TRUE;
+ }
+ return 1;
+
+ case WM_TIMER:
+ switch (wParam)
+ {
+ case TIMER_ID_KEYB_LAYOUT_GUARD:
+ if (bPrebootPasswordDlgMode)
+ {
+ DWORD keybLayout = (DWORD) GetKeyboardLayout (NULL);
+
+ if (keybLayout != 0x00000409 && keybLayout != 0x04090409)
+ {
+ // Keyboard layout is not standard US
+
+ // Attempt to wipe the password stored in the input field buffer
+ char tmp[MAX_PASSWORD+1];
+ memset (tmp, 'X', MAX_PASSWORD);
+ tmp [MAX_PASSWORD] = 0;
+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), tmp);
+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), "");
+
+ keybLayout = (DWORD) LoadKeyboardLayout ("00000409", KLF_ACTIVATE);
+
+ if (keybLayout != 0x00000409 && keybLayout != 0x04090409)
+ {
+ KillTimer (hwndDlg, TIMER_ID_KEYB_LAYOUT_GUARD);
+ Error ("CANT_CHANGE_KEYB_LAYOUT_FOR_SYS_ENCRYPTION");
+ EndDialog (hwndDlg, IDCANCEL);
+ return 1;
+ }
+
+ wchar_t szTmp [4096];
+ wcscpy (szTmp, GetString ("KEYB_LAYOUT_CHANGE_PREVENTED"));
+ wcscat (szTmp, L"\n\n");
+ wcscat (szTmp, GetString ("KEYB_LAYOUT_SYS_ENC_EXPLANATION"));
+ MessageBoxW (MainDlg, szTmp, lpszTitle, MB_ICONWARNING | MB_SETFOREGROUND | MB_TOPMOST);
+ }
+ }
+ return 1;
+ }
+ return 0;
+
+ case WM_COMMAND:
+
+ if (lw == IDC_MOUNT_OPTIONS)
+ {
+ DialogBoxParamW (hInst,
+ MAKEINTRESOURCEW (IDD_MOUNT_OPTIONS), hwndDlg,
+ (DLGPROC) MountOptionsDlgProc, (LPARAM) &mountOptions);
+
+ if (!bPrebootPasswordDlgMode && mountOptions.PartitionInInactiveSysEncScope)
+ SendMessage (hwndDlg, TC_APPMSG_PREBOOT_PASSWORD_MODE, 0, 0);
+
+ return 1;
+ }
+
+ if (lw == IDC_SHOW_PASSWORD)
+ {
+ SendMessage (GetDlgItem (hwndDlg, IDC_PASSWORD),
+ EM_SETPASSWORDCHAR,
+ GetCheckBox (hwndDlg, IDC_SHOW_PASSWORD) ? 0 : '*',
+ 0);
+ InvalidateRect (GetDlgItem (hwndDlg, IDC_PASSWORD), NULL, TRUE);
+ return 1;
+ }
+
+ if (lw == IDC_KEY_FILES)
+ {
+ KeyFilesDlgParam param;
+ param.EnableKeyFiles = KeyFilesEnable;
+ param.FirstKeyFile = FirstKeyFile;
+
+ if (IDOK == DialogBoxParamW (hInst,
+ MAKEINTRESOURCEW (IDD_KEYFILES), hwndDlg,
+ (DLGPROC) KeyFilesDlgProc, (LPARAM) &param))
+ {
+ KeyFilesEnable = param.EnableKeyFiles;
+ FirstKeyFile = param.FirstKeyFile;
+
+ SetCheckBox (hwndDlg, IDC_KEYFILES_ENABLE, KeyFilesEnable);
+ }
+
+ return 1;
+ }
+
+ if (lw == IDC_KEYFILES_ENABLE)
+ {
+ KeyFilesEnable = GetCheckBox (hwndDlg, IDC_KEYFILES_ENABLE);
+
+ return 1;
+ }
+
+ if (lw == IDCANCEL || lw == IDOK)
+ {
+ char tmp[MAX_PASSWORD+1];
+
+ if (lw == IDOK)
+ {
+ if (mountOptions.ProtectHiddenVolume && hidVolProtKeyFilesParam.EnableKeyFiles)
+ KeyFilesApply (&mountOptions.ProtectedHidVolPassword, hidVolProtKeyFilesParam.FirstKeyFile);
+
+ GetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), (LPSTR) szXPwd->Text, MAX_PASSWORD + 1);
+ szXPwd->Length = strlen ((char *) szXPwd->Text);
+
+ bCacheInDriver = IsButtonChecked (GetDlgItem (hwndDlg, IDC_CACHE));
+ }
+
+ // Attempt to wipe password stored in the input field buffer
+ memset (tmp, 'X', MAX_PASSWORD);
+ tmp[MAX_PASSWORD] = 0;
+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), tmp);
+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD_PROT_HIDVOL), tmp);
+
+ if (hidVolProtKeyFilesParam.FirstKeyFile != NULL)
+ {
+ KeyFileRemoveAll (&hidVolProtKeyFilesParam.FirstKeyFile);
+ hidVolProtKeyFilesParam.EnableKeyFiles = FALSE;
+ }
+
+ if (bPrebootPasswordDlgMode)
+ {
+ KillTimer (hwndDlg, TIMER_ID_KEYB_LAYOUT_GUARD);
+
+ // Restore the original keyboard layout
+ if (LoadKeyboardLayout (OrigKeyboardLayout, KLF_ACTIVATE | KLF_SUBSTITUTE_OK) == NULL)
+ Warning ("CANNOT_RESTORE_KEYBOARD_LAYOUT");
+ }
+
+ EndDialog (hwndDlg, lw);
+ return 1;
+ }
+ return 0;
+
+ case WM_CONTEXTMENU:
+ {
+ RECT buttonRect;
+ GetWindowRect (GetDlgItem (hwndDlg, IDC_KEY_FILES), &buttonRect);
+
+ if (LOWORD (lParam) >= buttonRect.left && LOWORD (lParam) <= buttonRect.right
+ && HIWORD (lParam) >= buttonRect.top && HIWORD (lParam) <= buttonRect.bottom)
+ {
+ // The "Keyfiles" button has been right-clicked
+
+ KeyFilesDlgParam param;
+ param.EnableKeyFiles = KeyFilesEnable;
+ param.FirstKeyFile = FirstKeyFile;
+
+ POINT popupPos;
+ popupPos.x = buttonRect.left + 2;
+ popupPos.y = buttonRect.top + 2;
+
+ if (KeyfilesPopupMenu (hwndDlg, popupPos, &param))
+ {
+ KeyFilesEnable = param.EnableKeyFiles;
+ FirstKeyFile = param.FirstKeyFile;
+ SetCheckBox (hwndDlg, IDC_KEYFILES_ENABLE, KeyFilesEnable);
+ }
+ }
+ }
+ break;
+
+ case WM_DROPFILES:
+ {
+ HDROP hdrop = (HDROP) wParam;
+ int i = 0, count = DragQueryFile (hdrop, 0xFFFFFFFF, NULL, 0);
+
+ while (count-- > 0)
+ {
+ KeyFile *kf = (KeyFile *) malloc (sizeof (KeyFile));
+ DragQueryFile (hdrop, i++, kf->FileName, sizeof (kf->FileName));
+ FirstKeyFile = KeyFileAdd (FirstKeyFile, kf);
+ KeyFilesEnable = TRUE;
+ }
+
+ SetCheckBox (hwndDlg, IDC_KEYFILES_ENABLE, KeyFilesEnable);
+ DragFinish (hdrop);
+ }
+ return 1;
+ }
+
+ return 0;
+}
+
+static void PreferencesDlgEnableButtons (HWND hwndDlg)
+{
+ BOOL back = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_BKG_TASK_ENABLE));
+ BOOL idle = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_INACTIVE));
+ BOOL installed = !IsNonInstallMode();
+
+ EnableWindow (GetDlgItem (hwndDlg, IDC_CLOSE_BKG_TASK_WHEN_NOVOL), back && installed);
+ EnableWindow (GetDlgItem (hwndDlg, IDT_LOGON), installed);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_PREF_LOGON_START), back && installed);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_PREF_LOGON_MOUNT_DEVICES), installed);
+ EnableWindow (GetDlgItem (hwndDlg, IDT_AUTO_DISMOUNT), back);
+ EnableWindow (GetDlgItem (hwndDlg, IDT_AUTO_DISMOUNT_ON), back);
+ EnableWindow (GetDlgItem (hwndDlg, IDT_MINUTES), back);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_LOGOFF), back);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_POWERSAVING), back);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_SCREENSAVER), back);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_INACTIVE), back);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_INACTIVE_TIME), back && idle);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_PREF_FORCE_AUTO_DISMOUNT), back);
+}
+
+BOOL CALLBACK PreferencesDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+ static BOOL PreferencesDialogActive = FALSE;
+ static HWND ActivePreferencesDialogWindow;
+
+ WORD lw = LOWORD (wParam);
+
+ switch (msg)
+ {
+ case WM_INITDIALOG:
+ {
+ if (PreferencesDialogActive)
+ {
+ ShowWindow (ActivePreferencesDialogWindow, SW_SHOW);
+ SetForegroundWindow (ActivePreferencesDialogWindow);
+ EndDialog (hwndDlg, IDCANCEL);
+ return 1;
+ }
+
+ ActivePreferencesDialogWindow = hwndDlg;
+ PreferencesDialogActive = TRUE;
+
+ LocalizeDialog (hwndDlg, "IDD_PREFERENCES_DLG");
+
+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_OPEN_EXPLORER), BM_SETCHECK,
+ bExplore ? BST_CHECKED:BST_UNCHECKED, 0);
+
+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_USE_DIFF_TRAY_ICON_IF_VOL_MOUNTED), BM_SETCHECK,
+ bUseDifferentTrayIconIfVolMounted ? BST_CHECKED:BST_UNCHECKED, 0);
+
+ SendMessage (GetDlgItem (hwndDlg, IDC_PRESERVE_TIMESTAMPS), BM_SETCHECK,
+ defaultMountOptions.PreserveTimestamp ? BST_CHECKED:BST_UNCHECKED, 0);
+
+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_WIPE_CACHE_ON_EXIT), BM_SETCHECK,
+ bWipeCacheOnExit ? BST_CHECKED:BST_UNCHECKED, 0);
+
+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_WIPE_CACHE_ON_AUTODISMOUNT), BM_SETCHECK,
+ bWipeCacheOnAutoDismount ? BST_CHECKED:BST_UNCHECKED, 0);
+
+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_CACHE_PASSWORDS), BM_SETCHECK,
+ bCacheInDriver ? BST_CHECKED:BST_UNCHECKED, 0);
+
+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_MOUNT_READONLY), BM_SETCHECK,
+ defaultMountOptions.ReadOnly ? BST_CHECKED:BST_UNCHECKED, 0);
+
+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_MOUNT_REMOVABLE), BM_SETCHECK,
+ defaultMountOptions.Removable ? BST_CHECKED:BST_UNCHECKED, 0);
+
+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_LOGON_START), BM_SETCHECK,
+ bStartOnLogon ? BST_CHECKED:BST_UNCHECKED, 0);
+
+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_LOGON_MOUNT_DEVICES), BM_SETCHECK,
+ bMountDevicesOnLogon ? BST_CHECKED:BST_UNCHECKED, 0);
+
+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_BKG_TASK_ENABLE), BM_SETCHECK,
+ bEnableBkgTask ? BST_CHECKED:BST_UNCHECKED, 0);
+
+ SendMessage (GetDlgItem (hwndDlg, IDC_CLOSE_BKG_TASK_WHEN_NOVOL), BM_SETCHECK,
+ bCloseBkgTaskWhenNoVolumes || IsNonInstallMode() ? BST_CHECKED:BST_UNCHECKED, 0);
+
+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_LOGOFF), BM_SETCHECK,
+ bDismountOnLogOff ? BST_CHECKED:BST_UNCHECKED, 0);
+
+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_POWERSAVING), BM_SETCHECK,
+ bDismountOnPowerSaving ? BST_CHECKED:BST_UNCHECKED, 0);
+
+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_SCREENSAVER), BM_SETCHECK,
+ bDismountOnScreenSaver ? BST_CHECKED:BST_UNCHECKED, 0);
+
+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_FORCE_AUTO_DISMOUNT), BM_SETCHECK,
+ bForceAutoDismount ? BST_CHECKED:BST_UNCHECKED, 0);
+
+ SendMessage (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_INACTIVE), BM_SETCHECK,
+ MaxVolumeIdleTime > 0 ? BST_CHECKED:BST_UNCHECKED, 0);
+
+ SetDlgItemInt (hwndDlg, IDC_PREF_DISMOUNT_INACTIVE_TIME, abs (MaxVolumeIdleTime), FALSE);
+
+ PreferencesDlgEnableButtons (hwndDlg);
+ }
+ return 0;
+
+ case WM_COMMAND:
+
+ if (lw == IDC_PREF_BKG_TASK_ENABLE && !IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_BKG_TASK_ENABLE)))
+ {
+ if (AskWarnNoYes ("CONFIRM_BACKGROUND_TASK_DISABLED") == IDNO)
+ SetCheckBox (hwndDlg, IDC_PREF_BKG_TASK_ENABLE, TRUE);
+ }
+
+ // Forced dismount disabled warning
+ if (lw == IDC_PREF_DISMOUNT_INACTIVE
+ || lw == IDC_PREF_DISMOUNT_LOGOFF
+ || lw == IDC_PREF_DISMOUNT_POWERSAVING
+ || lw == IDC_PREF_DISMOUNT_SCREENSAVER
+ || lw == IDC_PREF_FORCE_AUTO_DISMOUNT)
+ {
+ BOOL i = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_INACTIVE));
+ BOOL l = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_LOGOFF));
+ BOOL p = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_POWERSAVING));
+ BOOL s = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_SCREENSAVER));
+ BOOL q = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_FORCE_AUTO_DISMOUNT));
+
+ if (!q)
+ {
+ if (lw == IDC_PREF_FORCE_AUTO_DISMOUNT && (i || l || p || s))
+ {
+ if (AskWarnNoYes ("CONFIRM_NO_FORCED_AUTODISMOUNT") == IDNO)
+ SetCheckBox (hwndDlg, IDC_PREF_FORCE_AUTO_DISMOUNT, TRUE);
+ }
+ else if ((lw == IDC_PREF_DISMOUNT_INACTIVE && i
+ || lw == IDC_PREF_DISMOUNT_LOGOFF && l
+ || lw == IDC_PREF_DISMOUNT_POWERSAVING && p
+ || lw == IDC_PREF_DISMOUNT_SCREENSAVER && s))
+ Warning ("WARN_PREF_AUTO_DISMOUNT");
+ }
+
+ if (p && lw == IDC_PREF_DISMOUNT_POWERSAVING)
+ Warning ("WARN_PREF_AUTO_DISMOUNT_ON_POWER");
+ }
+
+ if (lw == IDCANCEL)
+ {
+ PreferencesDialogActive = FALSE;
+ EndDialog (hwndDlg, lw);
+ return 1;
+ }
+
+ if (lw == IDOK)
+ {
+ WaitCursor ();
+
+ bExplore = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_OPEN_EXPLORER));
+ bUseDifferentTrayIconIfVolMounted = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_USE_DIFF_TRAY_ICON_IF_VOL_MOUNTED));
+ bPreserveTimestamp = defaultMountOptions.PreserveTimestamp = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PRESERVE_TIMESTAMPS));
+ bWipeCacheOnExit = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_WIPE_CACHE_ON_EXIT));
+ bWipeCacheOnAutoDismount = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_WIPE_CACHE_ON_AUTODISMOUNT));
+ bCacheInDriverDefault = bCacheInDriver = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_CACHE_PASSWORDS));
+ defaultMountOptions.ReadOnly = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_MOUNT_READONLY));
+ defaultMountOptions.Removable = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_MOUNT_REMOVABLE));
+ bEnableBkgTask = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_BKG_TASK_ENABLE));
+ bCloseBkgTaskWhenNoVolumes = IsNonInstallMode() ? bCloseBkgTaskWhenNoVolumes : IsButtonChecked (GetDlgItem (hwndDlg, IDC_CLOSE_BKG_TASK_WHEN_NOVOL));
+ bDismountOnLogOff = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_LOGOFF));
+ bDismountOnPowerSaving = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_POWERSAVING));
+ bDismountOnScreenSaver = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_SCREENSAVER));
+ bForceAutoDismount = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_FORCE_AUTO_DISMOUNT));
+ MaxVolumeIdleTime = GetDlgItemInt (hwndDlg, IDC_PREF_DISMOUNT_INACTIVE_TIME, NULL, FALSE)
+ * (IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_INACTIVE)) ? 1 : -1);
+ bStartOnLogon = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_LOGON_START));
+ bMountDevicesOnLogon = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_LOGON_MOUNT_DEVICES));
+
+ ManageStartupSeq ();
+
+ SaveSettings (hwndDlg);
+
+ NormalCursor ();
+
+ PreferencesDialogActive = FALSE;
+ EndDialog (hwndDlg, lw);
+ return 1;
+ }
+
+ if (lw == IDC_MORE_SETTINGS)
+ {
+ HMENU popup = CreatePopupMenu ();
+
+ AppendMenuW (popup, MF_STRING, IDM_LANGUAGE, GetString ("IDM_LANGUAGE"));
+ AppendMenuW (popup, MF_STRING, IDM_HOTKEY_SETTINGS, GetString ("IDM_HOTKEY_SETTINGS"));
+ AppendMenuW (popup, MF_STRING, IDM_PERFORMANCE_SETTINGS, GetString ("IDM_PERFORMANCE_SETTINGS"));
+ AppendMenuW (popup, MF_STRING, IDM_SYSENC_SETTINGS, GetString ("IDM_SYSENC_SETTINGS"));
+ AppendMenuW (popup, MF_STRING, IDM_SYS_FAVORITES_SETTINGS, GetString ("IDM_SYS_FAVORITES_SETTINGS"));
+ AppendMenuW (popup, MF_STRING, IDM_DEFAULT_KEYFILES, GetString ("IDM_DEFAULT_KEYFILES"));
+ AppendMenuW (popup, MF_STRING, IDM_TOKEN_PREFERENCES, GetString ("IDM_TOKEN_PREFERENCES"));
+
+ RECT rect;
+ GetWindowRect (GetDlgItem (hwndDlg, IDC_MORE_SETTINGS), &rect);
+
+ int menuItem = TrackPopupMenu (popup, TPM_RETURNCMD | TPM_LEFTBUTTON, rect.left + 2, rect.top + 2, 0, hwndDlg, NULL);
+ DestroyMenu (popup);
+
+ SendMessage (MainDlg, WM_COMMAND, menuItem, NULL);
+ return 1;
+ }
+
+ if (HIWORD (wParam) == BN_CLICKED)
+ {
+ PreferencesDlgEnableButtons (hwndDlg);
+ return 1;
+ }
+
+ return 0;
+ }
+
+ return 0;
+}
+
+
+BOOL CALLBACK MountOptionsDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+ static MountOptions *mountOptions;
+
+ WORD lw = LOWORD (wParam);
+
+ switch (msg)
+ {
+ case WM_INITDIALOG:
+ {
+ BOOL protect;
+
+ mountOptions = (MountOptions *) lParam;
+
+ LocalizeDialog (hwndDlg, "IDD_MOUNT_OPTIONS");
+
+ SendDlgItemMessage (hwndDlg, IDC_MOUNT_READONLY, BM_SETCHECK,
+ mountOptions->ReadOnly ? BST_CHECKED : BST_UNCHECKED, 0);
+ SendDlgItemMessage (hwndDlg, IDC_MOUNT_REMOVABLE, BM_SETCHECK,
+ mountOptions->Removable ? BST_CHECKED : BST_UNCHECKED, 0);
+ SendDlgItemMessage (hwndDlg, IDC_PROTECT_HIDDEN_VOL, BM_SETCHECK,
+ mountOptions->ProtectHiddenVolume ? BST_CHECKED : BST_UNCHECKED, 0);
+
+ SendDlgItemMessage (hwndDlg, IDC_PROTECT_HIDDEN_VOL, BM_SETCHECK,
+ mountOptions->ProtectHiddenVolume ? BST_CHECKED : BST_UNCHECKED, 0);
+
+ mountOptions->PartitionInInactiveSysEncScope = bPrebootPasswordDlgMode;
+
+ SendDlgItemMessage (hwndDlg, IDC_MOUNT_SYSENC_PART_WITHOUT_PBA, BM_SETCHECK,
+ bPrebootPasswordDlgMode ? BST_CHECKED : BST_UNCHECKED, 0);
+
+ SendDlgItemMessage (hwndDlg, IDC_USE_EMBEDDED_HEADER_BAK, BM_SETCHECK,
+ mountOptions->UseBackupHeader ? BST_CHECKED : BST_UNCHECKED, 0);
+
+ EnableWindow (GetDlgItem (hwndDlg, IDC_MOUNT_SYSENC_PART_WITHOUT_PBA), !bPrebootPasswordDlgMode);
+
+ protect = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PROTECT_HIDDEN_VOL));
+
+ EnableWindow (GetDlgItem (hwndDlg, IDC_PROTECT_HIDDEN_VOL), !IsButtonChecked (GetDlgItem (hwndDlg, IDC_MOUNT_READONLY)));
+ EnableWindow (GetDlgItem (hwndDlg, IDT_HIDDEN_VOL_PROTECTION), !IsButtonChecked (GetDlgItem (hwndDlg, IDC_MOUNT_READONLY)));
+ EnableWindow (GetDlgItem (hwndDlg, IDC_PASSWORD_PROT_HIDVOL), protect);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_SHOW_PASSWORD_MO), protect);
+ EnableWindow (GetDlgItem (hwndDlg, IDT_HIDDEN_PROT_PASSWD), protect);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_KEYFILES_HIDVOL_PROT), protect);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_KEYFILES_ENABLE_HIDVOL_PROT), protect);
+
+ SetCheckBox (hwndDlg, IDC_KEYFILES_ENABLE_HIDVOL_PROT, hidVolProtKeyFilesParam.EnableKeyFiles);
+
+ SendDlgItemMessage (hwndDlg, IDC_PASSWORD_PROT_HIDVOL, EM_LIMITTEXT, MAX_PASSWORD, 0);
+
+ if (mountOptions->ProtectedHidVolPassword.Length > 0)
+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD_PROT_HIDVOL), (LPSTR) mountOptions->ProtectedHidVolPassword.Text);
+
+ ToHyperlink (hwndDlg, IDC_LINK_HIDVOL_PROTECTION_INFO);
+
+ }
+ return 0;
+
+ case WM_CONTEXTMENU:
+ {
+ RECT buttonRect;
+ GetWindowRect (GetDlgItem (hwndDlg, IDC_KEYFILES_HIDVOL_PROT), &buttonRect);
+
+ if (IsButtonChecked (GetDlgItem (hwndDlg, IDC_PROTECT_HIDDEN_VOL))
+ && LOWORD (lParam) >= buttonRect.left && LOWORD (lParam) <= buttonRect.right
+ && HIWORD (lParam) >= buttonRect.top && HIWORD (lParam) <= buttonRect.bottom)
+ {
+ // The "Keyfiles" button has been right-clicked
+
+ POINT popupPos;
+ popupPos.x = buttonRect.left + 2;
+ popupPos.y = buttonRect.top + 2;
+
+ if (KeyfilesPopupMenu (hwndDlg, popupPos, &hidVolProtKeyFilesParam))
+ SetCheckBox (hwndDlg, IDC_KEYFILES_ENABLE_HIDVOL_PROT, hidVolProtKeyFilesParam.EnableKeyFiles);
+ }
+ }
+ break;
+
+ case WM_COMMAND:
+
+ if (lw == IDC_KEYFILES_HIDVOL_PROT)
+ {
+ if (IDOK == DialogBoxParamW (hInst,
+ MAKEINTRESOURCEW (IDD_KEYFILES), hwndDlg,
+ (DLGPROC) KeyFilesDlgProc, (LPARAM) &hidVolProtKeyFilesParam))
+ {
+ SetCheckBox (hwndDlg, IDC_KEYFILES_ENABLE_HIDVOL_PROT, hidVolProtKeyFilesParam.EnableKeyFiles);
+ }
+ }
+
+ if (lw == IDC_KEYFILES_ENABLE_HIDVOL_PROT)
+ {
+ hidVolProtKeyFilesParam.EnableKeyFiles = GetCheckBox (hwndDlg, IDC_KEYFILES_ENABLE_HIDVOL_PROT);
+
+ return 0;
+ }
+
+ if (lw == IDC_SHOW_PASSWORD_MO)
+ {
+ SendMessage (GetDlgItem (hwndDlg, IDC_PASSWORD_PROT_HIDVOL),
+ EM_SETPASSWORDCHAR,
+ GetCheckBox (hwndDlg, IDC_SHOW_PASSWORD_MO) ? 0 : '*',
+ 0);
+ InvalidateRect (GetDlgItem (hwndDlg, IDC_PASSWORD_PROT_HIDVOL), NULL, TRUE);
+ return 1;
+ }
+
+ if (lw == IDC_LINK_HIDVOL_PROTECTION_INFO)
+ {
+ Applink ("hiddenvolprotection", TRUE, "");
+ }
+
+ if (lw == IDCANCEL)
+ {
+ char tmp[MAX_PASSWORD+1];
+
+ // Cleanup
+ memset (tmp, 'X', MAX_PASSWORD);
+ tmp[MAX_PASSWORD] = 0;
+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD_PROT_HIDVOL), tmp);
+
+ EndDialog (hwndDlg, lw);
+ return 1;
+ }
+
+ if (lw == IDOK)
+ {
+ char tmp[MAX_PASSWORD+1];
+
+ mountOptions->ReadOnly = IsButtonChecked (GetDlgItem (hwndDlg, IDC_MOUNT_READONLY));
+ mountOptions->Removable = IsButtonChecked (GetDlgItem (hwndDlg, IDC_MOUNT_REMOVABLE));
+ mountOptions->ProtectHiddenVolume = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PROTECT_HIDDEN_VOL));
+ mountOptions->PartitionInInactiveSysEncScope = IsButtonChecked (GetDlgItem (hwndDlg, IDC_MOUNT_SYSENC_PART_WITHOUT_PBA));
+ mountOptions->UseBackupHeader = IsButtonChecked (GetDlgItem (hwndDlg, IDC_USE_EMBEDDED_HEADER_BAK));
+
+ if (mountOptions->ProtectHiddenVolume)
+ {
+ GetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD_PROT_HIDVOL),
+ (LPSTR) mountOptions->ProtectedHidVolPassword.Text,
+ sizeof (mountOptions->ProtectedHidVolPassword.Text));
+
+ mountOptions->ProtectedHidVolPassword.Length = strlen ((char *) mountOptions->ProtectedHidVolPassword.Text);
+ }
+
+ // Cleanup
+ memset (tmp, 'X', MAX_PASSWORD);
+ tmp[MAX_PASSWORD] = 0;
+ SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD_PROT_HIDVOL), tmp);
+
+ if ((mountOptions->ProtectHiddenVolume && !bEnableBkgTask)
+ && (AskWarnYesNo ("HIDVOL_PROT_BKG_TASK_WARNING") == IDYES))
+ {
+ bEnableBkgTask = TRUE;
+ TaskBarIconAdd (MainDlg);
+ }
+
+ EndDialog (hwndDlg, lw);
+ return 1;
+ }
+
+ if (lw == IDC_MOUNT_READONLY || lw == IDC_PROTECT_HIDDEN_VOL)
+ {
+ BOOL protect;
+
+ if (lw == IDC_MOUNT_READONLY)
+ {
+ SendDlgItemMessage (hwndDlg, IDC_PROTECT_HIDDEN_VOL, BM_SETCHECK, BST_UNCHECKED, 0);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_PROTECT_HIDDEN_VOL), !IsButtonChecked (GetDlgItem (hwndDlg, IDC_MOUNT_READONLY)));
+ EnableWindow (GetDlgItem (hwndDlg, IDT_HIDDEN_VOL_PROTECTION), !IsButtonChecked (GetDlgItem (hwndDlg, IDC_MOUNT_READONLY)));
+ }
+
+ protect = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PROTECT_HIDDEN_VOL));
+
+ EnableWindow (GetDlgItem (hwndDlg, IDC_PASSWORD_PROT_HIDVOL), protect);
+ EnableWindow (GetDlgItem (hwndDlg, IDT_HIDDEN_PROT_PASSWD), protect);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_SHOW_PASSWORD_MO), protect);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_KEYFILES_HIDVOL_PROT), protect);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_KEYFILES_ENABLE_HIDVOL_PROT), protect);
+
+ return 1;
+ }
+
+ return 0;
+ }
+
+ return 0;
+}
+
+
+// Returns the block size (in bits) of the cipher with which the volume mounted as the
+// specified drive letter is encrypted. In case of a cascade of ciphers with different
+// block sizes the function returns the smallest block size.
+int GetCipherBlockSizeByDriveNo (int nDosDriveNo)
+{
+ VOLUME_PROPERTIES_STRUCT prop;
+ DWORD dwResult;
+
+ int blockSize = 0, cipherID;
+
+ memset (&prop, 0, sizeof(prop));
+ prop.driveNo = nDosDriveNo;
+
+ if (DeviceIoControl (hDriver, TC_IOCTL_GET_VOLUME_PROPERTIES, &prop, sizeof (prop), &prop, sizeof (prop), &dwResult, NULL))
+ {
+ for (cipherID = EAGetLastCipher (prop.ea);
+ cipherID != 0;
+ cipherID = EAGetPreviousCipher (prop.ea, cipherID))
+ {
+ if (blockSize > 0)
+ blockSize = min (blockSize, CipherGetBlockSize (cipherID) * 8);
+ else
+ blockSize = CipherGetBlockSize (cipherID) * 8;
+ }
+ }
+
+ return blockSize;
+}
+
+
+// Returns the mode of operation in which the volume mounted as the specified drive letter is encrypted.
+int GetModeOfOperationByDriveNo (int nDosDriveNo)
+{
+ VOLUME_PROPERTIES_STRUCT prop;
+ DWORD dwResult;
+
+ memset (&prop, 0, sizeof(prop));
+ prop.driveNo = nDosDriveNo;
+
+ if (DeviceIoControl (hDriver, TC_IOCTL_GET_VOLUME_PROPERTIES, &prop, sizeof (prop), &prop, sizeof (prop), &dwResult, NULL))
+ {
+ return prop.mode;
+ }
+
+ return 0;
+}
+
+
+BOOL CALLBACK VolumePropertiesDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+ BOOL bSysEnc = (BOOL) lParam;
+ BOOL bSysEncWholeDrive = FALSE;
+ WORD lw = LOWORD (wParam);
+ int i = 0;
+
+ switch (msg)
+ {
+ case WM_INITDIALOG:
+ {
+ VOLUME_PROPERTIES_STRUCT prop;
+ DWORD dwResult;
+
+ LVCOLUMNW lvCol;
+ HWND list = GetDlgItem (hwndDlg, IDC_VOLUME_PROPERTIES_LIST);
+ char szTmp[1024];
+ wchar_t sw[1024];
+ wchar_t *s;
+
+ if (bSysEnc)
+ {
+ try
+ {
+ BootEncStatus = BootEncObj->GetStatus();
+ bSysEncWholeDrive = WholeSysDriveEncryption(FALSE);
+ }
+ catch (Exception &e)
+ {
+ e.Show (MainDlg);
+ return 0;
+ }
+
+ if (!BootEncStatus.DriveEncrypted && !BootEncStatus.DriveMounted)
+ return 0;
+ }
+ else
+ {
+ switch (LOWORD (GetSelectedLong (GetDlgItem (GetParent(hwndDlg), IDC_DRIVELIST))))
+ {
+ case TC_MLIST_ITEM_FREE:
+
+ // No mounted volume
+ EndDialog (hwndDlg, IDOK);
+ return 0;
+
+ case TC_MLIST_ITEM_NONSYS_VOL:
+ // NOP
+ break;
+
+ case TC_MLIST_ITEM_SYS_DRIVE:
+ // Encrypted system drive
+ bSysEnc = TRUE;
+ bSysEncWholeDrive = TRUE;
+ break;
+
+ case TC_MLIST_ITEM_SYS_PARTITION:
+ // Encrypted system partition
+ bSysEnc = TRUE;
+ bSysEncWholeDrive = FALSE;
+ break;
+ }
+ }
+
+ LocalizeDialog (hwndDlg, "IDD_VOLUME_PROPERTIES");
+
+ SendMessage (list,LVM_SETEXTENDEDLISTVIEWSTYLE, 0,
+ LVS_EX_FULLROWSELECT
+ |LVS_EX_HEADERDRAGDROP
+ |LVS_EX_LABELTIP
+ );
+
+ memset (&lvCol,0,sizeof(lvCol));
+ lvCol.mask = LVCF_TEXT|LVCF_WIDTH|LVCF_SUBITEM|LVCF_FMT;
+ lvCol.pszText = GetString ("VALUE");
+ lvCol.cx = CompensateXDPI (208);
+ lvCol.fmt = LVCFMT_LEFT;
+ SendMessage (list,LVM_INSERTCOLUMNW,0,(LPARAM)&lvCol);
+
+ lvCol.pszText = GetString ("PROPERTY");
+ lvCol.cx = CompensateXDPI (192);
+ lvCol.fmt = LVCFMT_LEFT;
+ SendMessage (list,LVM_INSERTCOLUMNW,0,(LPARAM)&lvCol);
+
+ memset (&prop, 0, sizeof(prop));
+ prop.driveNo = HIWORD (GetSelectedLong (GetDlgItem (GetParent(hwndDlg), IDC_DRIVELIST))) - 'A';
+
+ if (bSysEnc)
+ {
+ try
+ {
+ BootEncStatus = BootEncObj->GetStatus();
+ if (!BootEncStatus.DriveEncrypted && !BootEncStatus.DriveMounted)
+ return 0;
+
+ BootEncObj->GetVolumeProperties (&prop);
+ }
+ catch (Exception &e)
+ {
+ e.Show (MainDlg);
+ return 0;
+ }
+ }
+ else
+ {
+ if (!DeviceIoControl (hDriver, TC_IOCTL_GET_VOLUME_PROPERTIES, &prop, sizeof (prop), &prop, sizeof (prop), &dwResult, NULL) || dwResult == 0)
+ return 0;
+ }
+
+ // Location
+ ListItemAddW (list, i, GetString ("LOCATION"));
+ if (bSysEnc)
+ ListSubItemSetW (list, i++, 1, GetString (bSysEncWholeDrive ? "SYSTEM_DRIVE" : IsHiddenOSRunning() ? "HIDDEN_SYSTEM_PARTITION" : "SYSTEM_PARTITION"));
+ else
+ ListSubItemSetW (list, i++, 1, (wchar_t *) (prop.wszVolume[1] != L'?' ? prop.wszVolume : prop.wszVolume + 4));
+
+ // Size
+ ListItemAddW (list, i, GetString ("SIZE"));
+ swprintf (sw, L"%I64u %s", prop.diskLength, GetString ("BYTES"));
+ ListSubItemSetW (list, i++, 1, sw);
+
+ // Type
+ ListItemAddW (list, i, GetString ("TYPE"));
+ if (bSysEnc)
+ ListSubItemSetW (list, i++, 1, GetString (IsHiddenOSRunning() ? "TYPE_HIDDEN_SYSTEM_ADJECTIVE" : "SYSTEM_VOLUME_TYPE_ADJECTIVE"));
+ else
+ {
+ ListSubItemSetW (list, i++, 1,
+ prop.hiddenVolume ? GetString ("HIDDEN") :
+ (prop.hiddenVolProtection != HIDVOL_PROT_STATUS_NONE ? GetString ("OUTER") : GetString ("NORMAL")));
+ }
+
+ if (!bSysEnc)
+ {
+ // Write protection
+ ListItemAddW (list, i, GetString ("READ_ONLY"));
+
+ if (prop.readOnly || prop.hiddenVolProtection == HIDVOL_PROT_STATUS_ACTION_TAKEN)
+ s = GetString ("UISTR_YES");
+ else
+ s = GetString ("UISTR_NO");
+
+ ListSubItemSetW (list, i++, 1, s);
+
+ // Hidden Volume Protection
+ ListItemAddW (list, i, GetString ("HIDDEN_VOL_PROTECTION"));
+ if (prop.hiddenVolume)
+ s = GetString ("NOT_APPLICABLE_OR_NOT_AVAILABLE");
+ else if (prop.hiddenVolProtection == HIDVOL_PROT_STATUS_NONE)
+ s = GetString ("UISTR_NO");
+ else if (prop.hiddenVolProtection == HIDVOL_PROT_STATUS_ACTIVE)
+ s = GetString ("UISTR_YES");
+ else if (prop.hiddenVolProtection == HIDVOL_PROT_STATUS_ACTION_TAKEN)
+ s = GetString ("HID_VOL_DAMAGE_PREVENTED");
+
+ ListSubItemSetW (list, i++, 1, s);
+ }
+
+ // Encryption algorithm
+ ListItemAddW (list, i, GetString ("ENCRYPTION_ALGORITHM"));
+
+ if (prop.ea == 0 || prop.ea > EAGetCount ())
+ {
+ ListSubItemSet (list, i, 1, "?");
+ return 1;
+ }
+
+ EAGetName (szTmp, prop.ea);
+ ListSubItemSet (list, i++, 1, szTmp);
+
+ // Key size(s)
+ {
+ char name[128];
+ int size = EAGetKeySize (prop.ea);
+ EAGetName (name, prop.ea);
+
+ if (strcmp (name, "Triple DES") == 0) /* Deprecated/legacy */
+ size -= 3; // Compensate for parity bytes
+
+ // Primary key
+ ListItemAddW (list, i, GetString ("KEY_SIZE"));
+ wsprintfW (sw, L"%d %s", size * 8, GetString ("BITS"));
+ ListSubItemSetW (list, i++, 1, sw);
+
+ if (strcmp (EAGetModeName (prop.ea, prop.mode, TRUE), "XTS") == 0)
+ {
+ // Secondary key (XTS)
+
+ ListItemAddW (list, i, GetString ("SECONDARY_KEY_SIZE_XTS"));
+ ListSubItemSetW (list, i++, 1, sw);
+ }
+ else if (strcmp (EAGetModeName (prop.ea, prop.mode, TRUE), "LRW") == 0)
+ {
+ // Tweak key (LRW)
+
+ ListItemAddW (list, i, GetString ("SECONDARY_KEY_SIZE_LRW"));
+ swprintf (sw, L"%d %s", CipherGetBlockSize (EAGetFirstCipher(prop.ea))*8, GetString ("BITS"));
+ ListSubItemSetW (list, i++, 1, sw);
+ }
+ }
+
+ // Block size
+ ListItemAddW (list, i, GetString ("BLOCK_SIZE"));
+ if (EAGetFirstMode (prop.ea) == INNER_CBC)
+ {
+ // Cascaded ciphers with non-equal block sizes (deprecated/legacy)
+ wchar_t tmpstr[64];
+ int i = EAGetLastCipher(prop.ea);
+
+ swprintf (sw, L"%d", CipherGetBlockSize(i)*8);
+
+ while (i = EAGetPreviousCipher(prop.ea, i))
+ {
+ swprintf (tmpstr, L"/%d", CipherGetBlockSize(i)*8);
+ wcscat (sw, tmpstr);
+ }
+ wcscat (sw, L" ");
+ }
+ else
+ {
+ swprintf (sw, L"%d ", CipherGetBlockSize (EAGetFirstCipher(prop.ea))*8);
+ }
+ wcscat (sw, GetString ("BITS"));
+ ListSubItemSetW (list, i++, 1, sw);
+
+ // Mode
+ ListItemAddW (list, i, GetString ("MODE_OF_OPERATION"));
+ ListSubItemSet (list, i++, 1, EAGetModeName (prop.ea, prop.mode, TRUE));
+
+ // PKCS 5 PRF
+ ListItemAddW (list, i, GetString ("PKCS5_PRF"));
+ ListSubItemSet (list, i++, 1, get_pkcs5_prf_name (prop.pkcs5));
+
+#if 0
+ // PCKS 5 iterations
+ ListItemAddW (list, i, GetString ("PKCS5_ITERATIONS"));
+ sprintf (szTmp, "%d", prop.pkcs5Iterations);
+ ListSubItemSet (list, i++, 1, szTmp);
+#endif
+
+#if 0
+ {
+ // Legacy
+
+ FILETIME ft, curFt;
+ LARGE_INTEGER ft64, curFt64;
+ SYSTEMTIME st;
+ wchar_t date[128];
+ memset (date, 0, sizeof (date));
+
+ // Volume date
+ ListItemAddW (list, i, GetString ("VOLUME_CREATE_DATE"));
+ *(unsigned __int64 *)(&ft) = prop.volumeCreationTime;
+ FileTimeToSystemTime (&ft, &st);
+ GetDateFormatW (LOCALE_USER_DEFAULT, 0, &st, 0, sw, sizeof (sw)/2);
+ swprintf (date, L"%s ", sw);
+ GetTimeFormatW (LOCALE_USER_DEFAULT, 0, &st, 0, sw, sizeof (sw)/2);
+ wcscat (date, sw);
+ ListSubItemSetW (list, i++, 1, date);
+
+ // Header date
+ ListItemAddW (list, i, GetString ("VOLUME_HEADER_DATE"));
+ *(unsigned __int64 *)(&ft) = prop.headerCreationTime;
+ FileTimeToSystemTime (&ft, &st);
+ GetDateFormatW (LOCALE_USER_DEFAULT, 0, &st, 0, sw, sizeof (sw)/2);
+ swprintf (date, L"%s ", sw);
+ GetTimeFormatW (LOCALE_USER_DEFAULT, 0, &st, 0, sw, sizeof (sw)/2);
+ wcscat (date, sw);
+
+ GetLocalTime (&st);
+ SystemTimeToFileTime (&st, &curFt);
+ curFt64.HighPart = curFt.dwHighDateTime;
+ curFt64.LowPart = curFt.dwLowDateTime;
+ ft64.HighPart = ft.dwHighDateTime;
+ ft64.LowPart = ft.dwLowDateTime;
+ swprintf (date + wcslen (date), GetString ("VOLUME_HEADER_DAYS")
+ , (curFt64.QuadPart - ft64.QuadPart)/(24LL*3600*10000000));
+ ListSubItemSetW (list, i++, 1, date);
+ }
+#endif // 0
+
+ if (!bSysEnc || IsHiddenOSRunning())
+ {
+ // Volume format version
+ ListItemAddW (list, i, GetString ("VOLUME_FORMAT_VERSION"));
+ sprintf (szTmp, "%d", prop.volFormatVersion);
+ ListSubItemSet (list, i++, 1, szTmp);
+
+ // Backup header
+ ListItemAddW (list, i, GetString ("BACKUP_HEADER"));
+ ListSubItemSetW (list, i++, 1, GetString (prop.volFormatVersion > 1 ? "UISTR_YES" : "UISTR_NO"));
+ }
+
+ // Total data read
+ ListItemAddW (list, i, GetString ("TOTAL_DATA_READ"));
+ GetSizeString (prop.totalBytesRead, sw);
+ ListSubItemSetW (list, i++, 1, sw);
+
+ // Total data written
+ ListItemAddW (list, i, GetString ("TOTAL_DATA_WRITTEN"));
+ GetSizeString (prop.totalBytesWritten, sw);
+ ListSubItemSetW (list, i++, 1, sw);
+
+ if (bSysEnc)
+ {
+ // TrueCrypt Boot Loader version
+ ListItemAddW (list, i, GetString ("TC_BOOT_LOADER_VERSION"));
+ ListSubItemSet (list, i++, 1, (char *) GetUserFriendlyVersionString (BootEncStatus.BootLoaderVersion).c_str());
+
+ // Encrypted portion
+ ListItemAddW (list, i, GetString ("ENCRYPTED_PORTION"));
+ if (GetSysEncDeviceEncryptedPartSize (FALSE) == GetSysEncDeviceSize (FALSE))
+ ListSubItemSetW (list, i++, 1, GetString ("ENCRYPTED_PORTION_FULLY_ENCRYPTED"));
+ else if (GetSysEncDeviceEncryptedPartSize (FALSE) <= 1)
+ ListSubItemSetW (list, i++, 1, GetString ("ENCRYPTED_PORTION_NOT_ENCRYPTED"));
+ else
+ {
+
+ _snwprintf (sw,
+ sizeof sw/2,
+ GetString ("PROCESSED_PORTION_X_PERCENT"),
+ (double) GetSysEncDeviceEncryptedPartSize (FALSE) / (double) GetSysEncDeviceSize (FALSE) * 100.0);
+
+ ListSubItemSetW (list, i++, 1, sw);
+ }
+ }
+
+ return 0;
+ }
+
+ case WM_COMMAND:
+ if (lw == IDOK)
+ {
+ EndDialog (hwndDlg, lw);
+ return 1;
+ }
+ return 0;
+
+ case WM_CLOSE:
+ EndDialog (hwndDlg, lw);
+ return 1;
+ }
+
+ return 0;
+}
+
+
+BOOL CALLBACK TravelerDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+ WORD lw = LOWORD (wParam);
+ static BOOL bAutoRunWarningDisplayed = FALSE;
+
+ switch (msg)
+ {
+ case WM_INITDIALOG:
+ {
+ char i;
+ int index;
+ char drive[] = { 0, ':', 0 };
+
+ LocalizeDialog (hwndDlg, "IDD_TRAVELER_DLG");
+
+ SendDlgItemMessage (hwndDlg, IDC_COPY_WIZARD, BM_SETCHECK,
+ BST_CHECKED, 0);
+
+ SendDlgItemMessage (hwndDlg, IDC_TRAVEL_OPEN_EXPLORER, BM_SETCHECK,
+ BST_CHECKED, 0);
+
+ SendDlgItemMessage (hwndDlg, IDC_AUTORUN_DISABLE, BM_SETCHECK,
+ BST_CHECKED, 0);
+
+ SendDlgItemMessage (hwndDlg, IDC_DRIVELIST, CB_RESETCONTENT, 0, 0);
+
+ index = SendDlgItemMessageW (hwndDlg, IDC_DRIVELIST, CB_ADDSTRING, 0, (LPARAM) GetString ("FIRST_AVAILABLE"));
+ SendDlgItemMessage (hwndDlg, IDC_DRIVELIST, CB_SETITEMDATA, index, (LPARAM) 0);
+
+ for (i = 'D'; i <= 'Z'; i++)
+ {
+ drive[0] = i;
+ index = SendDlgItemMessage (hwndDlg, IDC_DRIVELIST, CB_ADDSTRING, 0, (LPARAM) drive);
+ SendDlgItemMessage (hwndDlg, IDC_DRIVELIST, CB_SETITEMDATA, index, (LPARAM) i);
+ }
+
+ SendDlgItemMessage (hwndDlg, IDC_DRIVELIST, CB_SETCURSEL, 0, 0);
+
+ return 0;
+ }
+
+
+ case WM_COMMAND:
+
+ if (HIWORD (wParam) == BN_CLICKED
+ && (lw == IDC_AUTORUN_DISABLE || lw == IDC_AUTORUN_MOUNT || lw == IDC_AUTORUN_START ))
+ {
+ BOOL enabled = IsButtonChecked (GetDlgItem (hwndDlg, IDC_AUTORUN_MOUNT));
+
+ EnableWindow (GetDlgItem (hwndDlg, IDC_BROWSE_FILES), enabled);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_VOLUME_NAME), enabled);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_TRAVEL_OPEN_EXPLORER), enabled);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_TRAV_CACHE_PASSWORDS), enabled);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_MOUNT_READONLY), enabled);
+ EnableWindow (GetDlgItem (hwndDlg, IDC_DRIVELIST), enabled);
+ EnableWindow (GetDlgItem (hwndDlg, IDT_TRAVELER_MOUNT), enabled);
+ EnableWindow (GetDlgItem (hwndDlg, IDT_MOUNT_LETTER), enabled);
+ EnableWindow (GetDlgItem (hwndDlg, IDT_MOUNT_SETTINGS), enabled);
+
+ if (!bAutoRunWarningDisplayed
+ && (lw == IDC_AUTORUN_MOUNT || lw == IDC_AUTORUN_START))
+ {
+ bAutoRunWarningDisplayed = TRUE;
+ Warning ("AUTORUN_MAY_NOT_ALWAYS_WORK");
+ }
+
+ return 1;
+ }
+
+ if (lw == IDC_BROWSE_FILES)
+ {
+ char dstDir[MAX_PATH];
+ char volName[MAX_PATH] = { 0 };
+
+ GetDlgItemText (hwndDlg, IDC_DIRECTORY, dstDir, sizeof dstDir);
+
+ if (BrowseFilesInDir (hwndDlg, "OPEN_TITLE", dstDir, volName, bHistory, FALSE, NULL))
+ SetDlgItemText (hwndDlg, IDC_VOLUME_NAME, strchr (volName, '\\') + 1);
+
+ return 1;
+ }
+
+ if (lw == IDC_BROWSE_DIRS)
+ {
+ char dstPath[MAX_PATH * 2];
+ GetDlgItemText (hwndDlg, IDC_DIRECTORY, dstPath, sizeof dstPath);
+
+ if (BrowseDirectories (hwndDlg, "SELECT_DEST_DIR", dstPath))
+ SetDlgItemText (hwndDlg, IDC_DIRECTORY, dstPath);
+
+ return 1;
+ }
+
+ if (lw == IDCANCEL || lw == IDCLOSE)
+ {
+ EndDialog (hwndDlg, lw);
+ return 1;
+ }
+
+ if (lw == IDC_CREATE)
+ {
+
+ BOOL copyWizard, bExplore, bCacheInDriver, bAutoRun, bAutoMount, bMountReadOnly;
+ char dstDir[MAX_PATH];
+ char srcPath[MAX_PATH * 2];
+ char dstPath[MAX_PATH * 2];
+ char appDir[MAX_PATH];
+ char sysDir[MAX_PATH];
+ char volName[MAX_PATH];
+ int drive;
+
+ GetDlgItemText (hwndDlg, IDC_DIRECTORY, dstDir, sizeof dstDir);
+ volName[0] = 0;
+ GetDlgItemText (hwndDlg, IDC_VOLUME_NAME, volName + 1, sizeof volName);
+
+ drive = SendDlgItemMessage (hwndDlg, IDC_DRIVELIST, CB_GETCURSEL, 0, 0);
+ drive = SendDlgItemMessage (hwndDlg, IDC_DRIVELIST, CB_GETITEMDATA, drive, 0);
+
+ copyWizard = IsButtonChecked (GetDlgItem (hwndDlg, IDC_COPY_WIZARD));
+ bExplore = IsButtonChecked (GetDlgItem (hwndDlg, IDC_TRAVEL_OPEN_EXPLORER));
+ bCacheInDriver = IsButtonChecked (GetDlgItem (hwndDlg, IDC_TRAV_CACHE_PASSWORDS));
+ bMountReadOnly = IsButtonChecked (GetDlgItem (hwndDlg, IDC_MOUNT_READONLY));
+ bAutoRun = !IsButtonChecked (GetDlgItem (hwndDlg, IDC_AUTORUN_DISABLE));
+ bAutoMount = IsButtonChecked (GetDlgItem (hwndDlg, IDC_AUTORUN_MOUNT));
+
+ if (dstDir[0] == 0)
+ {
+ SetFocus (GetDlgItem (hwndDlg, IDC_DIRECTORY));
+ MessageBoxW (hwndDlg, GetString ("NO_PATH_SELECTED"), lpszTitle, MB_ICONEXCLAMATION);
+ return 1;
+ }
+
+
+ if (bAutoMount && volName[1] == 0)
+ {
+ SetFocus (GetDlgItem (hwndDlg, IDC_VOLUME_NAME));
+ MessageBoxW (hwndDlg, GetString ("NO_FILE_SELECTED"), lpszTitle, MB_ICONEXCLAMATION);
+ return 1;
+ }
+
+ if (volName[1] != 0)
+ {
+ volName[0] = '"';
+ strcat (volName, "\"");
+ }
+
+ GetModuleFileName (NULL, appDir, sizeof (appDir));
+ strrchr (appDir, '\\')[0] = 0;
+
+ WaitCursor ();
+ GetSystemDirectory (sysDir, sizeof (sysDir));
+
+ sprintf (dstPath, "%s\\TrueCrypt", dstDir);
+ CreateDirectory (dstPath, NULL);
+
+ // Main app
+ sprintf (srcPath, "%s\\TrueCrypt.exe", appDir);
+ sprintf (dstPath, "%s\\TrueCrypt\\TrueCrypt.exe", dstDir);
+ if (!TCCopyFile (srcPath, dstPath))
+ {
+ handleWin32Error (hwndDlg);
+ goto stop;
+ }
+
+ // Wizard
+ if (copyWizard)
+ {
+ sprintf (srcPath, "%s\\TrueCrypt Format.exe", appDir);
+ sprintf (dstPath, "%s\\TrueCrypt\\TrueCrypt Format.exe", dstDir);
+ if (!TCCopyFile (srcPath, dstPath))
+ {
+ handleWin32Error (hwndDlg);
+ goto stop;
+ }
+ }
+
+ // Driver
+ sprintf (srcPath, "%s\\truecrypt.sys", appDir);
+ sprintf (dstPath, "%s\\TrueCrypt\\truecrypt.sys", dstDir);
+ if (!TCCopyFile (srcPath, dstPath))
+ {
+ handleWin32Error (hwndDlg);
+ goto stop;
+ }
+
+ // Driver x64
+ sprintf (srcPath, "%s\\truecrypt-x64.sys", appDir);
+ sprintf (dstPath, "%s\\TrueCrypt\\truecrypt-x64.sys", dstDir);
+ if (!TCCopyFile (srcPath, dstPath))
+ {
+ handleWin32Error (hwndDlg);
+ goto stop;
+ }
+
+ if (GetPreferredLangId () && strcmp (GetPreferredLangId (), "en") != 0)
+ {
+ // Language pack
+ sprintf (srcPath, "%s\\Language.%s.xml", appDir, GetPreferredLangId ());
+ sprintf (dstPath, "%s\\TrueCrypt\\Language.%s.xml", dstDir, GetPreferredLangId ());
+ TCCopyFile (srcPath, dstPath);
+ }
+
+ // AutoRun
+ sprintf (dstPath, "%s\\autorun.inf", dstDir);
+ DeleteFile (dstPath);
+ if (bAutoRun)
+ {
+ FILE *af;
+ char autoMount[100];
+ char driveLetter[] = { ' ', '/', 'l', (char) drive, 0 };
+
+ af = fopen (dstPath, "w,ccs=UNICODE");
+
+ if (af == NULL)
+ {
+ MessageBoxW (hwndDlg, GetString ("CANT_CREATE_AUTORUN"), lpszTitle, MB_ICONERROR);
+ goto stop;
+ }
+
+ sprintf (autoMount, "TrueCrypt\\TrueCrypt.exe /q background%s%s%s%s /m rm /v %s",
+ drive > 0 ? driveLetter : "",
+ bExplore ? " /e" : "",
+ bCacheInDriver ? " /c y" : "",
+ bMountReadOnly ? " /m ro" : "",
+ volName);
+
+ fwprintf (af, L"[autorun]\nlabel=%s\nicon=TrueCrypt\\TrueCrypt.exe\n", GetString ("TC_TRAVELER_DISK"));
+ fwprintf (af, L"action=%s\n", bAutoMount ? GetString ("MOUNT_TC_VOLUME") : GetString ("IDC_PREF_LOGON_START"));
+ fwprintf (af, L"open=%hs\n", bAutoMount ? autoMount : "TrueCrypt\\TrueCrypt.exe");
+ fwprintf (af, L"shell\\start=%s\nshell\\start\\command=TrueCrypt\\TrueCrypt.exe\n", GetString ("IDC_PREF_LOGON_START"));
+ fwprintf (af, L"shell\\dismount=%s\nshell\\dismount\\command=TrueCrypt\\TrueCrypt.exe /q /d\n", GetString ("DISMOUNT_ALL_TC_VOLUMES"));
+
+ CheckFileStreamWriteErrors (af, dstPath);
+ fclose (af);
+ }
+ MessageBoxW (hwndDlg, GetString ("TRAVELER_DISK_CREATED"), lpszTitle, MB_ICONINFORMATION);
+
+stop:
+ NormalCursor ();
+ return 1;
+ }
+ return 0;
+ }
+
+ return 0;
+}
+
+void BuildTree (HWND hTree)
+{
+ HIMAGELIST hList;
+ HBITMAP hBitmap, hBitmapMask;
+ LVCOLUMNW lvCol;
+
+ ListView_DeleteColumn (hTree,0);
+ ListView_DeleteColumn (hTree,0);
+ ListView_DeleteColumn (hTree,0);
+ ListView_DeleteColumn (hTree,0);
+ ListView_DeleteColumn (hTree,0);
+ ListView_DeleteColumn (hTree,0);
+
+ SendMessage(hTree,LVM_SETEXTENDEDLISTVIEWSTYLE,0,
+ LVS_EX_FULLROWSELECT
+ |LVS_EX_HEADERDRAGDROP
+ );
+
+ memset(&lvCol,0,sizeof(lvCol));
+
+ lvCol.mask = LVCF_TEXT|LVCF_WIDTH|LVCF_SUBITEM|LVCF_FMT;
+ lvCol.pszText = GetString ("DRIVE");
+ lvCol.cx = CompensateXDPI (38);
+ lvCol.fmt = LVCFMT_COL_HAS_IMAGES|LVCFMT_LEFT ;
+ SendMessage (hTree,LVM_INSERTCOLUMNW,0,(LPARAM)&lvCol);
+
+ lvCol.pszText = GetString ("VOLUME");
+ lvCol.cx = CompensateXDPI (253);
+ lvCol.fmt = LVCFMT_LEFT;
+ SendMessage (hTree,LVM_INSERTCOLUMNW,1,(LPARAM)&lvCol);
+ LastDriveListVolumeColumnWidth = ListView_GetColumnWidth (hTree, 1);
+
+ lvCol.pszText = GetString ("SIZE");
+ lvCol.cx = CompensateXDPI (55);
+ lvCol.fmt = LVCFMT_RIGHT;
+ SendMessage (hTree,LVM_INSERTCOLUMNW,2,(LPARAM)&lvCol);
+
+ lvCol.pszText = GetString ("ENCRYPTION_ALGORITHM_LV");
+ lvCol.cx = CompensateXDPI (121);
+ lvCol.fmt = LVCFMT_LEFT;
+ SendMessage (hTree,LVM_INSERTCOLUMNW,3,(LPARAM)&lvCol);
+
+ lvCol.pszText = GetString ("TYPE");
+ lvCol.cx = CompensateXDPI (52);
+ lvCol.fmt = LVCFMT_LEFT;
+ SendMessage (hTree,LVM_INSERTCOLUMNW,4,(LPARAM)&lvCol);
+
+ // Regular drive icon
+
+ hBitmap = LoadBitmap (hInst, MAKEINTRESOURCE (IDB_DRIVEICON));
+ if (hBitmap == NULL)
+ return;
+ hBitmapMask = LoadBitmap (hInst, MAKEINTRESOURCE (IDB_DRIVEICON_MASK));
+
+ hList = ImageList_Create (16, 12, ILC_COLOR8|ILC_MASK, 2, 2);
+ if (ImageList_Add (hList, hBitmap, hBitmapMask) == -1)
+ {
+ DeleteObject (hBitmap);
+ DeleteObject (hBitmapMask);
+ return;
+ }
+ else
+ {
+ DeleteObject (hBitmap);
+ DeleteObject (hBitmapMask);
+ }
+
+ // System drive icon
+
+ hBitmap = LoadBitmap (hInst, MAKEINTRESOURCE (IDB_SYS_DRIVEICON));
+ if (hBitmap == NULL)
+ return;
+ hBitmapMask = LoadBitmap (hInst, MAKEINTRESOURCE (IDB_SYS_DRIVEICON_MASK));
+
+ if (ImageList_Add (hList, hBitmap, hBitmapMask) == -1)
+ {
+ DeleteObject (hBitmap);
+ DeleteObject (hBitmapMask);
+ return;
+ }
+ else
+ {
+ DeleteObject (hBitmap);
+ DeleteObject (hBitmapMask);
+ }
+
+ ListView_SetImageList (hTree, hList, LVSIL_NORMAL);
+ ListView_SetImageList (hTree, hList, LVSIL_SMALL);
+
+ LoadDriveLetters (hTree, 0);
+}
+
+LPARAM GetSelectedLong (HWND hTree)
+{
+ int hItem = ListView_GetSelectionMark (hTree);
+ LVITEM item;
+
+ if (nSelectedDriveIndex >= 0)
+ hItem = nSelectedDriveIndex;
+
+ memset(&item, 0, sizeof(LVITEM));
+ item.mask = LVIF_PARAM;
+ item.iItem = hItem;
+
+ if (ListView_GetItem (hTree, &item) == FALSE)
+ return MAKELONG (0xffff, 0xffff);
+ else
+ return item.lParam;
+}
+
+LPARAM GetItemLong (HWND hTree, int itemNo)
+{
+ LVITEM item;
+
+ memset(&item, 0, sizeof(LVITEM));
+ item.mask = LVIF_PARAM;
+ item.iItem = itemNo;
+
+ if (ListView_GetItem (hTree, &item) == FALSE)
+ return MAKELONG (0xffff, 0xffff);
+ else
+ return item.lParam;
+}
+
+static int AskVolumePassword (HWND hwndDlg, Password *password, char *titleStringId, BOOL enableMountOptions)
+{
+ int result;
+
+ PasswordDialogTitleStringId = titleStringId;
+ PasswordDialogDisableMountOptions = !enableMountOptions;
+
+ result = DialogBoxParamW (hInst,
+ MAKEINTRESOURCEW (IDD_PASSWORD_DLG), hwndDlg,
+ (DLGPROC) PasswordDlgProc, (LPARAM) password);
+
+ if (result != IDOK)
+ {
+ password->Length = 0;
+ burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword));
+ }
+
+ return result == IDOK;
+}
+
+// GUI actions
+
+static BOOL Mount (HWND hwndDlg, int nDosDriveNo, char *szFileName)
+{
+ BOOL status = FALSE;
+ char fileName[MAX_PATH];
+ int mounted = 0, modeOfOperation;
+
+ bPrebootPasswordDlgMode = mountOptions.PartitionInInactiveSysEncScope;
+
+ if (nDosDriveNo == 0)
+ nDosDriveNo = HIWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) - 'A';
+
+ if (!MultipleMountOperationInProgress)
+ VolumePassword.Length = 0;
+
+ if (szFileName == NULL)
+ {
+ GetWindowText (GetDlgItem (hwndDlg, IDC_VOLUME), fileName, sizeof (fileName));
+ szFileName = fileName;
+ }
+
+ if (strlen(szFileName) == 0)
+ {
+ status = FALSE;
+ goto ret;
+ }
+
+ if (IsMountedVolume (szFileName))
+ {
+ Warning ("VOL_ALREADY_MOUNTED");
+ status = FALSE;
+ goto ret;
+ }
+
+ if (!VolumePathExists (szFileName))
+ {
+ if (!MultipleMountOperationInProgress)
+ handleWin32Error (hwndDlg);
+
+ status = FALSE;
+ goto ret;
+ }
+
+ ResetWrongPwdRetryCount ();
+
+ // First try cached passwords and if they fail ask user for a new one
+ WaitCursor ();
+
+ mounted = MountVolume (hwndDlg, nDosDriveNo, szFileName, NULL, bCacheInDriver, bForceMount, &mountOptions, Silent, FALSE);
+
+ // If keyfiles are enabled, test empty password first
+ if (!mounted && KeyFilesEnable && FirstKeyFile)
+ {
+ Password emptyPassword;
+ emptyPassword.Length = 0;
+
+ KeyFilesApply (&emptyPassword, FirstKeyFile);
+ mounted = MountVolume (hwndDlg, nDosDriveNo, szFileName, &emptyPassword, bCacheInDriver, bForceMount, &mountOptions, Silent, FALSE);
+
+ burn (&emptyPassword, sizeof (emptyPassword));
+ }
+
+ // Test password and/or keyfiles used for the previous volume
+ if (!mounted && MultipleMountOperationInProgress && VolumePassword.Length != 0)
+ mounted = MountVolume (hwndDlg, nDosDriveNo, szFileName, &VolumePassword, bCacheInDriver, bForceMount, &mountOptions, Silent, FALSE);
+
+ NormalCursor ();
+
+ if (mounted)
+ {
+ // Check for deprecated CBC mode
+ modeOfOperation = GetModeOfOperationByDriveNo (nDosDriveNo);
+ if (modeOfOperation == CBC || modeOfOperation == OUTER_CBC)
+ Warning("WARN_CBC_MODE");
+
+ // Check for deprecated 64-bit-block ciphers
+ if (GetCipherBlockSizeByDriveNo (nDosDriveNo) == 64)
+ Warning("WARN_64_BIT_BLOCK_CIPHER");
+
+ // Check for problematic file extensions (exe, dll, sys)
+ if (CheckFileExtension(szFileName))
+ Warning ("EXE_FILE_EXTENSION_MOUNT_WARNING");
+ }
+
+ while (mounted == 0)
+ {
+ if (CmdVolumePassword.Length > 0)
+ {
+ VolumePassword = CmdVolumePassword;
+ }
+ else if (!Silent)
+ {
+ strcpy (PasswordDlgVolume, szFileName);
+
+ if (!AskVolumePassword (hwndDlg, &VolumePassword, NULL, TRUE))
+ goto ret;
+ }
+
+ WaitCursor ();
+
+ if (KeyFilesEnable)
+ KeyFilesApply (&VolumePassword, FirstKeyFile);
+
+ mounted = MountVolume (hwndDlg, nDosDriveNo, szFileName, &VolumePassword, bCacheInDriver, bForceMount, &mountOptions, Silent, !Silent);
+ NormalCursor ();
+
+ // Check for deprecated CBC mode
+ modeOfOperation = GetModeOfOperationByDriveNo (nDosDriveNo);
+ if (modeOfOperation == CBC || modeOfOperation == OUTER_CBC)
+ Warning("WARN_CBC_MODE");
+
+ // Check for deprecated 64-bit-block ciphers
+ if (GetCipherBlockSizeByDriveNo (nDosDriveNo) == 64)
+ Warning("WARN_64_BIT_BLOCK_CIPHER");
+
+ // Check for legacy non-ASCII passwords
+ if (mounted > 0 && !KeyFilesEnable && !CheckPasswordCharEncoding (NULL, &VolumePassword))
+ Warning ("UNSUPPORTED_CHARS_IN_PWD_RECOM");
+
+ // Check for problematic file extensions (exe, dll, sys)
+ if (mounted > 0 && CheckFileExtension (szFileName))
+ Warning ("EXE_FILE_EXTENSION_MOUNT_WARNING");
+
+ if (!MultipleMountOperationInProgress)
+ burn (&VolumePassword, sizeof (VolumePassword));
+
+ burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword));
+
+ if (CmdVolumePassword.Length > 0 || Silent)
+ break;
+ }
+
+ if (mounted > 0)
+ {
+ status = TRUE;
+
+ if (bBeep)
+ MessageBeep (0xFFFFFFFF);
+
+ RefreshMainDlg(hwndDlg);
+
+ if (bExplore)
+ {
+ WaitCursor();
+ OpenVolumeExplorerWindow (nDosDriveNo);
+ NormalCursor();
+ }
+
+ if (mountOptions.ProtectHiddenVolume)
+ Info ("HIDVOL_PROT_WARN_AFTER_MOUNT");
+ }
+
+ret:
+ if (!MultipleMountOperationInProgress)
+ burn (&VolumePassword, sizeof (VolumePassword));
+
+ burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword));
+
+ RestoreDefaultKeyFilesParam ();
+
+ if (UsePreferences)
+ bCacheInDriver = bCacheInDriverDefault;
+
+ if (status && CloseSecurityTokenSessionsAfterMount && !MultipleMountOperationInProgress)
+ SecurityToken::CloseAllSessions();
+
+ return status;
+}
+
+
+static BOOL Dismount (HWND hwndDlg, int nDosDriveNo)
+{
+ BOOL status = FALSE;
+ WaitCursor ();
+
+ if (nDosDriveNo == 0)
+ nDosDriveNo = (char) (HIWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) - 'A');
+
+ if (bCloseDismountedWindows)
+ {
+ CloseVolumeExplorerWindows (hwndDlg, nDosDriveNo);
+ }
+
+ if (UnmountVolume (hwndDlg, nDosDriveNo, bForceUnmount))
+ {
+ status = TRUE;
+
+ if (bBeep)
+ MessageBeep (0xFFFFFFFF);
+ RefreshMainDlg (hwndDlg);
+
+ if (nCurrentOS == WIN_2000 && RemoteSession && !IsAdmin ())
+ LoadDriveLetters (GetDlgItem (hwndDlg, IDC_DRIVELIST), 0);
+ }
+
+ NormalCursor ();
+ return status;
+}
+
+static BOOL DismountAll (HWND hwndDlg, BOOL forceUnmount, BOOL interact, int dismountMaxRetries, int dismountAutoRetryDelay)
+{
+ BOOL status = TRUE;
+ MOUNT_LIST_STRUCT mountList;
+ DWORD dwResult;
+ UNMOUNT_STRUCT unmount;
+ BOOL bResult;
+ unsigned __int32 prevMountedDrives = 0;
+ int i;
+
+retry:
+ WaitCursor();
+
+ DeviceIoControl (hDriver, TC_IOCTL_GET_MOUNTED_VOLUMES, &mountList, sizeof (mountList), &mountList, sizeof (mountList), &dwResult, NULL);
+
+ if (mountList.ulMountedDrives == 0)
+ {
+ NormalCursor();
+ return TRUE;
+ }
+
+ BroadcastDeviceChange (DBT_DEVICEREMOVEPENDING, 0, mountList.ulMountedDrives);
+
+ prevMountedDrives = mountList.ulMountedDrives;
+
+ for (i = 0; i < 26; i++)
+ {
+ if (mountList.ulMountedDrives & (1 << i))
+ {
+ if (bCloseDismountedWindows)
+ CloseVolumeExplorerWindows (hwndDlg, i);
+ }
+ }
+
+ unmount.nDosDriveNo = 0;
+ unmount.ignoreOpenFiles = forceUnmount;
+
+ do
+ {
+ bResult = DeviceIoControl (hDriver, TC_IOCTL_DISMOUNT_ALL_VOLUMES, &unmount,
+ sizeof (unmount), &unmount, sizeof (unmount), &dwResult, NULL);
+
+ if (bResult == FALSE)
+ {
+ NormalCursor();
+ handleWin32Error (hwndDlg);
+ return FALSE;
+ }
+
+ if (unmount.nReturnCode == ERR_SUCCESS
+ && unmount.HiddenVolumeProtectionTriggered
+ && !VolumeNotificationsList.bHidVolDamagePrevReported [unmount.nDosDriveNo])
+ {
+ wchar_t msg[4096];
+
+ VolumeNotificationsList.bHidVolDamagePrevReported [unmount.nDosDriveNo] = TRUE;
+ swprintf (msg, GetString ("DAMAGE_TO_HIDDEN_VOLUME_PREVENTED"), unmount.nDosDriveNo + 'A');
+ SetForegroundWindow (hwndDlg);
+ MessageBoxW (hwndDlg, msg, lpszTitle, MB_ICONWARNING | MB_SETFOREGROUND | MB_TOPMOST);
+
+ unmount.HiddenVolumeProtectionTriggered = FALSE;
+ continue;
+ }
+
+ if (unmount.nReturnCode == ERR_FILES_OPEN)
+ Sleep (dismountAutoRetryDelay);
+ else
+ break;
+
+ } while (--dismountMaxRetries > 0);
+
+ memset (&mountList, 0, sizeof (mountList));
+ DeviceIoControl (hDriver, TC_IOCTL_GET_MOUNTED_VOLUMES, &mountList, sizeof (mountList), &mountList, sizeof (mountList), &dwResult, NULL);
+ BroadcastDeviceChange (DBT_DEVICEREMOVECOMPLETE, 0, prevMountedDrives & ~mountList.ulMountedDrives);
+
+ RefreshMainDlg (hwndDlg);
+
+ if (nCurrentOS == WIN_2000 && RemoteSession && !IsAdmin ())
+ LoadDriveLetters (GetDlgItem (hwndDlg, IDC_DRIVELIST), 0);
+
+ NormalCursor();
+
+ if (unmount.nReturnCode != 0)
+ {
+ if (forceUnmount)
+ status = FALSE;
+
+ if (unmount.nReturnCode == ERR_FILES_OPEN)
+ {
+ if (interact && IDYES == AskWarnYesNoTopmost ("UNMOUNTALL_LOCK_FAILED"))
+ {
+ forceUnmount = TRUE;
+ goto retry;
+ }
+
+ if (IsOSAtLeast (WIN_7))
+ {
+ // Undo SHCNE_DRIVEREMOVED
+ DeviceIoControl (hDriver, TC_IOCTL_GET_MOUNTED_VOLUMES, NULL, 0, &mountList, sizeof (mountList), &dwResult, NULL);
+
+ for (i = 0; i < 26; i++)
+ {
+ if (mountList.ulMountedDrives & (1 << i))
+ {
+ char root[] = { (char) i + 'A', ':', '\\', 0 };
+ SHChangeNotify (SHCNE_DRIVEADD, SHCNF_PATH, root, NULL);
+ }
+ }
+ }
+
+ return FALSE;
+ }
+
+ if (interact)
+ MessageBoxW (hwndDlg, GetString ("UNMOUNT_FAILED"), lpszTitle, MB_ICONERROR);
+ }
+ else
+ {
+ if (bBeep)
+ MessageBeep (0xFFFFFFFF);
+ }
+
+ return status;
+}
+
+static BOOL MountAllDevices (HWND hwndDlg, BOOL bPasswordPrompt)
+{
+ HWND driveList = GetDlgItem (hwndDlg, IDC_DRIVELIST);
+ int selDrive = ListView_GetSelectionMark (driveList);
+ BOOL shared = FALSE, status = FALSE, b64BitBlockCipher = FALSE, bCBCMode = FALSE, bHeaderBakRetry = FALSE;
+ int mountedVolCount = 0, modeOfOperation;
+ vector <HostDevice> devices;
+
+ VolumePassword.Length = 0;
+ mountOptions = defaultMountOptions;
+ bPrebootPasswordDlgMode = FALSE;
+
+ if (selDrive == -1)
+ selDrive = 0;
+
+ ResetWrongPwdRetryCount ();
+
+ MultipleMountOperationInProgress = TRUE;
+
+ do
+ {
+ if (!bHeaderBakRetry)
+ {
+ if (!CmdVolumePasswordValid && bPasswordPrompt)
+ {
+ PasswordDlgVolume[0] = '\0';
+ if (!AskVolumePassword (hwndDlg, &VolumePassword, NULL, TRUE))
+ goto ret;
+ }
+ else if (CmdVolumePasswordValid)
+ {
+ bPasswordPrompt = FALSE;
+ VolumePassword = CmdVolumePassword;
+ }
+
+ WaitCursor();
+
+ if (FirstCmdKeyFile)
+ KeyFilesApply (&VolumePassword, FirstCmdKeyFile);
+ else if (KeyFilesEnable)
+ KeyFilesApply (&VolumePassword, FirstKeyFile);
+
+ }
+
+ if (devices.empty())
+ devices = GetAvailableHostDevices (true, false, true, true);
+ foreach (const HostDevice &drive, devices)
+ {
+ vector <HostDevice> partitions = drive.Partitions;
+ partitions.insert (partitions.begin(), drive);
+
+ foreach (const HostDevice &device, partitions)
+ {
+ char szFileName[TC_MAX_PATH];
+ strcpy_s (szFileName, sizeof (szFileName), device.Path.c_str());
+ BOOL mounted = IsMountedVolume (szFileName);
+
+ // Skip other partitions of the disk if partition0 (whole disk) is mounted
+ if (!device.IsPartition && mounted)
+ break;
+
+ if (device.Floppy)
+ break;
+
+ if (device.HasUnencryptedFilesystem && !mountOptions.UseBackupHeader && !bHeaderBakRetry)
+ continue;
+
+ if (!mounted)
+ {
+ int nDosDriveNo;
+
+ while (LOWORD (GetItemLong (driveList, selDrive)) != 0xffff)
+ {
+ if(LOWORD (GetItemLong (driveList, selDrive)) != TC_MLIST_ITEM_FREE)
+ {
+ selDrive++;
+ continue;
+ }
+ nDosDriveNo = HIWORD(GetItemLong (driveList, selDrive)) - 'A';
+ break;
+ }
+
+ if (LOWORD (GetItemLong (driveList, selDrive)) == 0xffff)
+ goto ret;
+
+ // First try user password then cached passwords
+ if ((mounted = MountVolume (hwndDlg, nDosDriveNo, szFileName, &VolumePassword, bCacheInDriver, bForceMount, &mountOptions, TRUE, FALSE)) > 0
+ || (mounted = MountVolume (hwndDlg, nDosDriveNo, szFileName, NULL, bCacheInDriver, bForceMount, &mountOptions, TRUE, FALSE)) > 0)
+ {
+ // A volume has been successfully mounted
+
+ ResetWrongPwdRetryCount ();
+
+ if (mounted == 2)
+ shared = TRUE;
+
+ LoadDriveLetters (driveList, (HIWORD (GetItemLong (GetDlgItem (hwndDlg, IDC_DRIVELIST), selDrive))));
+ selDrive++;
+
+ if (bExplore)
+ {
+ WaitCursor();
+ OpenVolumeExplorerWindow (nDosDriveNo);
+ NormalCursor();
+ }
+
+ if (bBeep)
+ MessageBeep (0xFFFFFFFF);
+
+ status = TRUE;
+
+ // Check for deprecated CBC mode
+ modeOfOperation = GetModeOfOperationByDriveNo (nDosDriveNo);
+ bCBCMode = (modeOfOperation == CBC || modeOfOperation == OUTER_CBC);
+
+ if (GetCipherBlockSizeByDriveNo(nDosDriveNo) == 64)
+ b64BitBlockCipher = TRUE;
+
+ mountedVolCount++;
+
+ // Skip other partitions of the disk if partition0 (whole disk) has been mounted
+ if (!device.IsPartition)
+ break;
+ }
+ }
+ }
+ }
+
+ if (mountedVolCount < 1)
+ {
+ // Failed to mount any volume
+
+ IncreaseWrongPwdRetryCount (1);
+
+ if (WrongPwdRetryCountOverLimit ()
+ && !mountOptions.UseBackupHeader
+ && !bHeaderBakRetry)
+ {
+ // Retry using embedded header backup (if any)
+ mountOptions.UseBackupHeader = TRUE;
+ bHeaderBakRetry = TRUE;
+ }
+ else if (bHeaderBakRetry)
+ {
+ mountOptions.UseBackupHeader = defaultMountOptions.UseBackupHeader;
+ bHeaderBakRetry = FALSE;
+ }
+
+ if (!Silent && !bHeaderBakRetry)
+ {
+ WCHAR szTmp[4096];
+
+ swprintf (szTmp, GetString (KeyFilesEnable || FirstCmdKeyFile ? "PASSWORD_OR_KEYFILE_WRONG_AUTOMOUNT" : "PASSWORD_WRONG_AUTOMOUNT"));
+ if (CheckCapsLock (hwndDlg, TRUE))
+ wcscat (szTmp, GetString ("PASSWORD_WRONG_CAPSLOCK_ON"));
+
+ MessageBoxW (hwndDlg, szTmp, lpszTitle, MB_ICONWARNING);
+ }
+ }
+ else if (bHeaderBakRetry)
+ {
+ // We have successfully mounted a volume using the header backup embedded in the volume (the header is damaged)
+ mountOptions.UseBackupHeader = defaultMountOptions.UseBackupHeader;
+ bHeaderBakRetry = FALSE;
+
+ if (!Silent)
+ Warning ("HEADER_DAMAGED_AUTO_USED_HEADER_BAK");
+ }
+
+ if (!bHeaderBakRetry)
+ {
+ burn (&VolumePassword, sizeof (VolumePassword));
+ burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword));
+ }
+
+ } while (bPasswordPrompt && mountedVolCount < 1);
+
+ /* One or more volumes successfully mounted */
+
+ ResetWrongPwdRetryCount ();
+
+ if (shared)
+ Warning ("DEVICE_IN_USE_INFO");
+
+ if (mountOptions.ProtectHiddenVolume)
+ {
+ if (mountedVolCount > 1)
+ Info ("HIDVOL_PROT_WARN_AFTER_MOUNT_PLURAL");
+ else if (mountedVolCount == 1)
+ Info ("HIDVOL_PROT_WARN_AFTER_MOUNT");
+ }
+
+ // Check for deprecated CBC mode
+ if (bCBCMode)
+ Warning("WARN_CBC_MODE");
+
+ // Check for deprecated 64-bit-block ciphers
+ if (b64BitBlockCipher)
+ Warning("WARN_64_BIT_BLOCK_CIPHER");
+
+ // Check for legacy non-ASCII passwords
+ if (!KeyFilesEnable
+ && !FirstCmdKeyFile
+ && mountedVolCount > 0
+ && !CheckPasswordCharEncoding (NULL, &VolumePassword))
+ Warning ("UNSUPPORTED_CHARS_IN_PWD_RECOM");
+
+ if (status && CloseSecurityTokenSessionsAfterMount)
+ SecurityToken::CloseAllSessions();
+
+ret:
+ MultipleMountOperationInProgress = FALSE;
+
+ burn (&VolumePassword, sizeof (VolumePassword));
+ burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword));
+
+ mountOptions.UseBackupHeader = defaultMountOptions.UseBackupHeader;
+
+ RestoreDefaultKeyFilesParam ();
+
+ if (UsePreferences)
+ bCacheInDriver = bCacheInDriverDefault;
+
+ EnableDisableButtons (hwndDlg);
+
+ NormalCursor();
+
+ return status;
+}
+
+static void ChangePassword (HWND hwndDlg)
+{
+ int result;
+
+ GetWindowText (GetDlgItem (hwndDlg, IDC_VOLUME), szFileName, sizeof (szFileName));
+ if (IsMountedVolume (szFileName))
+ {
+ Warning (pwdChangeDlgMode == PCDM_CHANGE_PKCS5_PRF ? "MOUNTED_NO_PKCS5_PRF_CHANGE" : "MOUNTED_NOPWCHANGE");
+ return;
+ }
+
+ if (!VolumePathExists (szFileName))
+ {
+ handleWin32Error (hwndDlg);
+ return;
+ }
+
+ bSysEncPwdChangeDlgMode = FALSE;
+
+ result = DialogBoxW (hInst, MAKEINTRESOURCEW (IDD_PASSWORDCHANGE_DLG), hwndDlg,
+ (DLGPROC) PasswordChangeDlgProc);
+
+ if (result == IDOK)
+ {
+ switch (pwdChangeDlgMode)
+ {
+ case PCDM_CHANGE_PKCS5_PRF:
+ Info ("PKCS5_PRF_CHANGED");
+ break;
+
+ case PCDM_ADD_REMOVE_VOL_KEYFILES:
+ case PCDM_REMOVE_ALL_KEYFILES_FROM_VOL:
+ Info ("KEYFILE_CHANGED");
+ break;
+
+ case PCDM_CHANGE_PASSWORD:
+ default:
+ Info ("PASSWORD_CHANGED");
+ }
+ }
+}
+
+// Change password of the system partition/drive
+static void ChangeSysEncPassword (HWND hwndDlg, BOOL bOnlyChangeKDF)
+{
+ try
+ {
+ BootEncStatus = BootEncObj->GetStatus();
+ }
+ catch (Exception &e)
+ {
+ e.Show (MainDlg);
+ }
+
+ if (!BootEncStatus.DriveEncrypted
+ && !BootEncStatus.DriveMounted
+ && !BootEncStatus.VolumeHeaderPresent
+ && !SysEncryptionOrDecryptionRequired ())
+ {
+ Warning ("SYS_DRIVE_NOT_ENCRYPTED");
+ return;
+ }
+
+ if (SysEncryptionOrDecryptionRequired ()
+ || BootEncStatus.SetupInProgress)
+ {
+ Warning ("SYSTEM_ENCRYPTION_NOT_COMPLETED");
+ return;
+ }
+
+ if (CreateSysEncMutex ()) // If no instance of the wizard is currently taking care of system encryption
+ {
+ sprintf (OrigKeyboardLayout, "%08X", (DWORD) GetKeyboardLayout (NULL) & 0xFFFF);
+
+ bSysEncPwdChangeDlgMode = TRUE;
+
+ if (bOnlyChangeKDF)
+ pwdChangeDlgMode = PCDM_CHANGE_PKCS5_PRF;
+ else
+ pwdChangeDlgMode = PCDM_CHANGE_PASSWORD;
+
+
+ INT_PTR result = DialogBoxW (hInst, MAKEINTRESOURCEW (IDD_PASSWORDCHANGE_DLG), hwndDlg, (DLGPROC) PasswordChangeDlgProc);
+
+ bSysEncPwdChangeDlgMode = FALSE;
+
+ if (bKeyboardLayoutChanged)
+ {
+ // Restore the original keyboard layout
+ if (LoadKeyboardLayout (OrigKeyboardLayout, KLF_ACTIVATE | KLF_SUBSTITUTE_OK) == NULL)
+ Warning ("CANNOT_RESTORE_KEYBOARD_LAYOUT");
+ else
+ bKeyboardLayoutChanged = FALSE;
+ }
+
+ bKeybLayoutAltKeyWarningShown = FALSE;
+
+ if (result == IDOK)
+ {
+ switch (pwdChangeDlgMode)
+ {
+ case PCDM_CHANGE_PKCS5_PRF:
+ Info ("PKCS5_PRF_CHANGED");
+
+ if (!IsHiddenOSRunning())
+ {
+ if (AskWarnYesNo ("SYS_HKD_ALGO_CHANGED_ASK_RESCUE_DISK") == IDYES)
+ CreateRescueDisk ();
+ }
+
+ break;
+
+ case PCDM_ADD_REMOVE_VOL_KEYFILES:
+ case PCDM_REMOVE_ALL_KEYFILES_FROM_VOL:
+ // NOP - Keyfiles are not supported for system encryption
+ break;
+
+ case PCDM_CHANGE_PASSWORD:
+ default:
+ Info ("PASSWORD_CHANGED");
+
+ if (!IsHiddenOSRunning())
+ {
+ if (AskWarnYesNo ("SYS_PASSWORD_CHANGED_ASK_RESCUE_DISK") == IDYES)
+ CreateRescueDisk ();
+ }
+ }
+ }
+
+ CloseSysEncMutex ();
+ }
+ else
+ Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE");
+}
+
+// Initiates or resumes encryption of the system partition/drive
+static void EncryptSystemDevice (void)
+{
+ try
+ {
+ BootEncStatus = BootEncObj->GetStatus();
+ }
+ catch (Exception &e)
+ {
+ e.Show (MainDlg);
+ }
+
+ if (!BootEncStatus.DriveEncrypted
+ && !BootEncStatus.DriveMounted
+ && !SysEncryptionOrDecryptionRequired ())
+ {
+ // System partition/drive is not encrypted (nothing to resume). Initiate the process.
+
+ if (!MutexExistsOnSystem (TC_MUTEX_NAME_SYSENC)) // If no instance of the wizard is currently taking care of system encryption
+ {
+ LaunchVolCreationWizard (MainDlg, "/sysenc");
+ }
+ else
+ Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE");
+
+ return;
+ }
+ else if (SysEncryptionOrDecryptionRequired ())
+ {
+ // System partition/drive encryption already initiated but is incomplete -- attempt to resume the process.
+ // Note that this also covers the pretest phase and paused decryption (reverses decrypting and starts encrypting)
+
+ if (!MutexExistsOnSystem (TC_MUTEX_NAME_SYSENC)) // If no instance of the wizard is currently taking care of system encryption
+ {
+ LaunchVolCreationWizard (MainDlg, "/sysenc");
+ }
+ else
+ Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE");
+ }
+ else if (SysDriveOrPartitionFullyEncrypted (FALSE))
+ {
+ // System partition/drive appears to be fully encrypted
+ Info ("SYS_PARTITION_OR_DRIVE_APPEARS_FULLY_ENCRYPTED");
+ return;
+ }
+}
+
+// Initiates decryption of the system partition/drive
+static void DecryptSystemDevice (void)
+{
+ try
+ {
+ BootEncStatus = BootEncObj->GetStatus();
+ }
+ catch (Exception &e)
+ {
+ e.Show (MainDlg);
+ }
+
+ if (!BootEncStatus.DriveEncrypted
+ && !BootEncStatus.DriveMounted
+ && !BootEncStatus.DeviceFilterActive
+ && !BootEncStatus.VolumeHeaderPresent
+ && !SysEncryptionOrDecryptionRequired ())
+ {
+ Warning ("SYS_DRIVE_NOT_ENCRYPTED");
+ return;
+ }
+
+ if (IsHiddenOSRunning())
+ {
+ Warning ("CANNOT_DECRYPT_HIDDEN_OS");
+ return;
+ }
+
+ if (AskNoYes ("CONFIRM_DECRYPT_SYS_DEVICE") == IDNO)
+ return;
+
+ if (AskWarnNoYes ("CONFIRM_DECRYPT_SYS_DEVICE_CAUTION") == IDNO)
+ return;
+
+ if (CreateSysEncMutex ()) // If no instance of the wizard is currently taking care of system encryption
+ {
+ try
+ {
+ // User-mode app may have crashed and its mutex may have gotten lost, so we need to check the driver status too
+ if (BootEncStatus.SetupInProgress)
+ {
+ int attempts = 20;
+
+ BootEncObj->AbortSetup ();
+ while (BootEncStatus.SetupInProgress && attempts > 0)
+ {
+ Sleep (100);
+ BootEncStatus = BootEncObj->GetStatus();
+ attempts--;
+ WaitCursor();
+ }
+ }
+ }
+ catch (Exception &e)
+ {
+ e.Show (MainDlg);
+ }
+ NormalCursor ();
+
+ if (BootEncStatus.SetupInProgress)
+ {
+ CloseSysEncMutex ();
+ Error ("SYS_ENCRYPTION_OR_DECRYPTION_IN_PROGRESS");
+ return;
+ }
+
+ CloseSysEncMutex ();
+ LaunchVolCreationWizard (MainDlg, "/dsysenc");
+ }
+ else
+ Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE");
+}
+
+// Initiates the process of creation of a hidden operating system
+static void CreateHiddenOS (void)
+{
+
+ // Display brief information as to what a hidden operating system is and what it's good for. This needs to be
+ // done, because if the system partition/drive is currently encrypted, the wizard will not display any
+ // such information, but will exit (displaying only an error meessage).
+ Info("HIDDEN_OS_PREINFO");
+
+ LaunchVolCreationWizard (MainDlg, "/isysenc");
+}
+
+// Blindly attempts (without any checks) to instruct the wizard to resume whatever system encryption process
+// had been interrupted or not started but scheduled or exptected to start.
+static void ResumeInterruptedSysEncProcess (void)
+{
+ if (!MutexExistsOnSystem (TC_MUTEX_NAME_SYSENC)) // If no instance of the wizard is currently taking care of system encryption
+ {
+ LaunchVolCreationWizard (MainDlg, "/csysenc");
+ }
+ else
+ Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE");
+}
+
+void CreateRescueDisk (void)
+{
+ try
+ {
+ BootEncStatus = BootEncObj->GetStatus();
+ }
+ catch (Exception &e)
+ {
+ e.Show (MainDlg);
+ }
+
+ if (IsHiddenOSRunning())
+ {
+ Warning ("CANNOT_CREATE_RESCUE_DISK_ON_HIDDEN_OS");
+ return;
+ }
+
+ if (!BootEncStatus.DriveEncrypted
+ && !BootEncStatus.DriveMounted
+ && !BootEncStatus.VolumeHeaderPresent
+ && !SysEncryptionOrDecryptionRequired ())
+ {
+ Warning ("SYS_DRIVE_NOT_ENCRYPTED");
+ return;
+ }
+
+ if (SysEncryptionOrDecryptionRequired ()
+ || BootEncStatus.SetupInProgress)
+ {
+ Warning ("SYSTEM_ENCRYPTION_NOT_COMPLETED");
+ return;
+ }
+
+ if (CreateSysEncMutex ()) // If no instance of the wizard is currently taking care of system encryption
+ {
+ try
+ {
+ wchar_t szTmp [8096];
+ char szRescueDiskISO [TC_MAX_PATH+1];
+
+ if (AskOkCancel ("RESCUE_DISK_NON_WIZARD_CREATION_SELECT_PATH") != IDOK)
+ {
+ CloseSysEncMutex ();
+ return;
+ }
+
+ char initialDir[MAX_PATH];
+ SHGetFolderPath (NULL, CSIDL_MYDOCUMENTS, NULL, 0, initialDir);
+
+ if (!BrowseFilesInDir (MainDlg, "OPEN_TITLE", initialDir, szRescueDiskISO, FALSE, TRUE, NULL, L"TrueCrypt Rescue Disk.iso", L"iso"))
+ {
+ CloseSysEncMutex ();
+ return;
+ }
+
+ WaitCursor();
+ BootEncObj->CreateRescueIsoImage (false, szRescueDiskISO);
+
+ _snwprintf (szTmp, sizeof szTmp / 2,
+ GetString (IsWindowsIsoBurnerAvailable() ? "RESCUE_DISK_NON_WIZARD_CREATION_WIN_ISOBURN" : "RESCUE_DISK_NON_WIZARD_CREATION_BURN"),
+ szRescueDiskISO);
+
+ if (IsWindowsIsoBurnerAvailable())
+ {
+ if (AskYesNoString (szTmp) == IDYES)
+ LaunchWindowsIsoBurner (MainDlg, szRescueDiskISO);
+ }
+ else
+ InfoDirect (szTmp);
+ }
+ catch (Exception &e)
+ {
+ e.Show (MainDlg);
+ Error ("ERROR_CREATING_RESCUE_DISK");
+ }
+ CloseSysEncMutex ();
+
+ NormalCursor ();
+ }
+ else
+ Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE");
+}
+
+static void VerifyRescueDisk (void)
+{
+ try
+ {
+ BootEncStatus = BootEncObj->GetStatus();
+ }
+ catch (Exception &e)
+ {
+ e.Show (MainDlg);
+ }
+
+ if (!BootEncStatus.DriveEncrypted
+ && !BootEncStatus.DriveMounted
+ && !BootEncStatus.VolumeHeaderPresent
+ && !SysEncryptionOrDecryptionRequired ())
+ {
+ Warning ("SYS_DRIVE_NOT_ENCRYPTED");
+ return;
+ }
+
+ if (SysEncryptionOrDecryptionRequired ()
+ || BootEncStatus.SetupInProgress)
+ {
+ Warning ("SYSTEM_ENCRYPTION_NOT_COMPLETED");
+ return;
+ }
+
+ if (CreateSysEncMutex ()) // If no instance of the wizard is currently taking care of system encryption
+ {
+ try
+ {
+ if (AskOkCancel ("RESCUE_DISK_NON_WIZARD_CHECK_INSERT") != IDOK)
+ {
+ CloseSysEncMutex ();
+ return;
+ }
+
+ // Create a temporary up-to-date rescue disk image in RAM (with it the CD/DVD content will be compared)
+ BootEncObj->CreateRescueIsoImage (false, "");
+
+ WaitCursor();
+ if (!BootEncObj->VerifyRescueDisk ())
+ Error ("RESCUE_DISK_NON_WIZARD_CHECK_FAILED");
+ else
+ Info ("RESCUE_DISK_NON_WIZARD_CHECK_PASSED");
+ }
+ catch (Exception &e)
+ {
+ e.Show (MainDlg);
+ Error ("RESCUE_DISK_NON_WIZARD_CHECK_FAILED");
+ }
+ CloseSysEncMutex ();
+
+ NormalCursor ();
+ }
+ else
+ Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE");
+}
+
+static void ShowSystemEncryptionStatus (void)
+{
+ try
+ {
+ BootEncStatus = BootEncObj->GetStatus();
+ }
+ catch (Exception &e)
+ {
+ e.Show (MainDlg);
+ }
+
+ if (GetAsyncKeyState (VK_SHIFT) < 0 && GetAsyncKeyState (VK_CONTROL) < 0)
+ {
+ // Ctrl+Shift held (for debugging purposes)
+
+ DebugMsgBox ("Debugging information for system encryption:\n\nDeviceFilterActive: %d\nBootLoaderVersion: %x\nSetupInProgress: %d\nSetupMode: %d\nVolumeHeaderPresent: %d\nDriveMounted: %d\nDriveEncrypted: %d\n"
+ "HiddenSystem: %d\nHiddenSystemPartitionStart: %I64d\n"
+ "ConfiguredEncryptedAreaStart: %I64d\nConfiguredEncryptedAreaEnd: %I64d\nEncryptedAreaStart: %I64d\nEncryptedAreaEnd: %I64d\nEncrypted: %I64d%%",
+ BootEncStatus.DeviceFilterActive,
+ BootEncStatus.BootLoaderVersion,
+ BootEncStatus.SetupInProgress,
+ BootEncStatus.SetupMode,
+ BootEncStatus.VolumeHeaderPresent,
+ BootEncStatus.DriveMounted,
+ BootEncStatus.DriveEncrypted,
+ BootEncStatus.HiddenSystem ? 1 : 0,
+ BootEncStatus.HiddenSystemPartitionStart,
+ BootEncStatus.ConfiguredEncryptedAreaStart,
+ BootEncStatus.ConfiguredEncryptedAreaEnd,
+ BootEncStatus.EncryptedAreaStart,
+ BootEncStatus.EncryptedAreaEnd,
+ !BootEncStatus.DriveEncrypted ? 0 : (BootEncStatus.EncryptedAreaEnd + 1 - BootEncStatus.EncryptedAreaStart) * 100I64 / (BootEncStatus.ConfiguredEncryptedAreaEnd + 1 - BootEncStatus.ConfiguredEncryptedAreaStart));
+ }
+
+ if (!BootEncStatus.DriveEncrypted && !BootEncStatus.DriveMounted)
+ {
+ Info ("SYS_DRIVE_NOT_ENCRYPTED");
+ return;
+ }
+
+ DialogBoxParamW (hInst,
+ MAKEINTRESOURCEW (IDD_VOLUME_PROPERTIES), MainDlg,
+ (DLGPROC) VolumePropertiesDlgProc, (LPARAM) TRUE);
+
+}
+
+static void ResumeInterruptedNonSysInplaceEncProcess (void)
+{
+ // IMPORTANT: This function must not check any config files! Otherwise, if a config file was lost or corrupt,
+ // the user would not be able resume encryption and the data on the volume would be inaccessible.
+
+ LaunchVolCreationWizard (MainDlg, "/zinplace");
+}
+
+static BOOL SelectContainer (HWND hwndDlg)
+{
+ if (BrowseFiles (hwndDlg, "OPEN_VOL_TITLE", szFileName, bHistory, FALSE, NULL) == FALSE)
+ return FALSE;
+
+ AddComboItem (GetDlgItem (hwndDlg, IDC_VOLUME), szFileName, bHistory);
+ EnableDisableButtons (hwndDlg);
+ SetFocus (GetDlgItem (hwndDlg, IDC_DRIVELIST));
+ return TRUE;
+}
+
+static BOOL SelectPartition (HWND hwndDlg)
+{
+ int nResult = DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_RAWDEVICES_DLG), hwndDlg,
+ (DLGPROC) RawDevicesDlgProc, (LPARAM) & szFileName[0]);
+ if (nResult == IDOK)
+ {
+ AddComboItem (GetDlgItem (hwndDlg, IDC_VOLUME), szFileName, bHistory);
+ EnableDisableButtons (hwndDlg);
+ SetFocus (GetDlgItem (hwndDlg, IDC_DRIVELIST));
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static void WipeCache (HWND hwndDlg, BOOL silent)
+{
+ DWORD dwResult;
+ BOOL bResult;
+
+ bResult = DeviceIoControl (hDriver, TC_IOCTL_WIPE_PASSWORD_CACHE, NULL, 0, NULL, 0, &dwResult, NULL);
+ if (hwndDlg == NULL)
+ return;
+
+ if (bResult == FALSE)
+ handleWin32Error (hwndDlg);
+ else
+ {
+ EnableDisableButtons (hwndDlg);
+
+ if (!silent)
+ InfoBalloon ("PASSWORD_CACHE_WIPED_SHORT", "PASSWORD_CACHE_WIPED");
+ }
+}
+
+static void Benchmark (HWND hwndDlg)
+{
+ DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_BENCHMARK_DLG), hwndDlg,
+ (DLGPROC) BenchmarkDlgProc, (LPARAM) NULL);
+}
+
+
+static BOOL CheckMountList ()
+{
+ MOUNT_LIST_STRUCT current;
+ static BootEncryptionStatus newBootEncStatus;
+ static BOOL lastbUseDifferentTrayIconIfVolMounted = bUseDifferentTrayIconIfVolMounted;
+ static uint32 lastUlMountedDrives = 0;
+
+ GetMountList (&current);
+
+ if ((current.ulMountedDrives != lastUlMountedDrives || bUseDifferentTrayIconIfVolMounted != lastbUseDifferentTrayIconIfVolMounted)
+ && TaskBarIconMutex != NULL)
+ {
+ lastUlMountedDrives = current.ulMountedDrives;
+ lastbUseDifferentTrayIconIfVolMounted = bUseDifferentTrayIconIfVolMounted;
+
+ TaskBarIconChange (MainDlg, current.ulMountedDrives != 0 && bUseDifferentTrayIconIfVolMounted ? IDI_TRUECRYPT_MOUNTED_ICON : IDI_TRUECRYPT_ICON);
+ }
+
+ if (LastKnownLogicalDrives != GetLogicalDrives()
+ || memcmp (&LastKnownMountList, &current, sizeof (current)) != 0)
+ {
+ char selDrive;
+
+ WaitCursor ();
+ LastKnownMountList = current;
+
+ selDrive = (char) HIWORD (GetSelectedLong (GetDlgItem (MainDlg, IDC_DRIVELIST)));
+ LoadDriveLetters (GetDlgItem (MainDlg, IDC_DRIVELIST), 0);
+ NormalCursor ();
+
+ if (selDrive != -1 && (current.ulMountedDrives & (1 << (selDrive - 'A'))) == 0 && !IsDriveAvailable (selDrive - 'A'))
+ {
+ nSelectedDriveIndex = -1;
+ return FALSE;
+ }
+
+ if (selDrive != -1)
+ SelectItem (GetDlgItem (MainDlg, IDC_DRIVELIST),selDrive);
+ }
+
+ try
+ {
+ newBootEncStatus = BootEncObj->GetStatus();
+
+ if (newBootEncStatus.SetupInProgress != RecentBootEncStatus.SetupInProgress
+ || newBootEncStatus.EncryptedAreaEnd != RecentBootEncStatus.EncryptedAreaEnd
+ || newBootEncStatus.DriveEncrypted != RecentBootEncStatus.DriveEncrypted
+ || newBootEncStatus.DriveMounted != RecentBootEncStatus.DriveMounted
+ || newBootEncStatus.SetupMode != RecentBootEncStatus.SetupMode
+ || newBootEncStatus.EncryptedAreaStart != RecentBootEncStatus.EncryptedAreaStart)
+ {
+ /* System encryption status change */
+
+ char selDrive;
+ int driveLetterToRefresh;
+
+ if (RecentBootEncStatus.DriveMounted == newBootEncStatus.DriveMounted) // If an icon (and whole new line) for a system device isn't to be added/removed
+ {
+ // Partial refresh
+ if (WholeSysDriveEncryption (TRUE))
+ {
+ // System drive (not just partition)
+ driveLetterToRefresh = ENC_SYSDRIVE_PSEUDO_DRIVE_LETTER;
+ }
+ else
+ {
+ // System partition
+ driveLetterToRefresh = GetSystemDriveLetter ();
+ }
+ }
+ else
+ {
+ // Full rebuild of the mount list
+ driveLetterToRefresh = 0;
+ }
+
+ selDrive = (char) HIWORD (GetSelectedLong (GetDlgItem (MainDlg, IDC_DRIVELIST)));
+ LoadDriveLetters (GetDlgItem (MainDlg, IDC_DRIVELIST), driveLetterToRefresh);
+
+ RecentBootEncStatus = newBootEncStatus;
+
+ if (selDrive != -1 && (current.ulMountedDrives & (1 << (selDrive - 'A'))) == 0 && !IsDriveAvailable (selDrive - 'A'))
+ {
+ nSelectedDriveIndex = -1;
+ }
+
+ if (selDrive != -1)
+ {
+ SelectItem (GetDlgItem (MainDlg, IDC_DRIVELIST),selDrive);
+ }
+ }
+
+ /* Miscellaneous notifications */
+
+ // Hibernation prevention notifications
+ if (newBootEncStatus.HibernationPreventionCount != RecentBootEncStatus.HibernationPreventionCount
+ && !bHibernationPreventionNotified)
+ {
+ bHibernationPreventionNotified = TRUE;
+ RecentBootEncStatus.HibernationPreventionCount = newBootEncStatus.HibernationPreventionCount;
+
+ if (IsHiddenOSRunning() && BootEncObj->GetSystemDriveConfiguration().ExtraBootPartitionPresent)
+ WarningTopMost ("HIDDEN_OS_HIBERNATION_PREVENTED");
+ else
+ WarningTopMost ("SYS_ENC_HIBERNATION_PREVENTED");
+ }
+
+ // Write mode prevention (hidden OS leak protection)
+ if (IsHiddenOSRunning())
+ {
+ if (newBootEncStatus.HiddenSysLeakProtectionCount != RecentBootEncStatus.HiddenSysLeakProtectionCount
+ && !bHiddenSysLeakProtNotifiedDuringSession)
+ {
+ bHiddenSysLeakProtNotifiedDuringSession = TRUE;
+
+ switch (HiddenSysLeakProtectionNotificationStatus)
+ {
+ case TC_HIDDEN_OS_READ_ONLY_NOTIF_MODE_COMPACT:
+ {
+ char *tmp[] = {0, "HIDDEN_OS_WRITE_PROTECTION_BRIEF_INFO", "SHOW_MORE_INFORMATION", "DO_NOT_SHOW_THIS_AGAIN", "CONTINUE", 0};
+ switch (AskMultiChoice ((void **) tmp, FALSE))
+ {
+ case 1:
+ InfoDirect ((wstring (GetString ("HIDDEN_OS_WRITE_PROTECTION_BRIEF_INFO"))
+ + L"\n\n"
+ + GetString ("HIDDEN_OS_WRITE_PROTECTION_EXPLANATION")
+ + L"\n\n\n"
+ + GetString ("DECOY_TO_HIDDEN_OS_DATA_TRANSFER_HOWTO")).c_str());
+ break;
+
+ case 2:
+ // No more warnings will be shown
+ if (ConfigBuffer == NULL)
+ {
+ // We need to load the config file because it is not done automatically when
+ // launched from the sys startup sequence (and SaveSettings would start by _loading_
+ // the settings to cache).
+ LoadSettings (MainDlg);
+ }
+ HiddenSysLeakProtectionNotificationStatus = TC_HIDDEN_OS_READ_ONLY_NOTIF_MODE_DISABLED;
+ SaveSettings (MainDlg);
+ break;
+
+ default:
+ // NOP
+ break;
+ }
+ }
+ break;
+
+ case TC_HIDDEN_OS_READ_ONLY_NOTIF_MODE_DISABLED:
+ // NOP
+ break;
+
+ case TC_HIDDEN_OS_READ_ONLY_NOTIF_MODE_NONE:
+ default:
+ {
+ // First time warning -- include technical explanation
+ InfoDirect ((wstring (GetString ("HIDDEN_OS_WRITE_PROTECTION_BRIEF_INFO"))
+ + L"\n\n"
+ + GetString ("HIDDEN_OS_WRITE_PROTECTION_EXPLANATION")
+ + L"\n\n\n"
+ + GetString ("DECOY_TO_HIDDEN_OS_DATA_TRANSFER_HOWTO")).c_str());
+
+ // Further warnings will not include the explanation (and will allow disabling)
+
+ if (ConfigBuffer == NULL)
+ {
+ // We need to load the config file because it is not done automatically when
+ // launched from the sys startup sequence (and SaveSettings would start by _loading_
+ // the settings to cache).
+ LoadSettings (MainDlg);
+ }
+ HiddenSysLeakProtectionNotificationStatus = TC_HIDDEN_OS_READ_ONLY_NOTIF_MODE_COMPACT;
+ SaveSettings (MainDlg);
+ }
+ break;
+ }
+ }
+ }
+ }
+ catch (...)
+ {
+ // NOP
+ }
+
+ return TRUE;
+}
+
+
+/* Except in response to the WM_INITDIALOG and WM_ENDSESSION messages, the dialog box procedure
+ should return nonzero if it processes a message, and zero if it does not. */
+BOOL CALLBACK MainDialogProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+ static UINT taskBarCreatedMsg;
+ WORD lw = LOWORD (wParam);
+ WORD hw = HIWORD (wParam);
+ DWORD mPos;
+
+ switch (uMsg)
+ {
+ case WM_HOTKEY:
+
+ HandleHotKey (hwndDlg, wParam);
+ return 1;
+
+ case WM_INITDIALOG:
+ {
+ int exitCode = 0;
+ int modeOfOperation;
+
+ MainDlg = hwndDlg;
+
+ if (IsTrueCryptInstallerRunning())
+ AbortProcess ("TC_INSTALLER_IS_RUNNING");
+
+ // Set critical default options in case UsePreferences is false
+ bPreserveTimestamp = defaultMountOptions.PreserveTimestamp = TRUE;
+
+ ResetWrongPwdRetryCount ();
+
+ ExtractCommandLine (hwndDlg, (char *) lParam);
+
+ try
+ {
+ BootEncStatus = BootEncObj->GetStatus();
+ RecentBootEncStatus = BootEncStatus;
+ }
+ catch (...)
+ {
+ // NOP
+ }
+
+ if (UsePreferences)
+ {
+ // General preferences
+ LoadSettings (hwndDlg);
+
+ // Keyfiles
+ LoadDefaultKeyFilesParam ();
+ RestoreDefaultKeyFilesParam ();
+ }
+
+ if (ComServerMode)
+ {
+ InitDialog (hwndDlg);
+
+ if (!ComServerMain ())
+ {
+ handleWin32Error (hwndDlg);
+ exit (1);
+ }
+ exit (0);
+ }
+
+ if (CmdMountOptionsValid)
+ mountOptions = CmdMountOptions;
+
+ InitMainDialog (hwndDlg);
+
+ try
+ {
+ if (IsHiddenOSRunning())
+ {
+ if (BootEncObj->GetInstalledBootLoaderVersion() > VERSION_NUM)
+ Warning ("UPDATE_TC_IN_HIDDEN_OS_TOO");
+ }
+ else if (SysDriveOrPartitionFullyEncrypted (TRUE)
+ && BootEncObj->GetInstalledBootLoaderVersion() != VERSION_NUM)
+ {
+ Warning ("BOOT_LOADER_VERSION_DIFFERENT_FROM_DRIVER_VERSION");
+ }
+ }
+ catch (...) { }
+
+ // Automount
+ if (bAuto || (Quit && szFileName[0] != 0))
+ {
+ // No drive letter specified on command line
+ if (commandLineDrive == 0)
+ szDriveLetter[0] = (char) GetFirstAvailableDrive () + 'A';
+
+ if (bAutoMountDevices)
+ {
+ defaultMountOptions = mountOptions;
+ if (FirstCmdKeyFile)
+ {
+ KeyFilesEnable = defaultKeyFilesParam.EnableKeyFiles = TRUE;
+ FirstKeyFile = KeyFileCloneAll (FirstCmdKeyFile);
+ defaultKeyFilesParam.FirstKeyFile = KeyFileCloneAll (FirstCmdKeyFile);
+ }
+
+ if (!MountAllDevices (hwndDlg, !Silent && !CmdVolumePasswordValid && IsPasswordCacheEmpty()))
+ exitCode = 1;
+ }
+
+ if (bAutoMountFavorites)
+ {
+ defaultMountOptions = mountOptions;
+ if (FirstCmdKeyFile)
+ {
+ KeyFilesEnable = defaultKeyFilesParam.EnableKeyFiles = TRUE;
+ FirstKeyFile = KeyFileCloneAll (FirstCmdKeyFile);
+ defaultKeyFilesParam.FirstKeyFile = KeyFileCloneAll (FirstCmdKeyFile);
+ }
+
+ if (!MountFavoriteVolumes (FALSE, LogOn))
+ exitCode = 1;
+ }
+
+ if (szFileName[0] != 0 && !IsMountedVolume (szFileName))
+ {
+ BOOL mounted;
+
+ // Cached password
+ mounted = MountVolume (hwndDlg, szDriveLetter[0] - 'A', szFileName, NULL, bCacheInDriver, bForceMount, &mountOptions, Silent, FALSE);
+
+ // Command line password or keyfiles
+ if (!mounted && (CmdVolumePassword.Length != 0 || FirstCmdKeyFile))
+ {
+ BOOL reportBadPasswd = CmdVolumePassword.Length > 0;
+
+ if (FirstCmdKeyFile)
+ KeyFilesApply (&CmdVolumePassword, FirstCmdKeyFile);
+
+ mounted = MountVolume (hwndDlg, szDriveLetter[0] - 'A',
+ szFileName, &CmdVolumePassword, bCacheInDriver, bForceMount,
+ &mountOptions, Silent, reportBadPasswd);
+
+ burn (&CmdVolumePassword, sizeof (CmdVolumePassword));
+ }
+
+ if (FirstCmdKeyFile)
+ {
+ FirstKeyFile = FirstCmdKeyFile;
+ KeyFilesEnable = TRUE;
+ }
+
+ // Ask user for password
+ while (!mounted && !Silent)
+ {
+ VolumePassword.Length = 0;
+
+ strcpy (PasswordDlgVolume, szFileName);
+ if (!AskVolumePassword (hwndDlg, &VolumePassword, NULL, TRUE))
+ break;
+
+ WaitCursor ();
+
+ if (KeyFilesEnable && FirstKeyFile)
+ KeyFilesApply (&VolumePassword, FirstKeyFile);
+
+ mounted = MountVolume (hwndDlg, szDriveLetter[0] - 'A', szFileName, &VolumePassword, bCacheInDriver, bForceMount, &mountOptions, FALSE, TRUE);
+
+ burn (&VolumePassword, sizeof (VolumePassword));
+ burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword));
+
+ NormalCursor ();
+ }
+
+ if (UsePreferences)
+ {
+ RestoreDefaultKeyFilesParam ();
+ bCacheInDriver = bCacheInDriverDefault;
+ }
+
+ if (mounted > 0)
+ {
+ if (bBeep)
+ MessageBeep (0xFFFFFFFF);
+
+ if (bExplore)
+ OpenVolumeExplorerWindow (szDriveLetter[0] - 'A');
+
+ RefreshMainDlg(hwndDlg);
+
+ if(!Silent)
+ {
+ // Check for deprecated CBC mode
+ modeOfOperation = GetModeOfOperationByDriveNo (szDriveLetter[0] - 'A');
+ if (modeOfOperation == CBC || modeOfOperation == OUTER_CBC)
+ Warning("WARN_CBC_MODE");
+
+ // Check for deprecated 64-bit-block ciphers
+ if (GetCipherBlockSizeByDriveNo (szDriveLetter[0] - 'A') == 64)
+ Warning("WARN_64_BIT_BLOCK_CIPHER");
+
+ // Check for problematic file extensions (exe, dll, sys)
+ if (CheckFileExtension (szFileName))
+ Warning ("EXE_FILE_EXTENSION_MOUNT_WARNING");
+ }
+ }
+ else
+ exitCode = 1;
+ }
+ else if (bExplore && GetMountedVolumeDriveNo (szFileName) != -1)
+ OpenVolumeExplorerWindow (GetMountedVolumeDriveNo (szFileName));
+ else if (szFileName[0] != 0 && IsMountedVolume (szFileName))
+ Warning ("VOL_ALREADY_MOUNTED");
+
+ if (!Quit)
+ RefreshMainDlg(hwndDlg);
+ }
+
+ // Wipe cache
+ if (bWipe)
+ WipeCache (hwndDlg, Silent);
+
+ // Wipe command line password
+ if (CmdVolumePassword.Length != 0)
+ {
+ burn (&CmdVolumePassword, sizeof (CmdVolumePassword));
+ CmdVolumePassword.Length = 0;
+ }
+
+ // Wipe command line keyfiles
+ if (FirstCmdKeyFile)
+ {
+ if (defaultKeyFilesParam.FirstKeyFile)
+ KeyFileRemoveAll (&defaultKeyFilesParam.FirstKeyFile);
+
+ defaultKeyFilesParam.EnableKeyFiles = FALSE;
+
+ if (!Quit)
+ {
+ LoadSettings (hwndDlg);
+ LoadDefaultKeyFilesParam ();
+ RestoreDefaultKeyFilesParam ();
+ }
+ }
+
+ // Dismount
+ if (cmdUnmountDrive > 0)
+ {
+ MOUNT_LIST_STRUCT mountList;
+ DWORD bytesReturned;
+
+ if (DeviceIoControl (hDriver, TC_IOCTL_GET_MOUNTED_VOLUMES, NULL, 0, &mountList, sizeof (mountList), &bytesReturned, NULL)
+ && (mountList.ulMountedDrives & (1 << cmdUnmountDrive)) == 0)
+ {
+ Error ("NO_VOLUME_MOUNTED_TO_DRIVE");
+ exitCode = 1;
+ }
+ else if (!Dismount (hwndDlg, cmdUnmountDrive))
+ exitCode = 1;
+ }
+ else if (cmdUnmountDrive == -1)
+ {
+ if (!DismountAll (hwndDlg, bForceUnmount, !Silent, UNMOUNT_MAX_AUTO_RETRIES, UNMOUNT_AUTO_RETRY_DELAY))
+ exitCode = 1;
+ }
+
+ // TaskBar icon
+ if (bEnableBkgTask)
+ TaskBarIconAdd (hwndDlg);
+
+ // Quit
+ if (Quit)
+ {
+ if (TaskBarIconMutex == NULL)
+ exit (exitCode);
+
+ MainWindowHidden = TRUE;
+
+ LoadSettings (hwndDlg);
+ LoadDefaultKeyFilesParam ();
+ RestoreDefaultKeyFilesParam ();
+
+ if (!bEnableBkgTask)
+ {
+ if (TaskBarIconMutex)
+ TaskBarIconRemove (hwndDlg);
+ exit (exitCode);
+ }
+ }
+
+ // No command line arguments or only /volume => bring active instance
+ // to foreground if available
+ if (NoCmdLineArgs == 0 || (CmdLineVolumeSpecified && NoCmdLineArgs <= 2))
+ {
+ HWND h = hwndDlg;
+ EnumWindows (FindTCWindowEnum, (LPARAM) &h);
+
+ if (h != hwndDlg
+ && (!IsAdmin() || (GetWindowLongPtr (h, DWLP_USER) & TC_MAIN_WINDOW_FLAG_ADMIN_PRIVILEGES) != 0))
+ {
+ if (CmdLineVolumeSpecified)
+ {
+ COPYDATASTRUCT cd;
+ memcpy (&cd.dwData, WM_COPY_SET_VOLUME_NAME, 4);
+ cd.lpData = szFileName;
+ cd.cbData = strlen (szFileName) + 1;
+
+ SendMessage (h, WM_COPYDATA, (WPARAM)hwndDlg, (LPARAM)&cd);
+ }
+
+ SendMessage (h, TC_APPMSG_MOUNT_SHOW_WINDOW, 0, 0);
+
+ ShowWindow (h, SW_SHOW);
+ SetForegroundWindow (h);
+
+ if (TaskBarIconMutex == NULL)
+ exit (0);
+ }
+ }
+
+ HookMouseWheel (hwndDlg, IDC_VOLUME);
+
+ // Register hot keys
+ if (!RegisterAllHotkeys (hwndDlg, Hotkeys)
+ && TaskBarIconMutex != NULL) // Warn only if we are the first instance of TrueCrypt
+ Warning("HOTKEY_REGISTRATION_ERROR");
+
+ Silent = FALSE;
+
+ GetMountList (&LastKnownMountList);
+ SetTimer (hwndDlg, TIMER_ID_MAIN, TIMER_INTERVAL_MAIN, NULL);
+
+ taskBarCreatedMsg = RegisterWindowMessage ("TaskbarCreated");
+
+ SetFocus (GetDlgItem (hwndDlg, IDC_DRIVELIST));
+
+ /* Check system encryption status */
+
+ if (!Quit) // Do not care about system encryption or in-place encryption if we were launched from the system startup sequence (the wizard was added to it too).
+ {
+ if (SysEncryptionOrDecryptionRequired ())
+ {
+ if (!MutexExistsOnSystem (TC_MUTEX_NAME_SYSENC)) // If no instance of the wizard is currently taking care of system encryption
+ {
+ // We shouldn't block the mutex at this point
+
+ if (SystemEncryptionStatus == SYSENC_STATUS_PRETEST
+ || AskWarnYesNo ("SYSTEM_ENCRYPTION_RESUME_PROMPT") == IDYES)
+ {
+ // The wizard was not launched during the system startup seq, or the user may have forgotten
+ // to resume the encryption/decryption process.
+
+
+ LaunchVolCreationWizard (hwndDlg, "/csysenc");
+ }
+ }
+ }
+
+ if (bInPlaceEncNonSysPending && !NonSysInplaceEncInProgressElsewhere())
+ {
+ if (AskNonSysInPlaceEncryptionResume() == IDYES)
+ ResumeInterruptedNonSysInplaceEncProcess ();
+ }
+ }
+
+ if (!DisableSystemCrashDetection
+ && IsOSAtLeast (WIN_7))
+ {
+ // Auto-detect a system crash
+
+ const int detectionPeriodInMonthsSinceReleaseDate = 2;
+ int maxYear = TC_RELEASE_DATE_YEAR;
+ int maxMonth = TC_RELEASE_DATE_MONTH + detectionPeriodInMonthsSinceReleaseDate;
+ if (maxMonth > 12)
+ {
+ ++maxYear;
+ maxMonth -= 12;
+ }
+
+ SYSTEMTIME systemTime;
+ GetSystemTime (&systemTime);
+
+ if (systemTime.wYear >= TC_RELEASE_DATE_YEAR
+ && !(systemTime.wYear == TC_RELEASE_DATE_YEAR && systemTime.wMonth < TC_RELEASE_DATE_MONTH)
+ && systemTime.wYear <= maxYear
+ && !(systemTime.wYear == maxYear && systemTime.wMonth > maxMonth))
+ {
+ char winDir[MAX_PATH] = { 0 };
+ GetWindowsDirectory (winDir, sizeof (winDir));
+
+ WIN32_FIND_DATA findData;
+ HANDLE find = FindFirstFile ((string (winDir) + "\\MEMORY.DMP").c_str(), &findData);
+
+ if (find != INVALID_HANDLE_VALUE)
+ {
+ SYSTEMTIME systemTime;
+ FILETIME ft;
+ GetSystemTime (&systemTime);
+ SystemTimeToFileTime (&systemTime, &ft);
+
+ ULARGE_INTEGER sysTime, fileTime;
+ sysTime.HighPart = ft.dwHighDateTime;
+ sysTime.LowPart = ft.dwLowDateTime;
+ fileTime.HighPart = findData.ftLastWriteTime.dwHighDateTime;
+ fileTime.LowPart = findData.ftLastWriteTime.dwLowDateTime;
+
+ // Memory dump must not be older than 10 minutes
+ if (sysTime.QuadPart - fileTime.QuadPart < 10I64 * 1000 * 1000 * 60 * 10)
+ SystemCrashDetected = TRUE;
+
+ FindClose (find);
+ }
+ }
+ }
+
+ DoPostInstallTasks ();
+ ResetCurrentDirectory ();
+ }
+ return 0;
+
+ case WM_MOUSEWHEEL:
+ return HandleDriveListMouseWheelEvent (uMsg, wParam, lParam, FALSE);
+
+ case WM_WINDOWPOSCHANGING:
+ if (MainWindowHidden)
+ {
+ // Prevent window from being shown
+ PWINDOWPOS wp = (PWINDOWPOS)lParam;
+ wp->flags &= ~SWP_SHOWWINDOW;
+ return 0;
+ }
+ return 1;
+
+ case WM_SYSCOMMAND:
+ if (lw == IDC_ABOUT)
+ {
+ DialogBoxW (hInst, MAKEINTRESOURCEW (IDD_ABOUT_DLG), hwndDlg, (DLGPROC) AboutDlgProc);
+ return 1;
+ }
+ return 0;
+
+ case WM_HELP:
+ OpenPageHelp (hwndDlg, 0);
+ return 1;
+
+ case WM_ENDSESSION:
+ if (TaskBarIconMutex != NULL)
+ {
+ if (bDismountOnLogOff)
+ {
+ // Auto-dismount when user logs off
+ DWORD dwResult;
+
+ if (bWipeCacheOnAutoDismount)
+ DeviceIoControl (hDriver, TC_IOCTL_WIPE_PASSWORD_CACHE, NULL, 0, NULL, 0, &dwResult, NULL);
+
+ DismountAll (hwndDlg, bForceAutoDismount, FALSE, 1, 0);
+ }
+
+ TaskBarIconRemove (hwndDlg);
+ }
+ EndMainDlg (hwndDlg);
+ localcleanup ();
+ return 0;
+
+ case WM_POWERBROADCAST:
+ if (wParam == PBT_APMSUSPEND
+ && TaskBarIconMutex != NULL && bDismountOnPowerSaving)
+ {
+ // Auto-dismount when entering power-saving mode
+ DWORD dwResult;
+
+ if (bWipeCacheOnAutoDismount)
+ {
+ DeviceIoControl (hDriver, TC_IOCTL_WIPE_PASSWORD_CACHE, NULL, 0, NULL, 0, &dwResult, NULL);
+ SecurityToken::CloseAllSessions();
+ }
+
+ DismountAll (hwndDlg, bForceAutoDismount, TRUE, UNMOUNT_MAX_AUTO_RETRIES, UNMOUNT_AUTO_RETRY_DELAY);
+ }
+ return 0;
+
+ case WM_TIMER:
+ {
+ // Check mount list and update GUI if needed
+ CheckMountList ();
+
+ // Cache status
+ if (IsPasswordCacheEmpty() == IsWindowEnabled (GetDlgItem (hwndDlg, IDC_WIPE_CACHE)))
+ EnableWindow (GetDlgItem (hwndDlg, IDC_WIPE_CACHE), !IsPasswordCacheEmpty());
+
+ // Check driver warning flags
+ DWORD bytesOut;
+ GetWarningFlagsRequest warnings;
+ if (DeviceIoControl (hDriver, TC_IOCTL_GET_WARNING_FLAGS, NULL, 0, &warnings, sizeof (warnings), &bytesOut, NULL))
+ {
+ if (warnings.SystemFavoriteVolumeDirty)
+ WarningTopMost ("SYS_FAVORITE_VOLUME_DIRTY");
+
+ if (warnings.PagingFileCreationPrevented)
+ WarningTopMost ("PAGING_FILE_CREATION_PREVENTED");
+ }
+
+ if (TaskBarIconMutex != NULL)
+ {
+ // Handle system crash
+ static BOOL systemCrashHandlerLocked = FALSE;
+ if (SystemCrashDetected && !systemCrashHandlerLocked)
+ {
+ systemCrashHandlerLocked = TRUE;
+
+ SetForegroundWindow (hwndDlg);
+ MainWindowHidden = FALSE;
+ ShowWindow (hwndDlg, SW_SHOW);
+ ShowWindow (hwndDlg, SW_RESTORE);
+
+ if (AskYesNoTopmost ("SYSTEM_CRASHED_ASK_REPORT") == IDYES)
+ {
+ if (!IsAdmin() && IsUacSupported())
+ UacAnalyzeKernelMiniDump (hwndDlg);
+ else
+ AnalyzeKernelMiniDump (hwndDlg);
+ }
+ else if (AskYesNoTopmost ("ASK_KEEP_DETECTING_SYSTEM_CRASH") == IDNO)
+ {
+ DisableSystemCrashDetection = TRUE;
+ SaveSettings (hwndDlg);
+ }
+ }
+
+ // Idle auto-dismount
+ if (MaxVolumeIdleTime > 0)
+ DismountIdleVolumes ();
+
+ // Screen saver auto-dismount
+ if (bDismountOnScreenSaver)
+ {
+ static BOOL previousState = FALSE;
+ BOOL running = FALSE;
+ SystemParametersInfo (SPI_GETSCREENSAVERRUNNING, 0, &running, 0);
+
+ if (running && !previousState)
+ {
+ DWORD dwResult;
+ previousState = TRUE;
+
+ if (bWipeCacheOnAutoDismount)
+ {
+ DeviceIoControl (hDriver, TC_IOCTL_WIPE_PASSWORD_CACHE, NULL, 0, NULL, 0, &dwResult, NULL);
+ SecurityToken::CloseAllSessions();
+ }
+
+ DismountAll (hwndDlg, bForceAutoDismount, FALSE, UNMOUNT_MAX_AUTO_RETRIES, UNMOUNT_AUTO_RETRY_DELAY);
+ }
+ else
+ {
+ previousState = running;
+ }
+ }
+
+ // Auto-mount favorite volumes on arrival
+#if TIMER_INTERVAL_MAIN != 500
+#error TIMER_INTERVAL_MAIN != 500
+#endif
+ static int favoritesAutoMountTimerDivisor = 0;
+ if ((++favoritesAutoMountTimerDivisor & 1) && !FavoritesOnArrivalMountRequired.empty())
+ {
+ static bool reentry = false;
+ if (reentry)
+ break;
+
+ reentry = true;
+
+ foreach (FavoriteVolume favorite, FavoritesOnArrivalMountRequired)
+ {
+ if (!favorite.VolumePathId.empty())
+ {
+ if (IsMountedVolume (favorite.Path.c_str()))
+ continue;
+
+ char volDevPath[TC_MAX_PATH];
+ if (QueryDosDevice (favorite.VolumePathId.substr (4, favorite.VolumePathId.size() - 5).c_str(), volDevPath, TC_MAX_PATH) == 0)
+ continue;
+
+ favorite.DisconnectedDevice = false;
+ }
+ else if (favorite.Path.find ("\\\\?\\Volume{") == 0)
+ {
+ string resolvedPath = VolumeGuidPathToDevicePath (favorite.Path);
+ if (resolvedPath.empty())
+ continue;
+
+ favorite.DisconnectedDevice = false;
+ favorite.VolumePathId = favorite.Path;
+ favorite.Path = resolvedPath;
+ }
+
+ if (IsMountedVolume (favorite.Path.c_str()))
+ continue;
+
+ if (!IsVolumeDeviceHosted (favorite.Path.c_str()))
+ {
+ if (!FileExists (favorite.Path.c_str()))
+ continue;
+ }
+ else if (favorite.VolumePathId.empty())
+ continue;
+
+ bool mountedAndNotDisconnected = false;
+ foreach (FavoriteVolume mountedFavorite, FavoritesMountedOnArrivalStillConnected)
+ {
+ if (favorite.Path == mountedFavorite.Path)
+ {
+ mountedAndNotDisconnected = true;
+ break;
+ }
+ }
+
+ if (!mountedAndNotDisconnected)
+ {
+ FavoriteMountOnArrivalInProgress = TRUE;
+ MountFavoriteVolumes (FALSE, FALSE, FALSE, favorite);
+ FavoriteMountOnArrivalInProgress = FALSE;
+
+ FavoritesMountedOnArrivalStillConnected.push_back (favorite);
+ }
+ }
+
+ bool deleted;
+ for (list <FavoriteVolume>::iterator favorite = FavoritesMountedOnArrivalStillConnected.begin();
+ favorite != FavoritesMountedOnArrivalStillConnected.end();
+ deleted ? favorite : ++favorite)
+ {
+ deleted = false;
+
+ if (IsMountedVolume (favorite->Path.c_str()))
+ continue;
+
+ if (!IsVolumeDeviceHosted (favorite->Path.c_str()))
+ {
+ if (FileExists (favorite->Path.c_str()))
+ continue;
+ }
+
+ char volDevPath[TC_MAX_PATH];
+ if (favorite->VolumePathId.size() > 5
+ && QueryDosDevice (favorite->VolumePathId.substr (4, favorite->VolumePathId.size() - 5).c_str(), volDevPath, TC_MAX_PATH) != 0)
+ {
+ continue;
+ }
+
+ favorite = FavoritesMountedOnArrivalStillConnected.erase (favorite);
+ deleted = true;
+ }
+
+ reentry = false;
+ }
+ }
+
+ // Exit background process in non-install mode or if no volume mounted
+ // and no other instance active
+ if (LastKnownMountList.ulMountedDrives == 0
+ && MainWindowHidden
+#ifndef _DEBUG
+ && (bCloseBkgTaskWhenNoVolumes || IsNonInstallMode ())
+ && !SysEncDeviceActive (TRUE)
+#endif
+ && GetDriverRefCount () < 2)
+ {
+ TaskBarIconRemove (hwndDlg);
+ EndMainDlg (hwndDlg);
+ }
+ }
+ return 1;
+
+ case TC_APPMSG_TASKBAR_ICON:
+ {
+ switch (lParam)
+ {
+ case WM_LBUTTONDOWN:
+ SetForegroundWindow (hwndDlg);
+ MainWindowHidden = FALSE;
+ ShowWindow (hwndDlg, SW_SHOW);
+ ShowWindow (hwndDlg, SW_RESTORE);
+ return 1;
+
+ case WM_RBUTTONUP:
+ {
+ POINT pos;
+ HMENU popup = CreatePopupMenu ();
+ int sel, i, n;
+
+ if (MainWindowHidden)
+ {
+ AppendMenuW (popup, MF_STRING, IDM_SHOW_HIDE, GetString ("SHOW_TC"));
+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);
+ }
+ else if (bEnableBkgTask
+ && (!(LastKnownMountList.ulMountedDrives == 0
+ && (bCloseBkgTaskWhenNoVolumes || IsNonInstallMode ())
+ && !SysEncDeviceActive (TRUE)
+ && GetDriverRefCount () < 2)))
+ {
+ AppendMenuW (popup, MF_STRING, IDM_SHOW_HIDE, GetString ("HIDE_TC"));
+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);
+ }
+ AppendMenuW (popup, MF_STRING, IDM_MOUNTALL, GetString ("IDC_MOUNTALL"));
+ AppendMenuW (popup, MF_STRING, IDM_MOUNT_FAVORITE_VOLUMES, GetString ("IDM_MOUNT_FAVORITE_VOLUMES"));
+ AppendMenuW (popup, MF_STRING, IDM_UNMOUNTALL, GetString ("IDC_UNMOUNTALL"));
+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);
+
+ for (n = 0; n < 2; n++)
+ {
+ for (i = 0; i < 26; i++)
+ {
+ if (LastKnownMountList.ulMountedDrives & (1 << i))
+ {
+ wchar_t s[1024];
+ wchar_t *vol = (wchar_t *) LastKnownMountList.wszVolume[i];
+
+ if (wcsstr (vol, L"\\??\\")) vol += 4;
+
+ wstring label = GetFavoriteVolumeLabel (WideToSingleString (vol));
+
+ wsprintfW (s, L"%s %c: (%s)",
+ GetString (n==0 ? "OPEN" : "DISMOUNT"),
+ i + L'A',
+ label.empty() ? vol : label.c_str());
+ AppendMenuW (popup, MF_STRING, n*26 + TRAYICON_MENU_DRIVE_OFFSET + i, s);
+ }
+ }
+ if (LastKnownMountList.ulMountedDrives != 0)
+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);
+ }
+
+ AppendMenuW (popup, MF_STRING, IDM_HELP, GetString ("MENU_HELP"));
+ AppendMenuW (popup, MF_STRING, IDM_HOMEPAGE_SYSTRAY, GetString ("HOMEPAGE"));
+ AppendMenuW (popup, MF_STRING, IDM_PREFERENCES, GetString ("IDM_PREFERENCES"));
+ AppendMenuW (popup, MF_STRING, IDM_ABOUT, GetString ("IDM_ABOUT"));
+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);
+ AppendMenuW (popup, MF_STRING, IDCANCEL, GetString ("EXIT"));
+
+ GetCursorPos (&pos);
+
+ SetForegroundWindow(hwndDlg);
+
+ sel = TrackPopupMenu (popup,
+ TPM_RETURNCMD | TPM_LEFTALIGN | TPM_BOTTOMALIGN | TPM_RIGHTBUTTON,
+ pos.x,
+ pos.y,
+ 0,
+ hwndDlg,
+ NULL);
+
+ if (sel >= TRAYICON_MENU_DRIVE_OFFSET && sel < TRAYICON_MENU_DRIVE_OFFSET + 26)
+ {
+ OpenVolumeExplorerWindow (sel - TRAYICON_MENU_DRIVE_OFFSET);
+ }
+ else if (sel >= TRAYICON_MENU_DRIVE_OFFSET + 26 && sel < TRAYICON_MENU_DRIVE_OFFSET + 26*2)
+ {
+ if (CheckMountList ())
+ {
+ if (Dismount (hwndDlg, sel - TRAYICON_MENU_DRIVE_OFFSET - 26))
+ {
+ wchar_t txt [2048];
+ wsprintfW (txt, GetString ("VOLUME_MOUNTED_AS_DRIVE_LETTER_X_DISMOUNTED"), sel - TRAYICON_MENU_DRIVE_OFFSET - 26 + L'A');
+
+ InfoBalloonDirect (GetString ("SUCCESSFULLY_DISMOUNTED"), txt);
+ }
+ }
+ }
+ else if (sel == IDM_SHOW_HIDE)
+ {
+ ChangeMainWindowVisibility ();
+ }
+ else if (sel == IDM_HOMEPAGE_SYSTRAY)
+ {
+ Applink ("home", TRUE, "");
+ }
+ else if (sel == IDCANCEL)
+ {
+ if ((LastKnownMountList.ulMountedDrives == 0
+ && !SysEncDeviceActive (TRUE))
+ || AskWarnNoYes ("CONFIRM_EXIT") == IDYES)
+ {
+ // Close all other TC windows
+ EnumWindows (CloseTCWindowsEnum, 0);
+
+ TaskBarIconRemove (hwndDlg);
+ SendMessage (hwndDlg, WM_COMMAND, sel, 0);
+ }
+ }
+ else
+ {
+ SendMessage (hwndDlg, WM_COMMAND, sel, 0);
+ }
+
+ PostMessage(hwndDlg, WM_NULL, 0, 0);
+ DestroyMenu (popup);
+ }
+ return 1;
+ }
+ }
+
+ return 0;
+
+ case TC_APPMSG_CLOSE_BKG_TASK:
+ if (TaskBarIconMutex != NULL)
+ TaskBarIconRemove (hwndDlg);
+
+ return 1;
+
+ case TC_APPMSG_SYSENC_CONFIG_UPDATE:
+ LoadSysEncSettings (hwndDlg);
+
+ // The wizard added TrueCrypt.exe to the system startup sequence or performed other operations that
+ // require us to update our cached settings.
+ LoadSettings (hwndDlg);
+
+ return 1;
+
+ case WM_DEVICECHANGE:
+ if (!IgnoreWmDeviceChange && wParam != DBT_DEVICEARRIVAL)
+ {
+ // Check if any host device has been removed and force dismount of volumes accordingly
+ PDEV_BROADCAST_HDR hdr = (PDEV_BROADCAST_HDR) lParam;
+ int m;
+
+ GetMountList (&LastKnownMountList);
+
+ if (wParam == DBT_DEVICEREMOVECOMPLETE && hdr->dbch_devicetype == DBT_DEVTYP_VOLUME)
+ {
+ // File-hosted volumes
+ PDEV_BROADCAST_VOLUME vol = (PDEV_BROADCAST_VOLUME) lParam;
+ int i;
+
+ for (i = 0; i < 26; i++)
+ {
+ if ((vol->dbcv_unitmask & (1 << i)) && !(GetLogicalDrives() & (1 << i)))
+ {
+ for (m = 0; m < 26; m++)
+ {
+ if (LastKnownMountList.ulMountedDrives & (1 << m))
+ {
+ wchar_t *vol = (wchar_t *) LastKnownMountList.wszVolume[m];
+
+ if (wcsstr (vol, L"\\??\\") == vol)
+ vol += 4;
+
+ if (vol[1] == L':' && i == (vol[0] - (vol[0] <= L'Z' ? L'A' : L'a')))
+ {
+ UnmountVolume (hwndDlg, m, TRUE);
+ WarningBalloon ("HOST_DEVICE_REMOVAL_DISMOUNT_WARN_TITLE", "HOST_DEVICE_REMOVAL_DISMOUNT_WARN");
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // Device-hosted volumes
+ for (m = 0; m < 26; m++)
+ {
+ if (LastKnownMountList.ulMountedDrives & (1 << m))
+ {
+ wchar_t *vol = (wchar_t *) LastKnownMountList.wszVolume[m];
+ char volp[MAX_PATH];
+
+ if (wcsstr (vol, L"\\??\\") == vol)
+ vol += 4;
+
+ _snprintf (volp, sizeof(volp), "%ls", vol);
+
+ if (IsVolumeDeviceHosted (volp))
+ {
+ OPEN_TEST_STRUCT ots;
+
+ if (!OpenDevice (volp, &ots, FALSE))
+ {
+ UnmountVolume (hwndDlg, m, TRUE);
+ WarningBalloon ("HOST_DEVICE_REMOVAL_DISMOUNT_WARN_TITLE", "HOST_DEVICE_REMOVAL_DISMOUNT_WARN");
+ }
+ }
+ }
+ }
+
+ // Favorite volumes
+ UpdateDeviceHostedFavoriteVolumes();
+
+ return 1;
+ }
+ return 0;
+
+ case WM_NOTIFY:
+
+ if(wParam == IDC_DRIVELIST)
+ {
+ if (((LPNMHDR) lParam)->code == NM_CUSTOMDRAW)
+ {
+ int width = ListView_GetColumnWidth (GetDlgItem (hwndDlg, IDC_DRIVELIST), 1);
+ if (width != LastDriveListVolumeColumnWidth)
+ {
+ LastDriveListVolumeColumnWidth = width;
+ LoadDriveLetters (GetDlgItem (hwndDlg, IDC_DRIVELIST), 0);
+ }
+ return 0;
+ }
+
+ /* Single click within drive list */
+ if (((LPNMHDR) lParam)->code == LVN_ITEMCHANGED && (((LPNMLISTVIEW) lParam)->uNewState & LVIS_FOCUSED ))
+ {
+ nSelectedDriveIndex = ((LPNMLISTVIEW) lParam)->iItem;
+ EnableDisableButtons (hwndDlg);
+ return 1;
+ }
+
+ /* Double click within drive list */
+ if (((LPNMHDR) lParam)->code == LVN_ITEMACTIVATE)
+ {
+ int state = GetItemLong (GetDlgItem (hwndDlg, IDC_DRIVELIST), ((LPNMITEMACTIVATE)lParam)->iItem );
+ nSelectedDriveIndex = ((LPNMITEMACTIVATE)lParam)->iItem;
+ if (LOWORD(state) == TC_MLIST_ITEM_NONSYS_VOL || LOWORD(state) == TC_MLIST_ITEM_SYS_PARTITION)
+ {
+ // Open explorer window for mounted volume
+ WaitCursor ();
+ OpenVolumeExplorerWindow (HIWORD(state) - 'A');
+ NormalCursor ();
+ }
+ else if (LOWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) == TC_MLIST_ITEM_FREE)
+ {
+ mountOptions = defaultMountOptions;
+ bPrebootPasswordDlgMode = FALSE;
+
+ if (GetAsyncKeyState (VK_CONTROL) < 0)
+ {
+ if (IDCANCEL == DialogBoxParamW (hInst,
+ MAKEINTRESOURCEW (IDD_MOUNT_OPTIONS), hwndDlg,
+ (DLGPROC) MountOptionsDlgProc, (LPARAM) &mountOptions))
+ return 1;
+
+ if (mountOptions.ProtectHiddenVolume && hidVolProtKeyFilesParam.EnableKeyFiles)
+ KeyFilesApply (&mountOptions.ProtectedHidVolPassword, hidVolProtKeyFilesParam.FirstKeyFile);
+ }
+
+ if (CheckMountList ())
+ Mount (hwndDlg, 0, 0);
+ }
+ return 1;
+ }
+
+ /* Right click and drag&drop operations */
+
+ switch (((NM_LISTVIEW *) lParam)->hdr.code)
+ {
+ case NM_RCLICK:
+ case LVN_BEGINRDRAG:
+ /* If the mouse was moving while the right mouse button is pressed, popup menu would
+ not open, because drag&drop operation would be initiated. Therefore, we're handling
+ RMB drag-and-drop operations as well. */
+ {
+
+ /* Drive list context menu */
+
+ int menuItem;
+ HMENU popup = CreatePopupMenu ();
+
+ SetFocus (GetDlgItem (hwndDlg, IDC_DRIVELIST));
+
+ switch (LOWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))))
+ {
+ case TC_MLIST_ITEM_FREE:
+
+ // No mounted volume at this drive letter
+
+ AppendMenuW (popup, MF_STRING, IDM_MOUNT_VOLUME, GetString ("IDM_MOUNT_VOLUME"));
+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);
+ AppendMenuW (popup, MF_STRING, IDPM_SELECT_FILE_AND_MOUNT, GetString ("SELECT_FILE_AND_MOUNT"));
+ AppendMenuW (popup, MF_STRING, IDPM_SELECT_DEVICE_AND_MOUNT, GetString ("SELECT_DEVICE_AND_MOUNT"));
+ break;
+
+ case TC_MLIST_ITEM_NONSYS_VOL:
+
+ // There's a mounted non-system volume at this drive letter
+
+ AppendMenuW (popup, MF_STRING, IDM_UNMOUNT_VOLUME, GetString ("DISMOUNT"));
+ AppendMenuW (popup, MF_STRING, IDPM_OPEN_VOLUME, GetString ("OPEN"));
+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);
+ AppendMenuW (popup, MF_STRING, IDPM_CHECK_FILESYS, GetString ("IDPM_CHECK_FILESYS"));
+ AppendMenuW (popup, MF_STRING, IDPM_REPAIR_FILESYS, GetString ("IDPM_REPAIR_FILESYS"));
+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);
+ AppendMenuW (popup, MF_STRING, IDPM_ADD_TO_FAVORITES, GetString ("IDPM_ADD_TO_FAVORITES"));
+ AppendMenuW (popup, MF_STRING, IDPM_ADD_TO_SYSTEM_FAVORITES, GetString ("IDPM_ADD_TO_SYSTEM_FAVORITES"));
+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);
+ AppendMenuW (popup, MF_STRING, IDM_VOLUME_PROPERTIES, GetString ("IDPM_PROPERTIES"));
+ break;
+
+ case TC_MLIST_ITEM_SYS_PARTITION:
+ case TC_MLIST_ITEM_SYS_DRIVE:
+
+ // System partition/drive
+
+ PopulateSysEncContextMenu (popup, FALSE);
+ break;
+ }
+
+ mPos=GetMessagePos();
+
+ menuItem = TrackPopupMenu (popup,
+ TPM_RETURNCMD | TPM_LEFTBUTTON,
+ GET_X_LPARAM(mPos),
+ GET_Y_LPARAM(mPos),
+ 0,
+ hwndDlg,
+ NULL);
+
+ DestroyMenu (popup);
+
+ switch (menuItem)
+ {
+ case IDPM_SELECT_FILE_AND_MOUNT:
+ if (SelectContainer (hwndDlg))
+ MountSelectedVolume (hwndDlg, FALSE);
+ break;
+
+ case IDPM_SELECT_DEVICE_AND_MOUNT:
+ if (SelectPartition (hwndDlg))
+ MountSelectedVolume (hwndDlg, FALSE);
+ break;
+
+ case IDPM_CHECK_FILESYS:
+ case IDPM_REPAIR_FILESYS:
+ {
+ LPARAM lLetter = GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST));
+
+ if (LOWORD (lLetter) != 0xffff)
+ CheckFilesystem ((char) HIWORD (lLetter) - 'A', menuItem == IDPM_REPAIR_FILESYS);
+ }
+ break;
+
+ case IDM_UNMOUNT_VOLUME:
+ if (CheckMountList ())
+ Dismount (hwndDlg, 0);
+ break;
+
+ case IDPM_OPEN_VOLUME:
+ {
+ int state = GetItemLong(GetDlgItem (hwndDlg, IDC_DRIVELIST), ((LPNMITEMACTIVATE)lParam)->iItem );
+ nSelectedDriveIndex = ((LPNMITEMACTIVATE)lParam)->iItem;
+
+ WaitCursor ();
+ OpenVolumeExplorerWindow (HIWORD(state) - 'A');
+ NormalCursor ();
+ }
+ break;
+
+ case IDM_VOLUME_PROPERTIES:
+ DialogBoxParamW (hInst,
+ MAKEINTRESOURCEW (IDD_VOLUME_PROPERTIES), hwndDlg,
+ (DLGPROC) VolumePropertiesDlgProc, (LPARAM) FALSE);
+ break;
+
+ case IDM_MOUNT_VOLUME:
+ if (!VolumeSelected(hwndDlg))
+ {
+ Warning ("NO_VOLUME_SELECTED");
+ }
+ else
+ {
+ mountOptions = defaultMountOptions;
+ bPrebootPasswordDlgMode = FALSE;
+
+ if (CheckMountList ())
+ Mount (hwndDlg, 0, 0);
+ }
+ break;
+
+ case IDPM_ADD_TO_FAVORITES:
+ case IDPM_ADD_TO_SYSTEM_FAVORITES:
+ {
+ LPARAM selectedDrive = GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST));
+
+ if (LOWORD (selectedDrive) == TC_MLIST_ITEM_NONSYS_VOL)
+ AddMountedVolumeToFavorites (hwndDlg, HIWORD (selectedDrive) - 'A', menuItem == IDPM_ADD_TO_SYSTEM_FAVORITES);
+ }
+ break;
+
+ default:
+ SendMessage (MainDlg, WM_COMMAND, menuItem, NULL);
+ break;
+ }
+ return 1;
+ }
+ }
+ }
+ return 0;
+
+ case WM_ERASEBKGND:
+ return 0;
+
+ case WM_COMMAND:
+
+ if (lw == IDCANCEL || lw == IDC_EXIT)
+ {
+ EndMainDlg (hwndDlg);
+ return 1;
+ }
+
+ if (lw == IDHELP || lw == IDM_HELP)
+ {
+ OpenPageHelp (hwndDlg, 0);
+ return 1;
+ }
+
+ if (lw == IDM_ABOUT || lw == IDC_LOGO)
+ {
+ DialogBoxW (hInst, MAKEINTRESOURCEW (IDD_ABOUT_DLG), hwndDlg, (DLGPROC) AboutDlgProc);
+ return 1;
+ }
+
+ if (lw == IDOK && LOWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) == TC_MLIST_ITEM_NONSYS_VOL
+ || lw == IDM_UNMOUNT_VOLUME)
+ {
+ if (lw == IDM_UNMOUNT_VOLUME && LOWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) != TC_MLIST_ITEM_NONSYS_VOL)
+ {
+ Warning ("SELECT_A_MOUNTED_VOLUME");
+ return 1;
+ }
+
+ if (CheckMountList ())
+ Dismount (hwndDlg, 0);
+ return 1;
+ }
+
+ if ((lw == IDOK || lw == IDM_MOUNT_VOLUME || lw == IDM_MOUNT_VOLUME_OPTIONS || lw == IDC_MOUNTALL || lw == IDM_MOUNTALL)
+ && LOWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) == 0xffff)
+ {
+ MessageBoxW (hwndDlg, GetString ("SELECT_FREE_DRIVE"), L"TrueCrypt", MB_ICONEXCLAMATION);
+ return 1;
+ }
+
+ if ((lw == IDOK || lw == IDM_MOUNT_VOLUME || lw == IDM_MOUNT_VOLUME_OPTIONS))
+ {
+ MountSelectedVolume (hwndDlg, lw == IDM_MOUNT_VOLUME_OPTIONS);
+ return 1;
+ }
+
+ if (lw == IDC_UNMOUNTALL || lw == IDM_UNMOUNTALL)
+ {
+ if (DismountAll (hwndDlg, bForceUnmount, TRUE, UNMOUNT_MAX_AUTO_RETRIES, UNMOUNT_AUTO_RETRY_DELAY)
+ && lw == IDM_UNMOUNTALL) // If initiated via the systray menu
+ {
+ InfoBalloon ("SUCCESSFULLY_DISMOUNTED", "MOUNTED_VOLUMES_DISMOUNTED");
+ }
+
+ return 1;
+ }
+
+ if (lw == IDC_MOUNTALL || lw == IDM_MOUNTALL)
+ {
+ // If Shift key is down and the password cache isn't empty, bypass password prompt
+ MountAllDevices (hwndDlg, !(GetAsyncKeyState (VK_SHIFT) < 0 && !IsPasswordCacheEmpty()));
+ return 1;
+ }
+
+ if (lw == IDC_SELECT_FILE || lw == IDM_SELECT_FILE)
+ {
+ SelectContainer (hwndDlg);
+ return 1;
+ }
+
+ if (lw == IDC_SELECT_DEVICE || lw == IDM_SELECT_DEVICE)
+ {
+ SelectPartition (hwndDlg);
+ return 1;
+ }
+
+ // System Encryption menu
+ switch (lw)
+ {
+ case IDM_ENCRYPT_SYSTEM_DEVICE:
+ EncryptSystemDevice ();
+ break;
+ case IDM_PERMANENTLY_DECRYPT_SYS:
+ DecryptSystemDevice ();
+ break;
+ case IDM_CREATE_HIDDEN_OS:
+ CreateHiddenOS ();
+ break;
+ case IDM_SYSENC_RESUME:
+ ResumeInterruptedSysEncProcess ();
+ break;
+ case IDM_SYSTEM_ENCRYPTION_STATUS:
+ ShowSystemEncryptionStatus ();
+ break;
+ case IDM_CHANGE_SYS_PASSWORD:
+ ChangeSysEncPassword (hwndDlg, FALSE);
+ break;
+ case IDM_CHANGE_SYS_HEADER_KEY_DERIV_ALGO:
+ ChangeSysEncPassword (hwndDlg, TRUE);
+ break;
+ case IDM_CREATE_RESCUE_DISK:
+ CreateRescueDisk ();
+ break;
+ case IDM_VERIFY_RESCUE_DISK:
+ VerifyRescueDisk ();
+ break;
+ case IDM_MOUNT_SYSENC_PART_WITHOUT_PBA:
+
+ if (CheckSysEncMountWithoutPBA ("", FALSE))
+ {
+ mountOptions = defaultMountOptions;
+ mountOptions.PartitionInInactiveSysEncScope = TRUE;
+ bPrebootPasswordDlgMode = TRUE;
+
+ if (CheckMountList ())
+ Mount (hwndDlg, 0, 0);
+
+ bPrebootPasswordDlgMode = FALSE;
+ }
+ break;
+ }
+
+ if (lw == IDC_VOLUME_TOOLS)
+ {
+ /* Volume Tools popup menu */
+
+ int menuItem;
+ char volPath[TC_MAX_PATH]; /* Volume to mount */
+ HMENU popup = CreatePopupMenu ();
+ RECT rect;
+
+ if (ActiveSysEncDeviceSelected ())
+ {
+ PopulateSysEncContextMenu (popup, TRUE);
+ }
+ else
+ {
+ AppendMenuW (popup, MF_STRING, IDM_CHANGE_PASSWORD, GetString ("IDM_CHANGE_PASSWORD"));
+ AppendMenuW (popup, MF_STRING, IDM_CHANGE_HEADER_KEY_DERIV_ALGO, GetString ("IDM_CHANGE_HEADER_KEY_DERIV_ALGO"));
+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);
+ AppendMenuW (popup, MF_STRING, IDM_ADD_REMOVE_VOL_KEYFILES, GetString ("IDM_ADD_REMOVE_VOL_KEYFILES"));
+ AppendMenuW (popup, MF_STRING, IDM_REMOVE_ALL_KEYFILES_FROM_VOL, GetString ("IDM_REMOVE_ALL_KEYFILES_FROM_VOL"));
+ AppendMenu (popup, MF_SEPARATOR, 0, NULL);
+ AppendMenuW (popup, MF_STRING, IDM_BACKUP_VOL_HEADER, GetString ("IDM_BACKUP_VOL_HEADER"));
+ AppendMenuW (popup, MF_STRING, IDM_RESTORE_VOL_HEADER, GetString ("IDM_RESTORE_VOL_HEADER"));
+ }
+
+ GetWindowRect (GetDlgItem (hwndDlg, IDC_VOLUME_TOOLS), &rect);
+
+ menuItem = TrackPopupMenu (popup,
+ TPM_RETURNCMD | TPM_LEFTBUTTON,
+ rect.left + 2,
+ rect.top + 2,
+ 0,
+ hwndDlg,
+ NULL);
+
+ DestroyMenu (popup);
+
+ switch (menuItem)
+ {
+ case IDM_CHANGE_PASSWORD:
+ if (!VolumeSelected(hwndDlg))
+ {
+ Warning ("NO_VOLUME_SELECTED");
+ }
+ else
+ {
+ pwdChangeDlgMode = PCDM_CHANGE_PASSWORD;
+ ChangePassword (hwndDlg);
+ }
+ break;
+
+ case IDM_CHANGE_HEADER_KEY_DERIV_ALGO:
+ if (!VolumeSelected(hwndDlg))
+ {
+ Warning ("NO_VOLUME_SELECTED");
+ }
+ else
+ {
+ pwdChangeDlgMode = PCDM_CHANGE_PKCS5_PRF;
+ ChangePassword (hwndDlg);
+ }
+ break;
+
+ case IDM_ADD_REMOVE_VOL_KEYFILES:
+ if (!VolumeSelected(hwndDlg))
+ {
+ Warning ("NO_VOLUME_SELECTED");
+ }
+ else
+ {
+ pwdChangeDlgMode = PCDM_ADD_REMOVE_VOL_KEYFILES;
+ ChangePassword (hwndDlg);
+ }
+ break;
+
+ case IDM_REMOVE_ALL_KEYFILES_FROM_VOL:
+ if (!VolumeSelected(hwndDlg))
+ {
+ Warning ("NO_VOLUME_SELECTED");
+ }
+ else
+ {
+ pwdChangeDlgMode = PCDM_REMOVE_ALL_KEYFILES_FROM_VOL;
+ ChangePassword (hwndDlg);
+ }
+ break;
+
+ case IDM_BACKUP_VOL_HEADER:
+ if (!VolumeSelected(hwndDlg))
+ {
+ Warning ("NO_VOLUME_SELECTED");
+ }
+ else
+ {
+ GetWindowText (GetDlgItem (hwndDlg, IDC_VOLUME), volPath, sizeof (volPath));
+
+ WaitCursor ();
+
+ if (!IsAdmin () && IsUacSupported () && IsVolumeDeviceHosted (volPath))
+ UacBackupVolumeHeader (hwndDlg, TRUE, volPath);
+ else
+ BackupVolumeHeader (hwndDlg, TRUE, volPath);
+
+ NormalCursor ();
+ }
+ break;
+
+ case IDM_RESTORE_VOL_HEADER:
+ if (!VolumeSelected(hwndDlg))
+ {
+ Warning ("NO_VOLUME_SELECTED");
+ }
+ else
+ {
+ GetWindowText (GetDlgItem (hwndDlg, IDC_VOLUME), volPath, sizeof (volPath));
+
+ WaitCursor ();
+
+ if (!IsAdmin () && IsUacSupported () && IsVolumeDeviceHosted (volPath))
+ UacRestoreVolumeHeader (hwndDlg, volPath);
+ else
+ RestoreVolumeHeader (hwndDlg, volPath);
+
+ NormalCursor ();
+ }
+ break;
+
+ default:
+ SendMessage (MainDlg, WM_COMMAND, menuItem, NULL);
+ break;
+ }
+ return 1;
+ }
+
+ if (lw == IDM_CHANGE_PASSWORD)
+ {
+ if (!VolumeSelected(hwndDlg))
+ {
+ Warning ("NO_VOLUME_SELECTED");
+ }
+ else
+ {
+ if (ActiveSysEncDeviceSelected ())
+ {
+ ChangeSysEncPassword (hwndDlg, FALSE);
+ }
+ else
+ {
+ pwdChangeDlgMode = PCDM_CHANGE_PASSWORD;
+ ChangePassword (hwndDlg);
+ }
+ }
+ return 1;
+ }
+
+ if (lw == IDM_CHANGE_HEADER_KEY_DERIV_ALGO)
+ {
+ if (!VolumeSelected(hwndDlg))
+ {
+ Warning ("NO_VOLUME_SELECTED");
+ }
+ else
+ {
+ if (ActiveSysEncDeviceSelected ())
+ {
+ ChangeSysEncPassword (hwndDlg, TRUE);
+ }
+ else
+ {
+ pwdChangeDlgMode = PCDM_CHANGE_PKCS5_PRF;
+ ChangePassword (hwndDlg);
+ }
+ }
+ return 1;
+ }
+
+ if (lw == IDC_WIPE_CACHE || lw == IDM_WIPE_CACHE)
+ {
+ WipeCache (hwndDlg, FALSE);
+ return 1;
+ }
+
+ if (lw == IDM_CLEAR_HISTORY)
+ {
+ ClearHistory (GetDlgItem (hwndDlg, IDC_VOLUME));
+ EnableDisableButtons (hwndDlg);
+ return 1;
+ }
+
+ if (lw == IDC_CREATE_VOLUME || lw == IDM_CREATE_VOLUME || lw == IDM_VOLUME_WIZARD)
+ {
+ LaunchVolCreationWizard (hwndDlg, "");
+ return 1;
+ }
+
+ if (lw == IDM_ADD_REMOVE_VOL_KEYFILES)
+ {
+ if (!VolumeSelected(hwndDlg))
+ {
+ Warning ("NO_VOLUME_SELECTED");
+ }
+ else
+ {
+ pwdChangeDlgMode = PCDM_ADD_REMOVE_VOL_KEYFILES;
+ ChangePassword (hwndDlg);
+ }
+ return 1;
+ }
+
+ if (lw == IDM_REMOVE_ALL_KEYFILES_FROM_VOL)
+ {
+ if (!VolumeSelected(hwndDlg))
+ {
+ Warning ("NO_VOLUME_SELECTED");
+ }
+ else
+ {
+ pwdChangeDlgMode = PCDM_REMOVE_ALL_KEYFILES_FROM_VOL;
+ ChangePassword (hwndDlg);
+ }
+ return 1;
+ }
+
+ if (lw == IDM_MANAGE_TOKEN_KEYFILES)
+ {
+ DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_TOKEN_KEYFILES), hwndDlg, (DLGPROC) SecurityTokenKeyfileDlgProc, NULL);
+ return 1;
+ }
+
+ if (lw == IDM_CLOSE_ALL_TOKEN_SESSIONS)
+ {
+ {
+ WaitCursor();
+ finally_do ({ NormalCursor(); });
+
+ SecurityToken::CloseAllSessions();
+ }
+
+ InfoBalloon (NULL, "ALL_TOKEN_SESSIONS_CLOSED");
+
+ return 1;
+ }
+
+ if (lw == IDM_KEYFILE_GENERATOR)
+ {
+ DialogBoxParamW (hInst,
+ MAKEINTRESOURCEW (IDD_KEYFILE_GENERATOR), hwndDlg,
+ (DLGPROC) KeyfileGeneratorDlgProc, (LPARAM) 0);
+
+ return 1;
+ }
+
+ if (lw == IDM_LICENSE)
+ {
+ TextInfoDialogBox (TC_TBXID_LEGAL_NOTICES);
+ return 1;
+ }
+
+ if (lw == IDM_WEBSITE)
+ {
+ Applink ("website", TRUE, "");
+ return 1;
+ }
+ else if (lw == IDM_HOMEPAGE)
+ {
+ Applink ("homepage", TRUE, "");
+ return 1;
+ }
+ else if (lw == IDM_ONLINE_TUTORIAL)
+ {
+ Applink ("tutorial", TRUE, "");
+ return 1;
+ }
+ else if (lw == IDM_ONLINE_HELP)
+ {
+ OpenOnlineHelp ();
+ return 1;
+ }
+ else if (lw == IDM_FAQ)
+ {
+ Applink ("faq", TRUE, "");
+ return 1;
+ }
+ else if (lw == IDM_TC_DOWNLOADS)
+ {
+ Applink ("downloads", TRUE, "");
+ return 1;
+ }
+ else if (lw == IDM_NEWS)
+ {
+ Applink ("news", TRUE, "");
+ return 1;
+ }
+ else if (lw == IDM_VERSION_HISTORY)
+ {
+ Applink ("history", TRUE, "");
+ return 1;
+ }
+ else if (lw == IDM_ANALYZE_SYSTEM_CRASH)
+ {
+ if (!IsAdmin() && IsUacSupported())
+ UacAnalyzeKernelMiniDump (hwndDlg);
+ else
+ AnalyzeKernelMiniDump (hwndDlg);
+
+ return 1;
+ }
+ else if (lw == IDM_CONTACT)
+ {
+ Applink ("contact", FALSE, "");
+ return 1;
+ }
+
+ if (lw == IDM_PREFERENCES)
+ {
+ if (IDOK == DialogBoxParamW (hInst,
+ MAKEINTRESOURCEW (IDD_PREFERENCES_DLG), hwndDlg,
+ (DLGPROC) PreferencesDlgProc, (LPARAM) 0))
+ {
+ if (bEnableBkgTask)
+ {
+ TaskBarIconAdd (hwndDlg);
+ }
+ else
+ {
+ TaskBarIconRemove (hwndDlg);
+ if (MainWindowHidden)
+ EndMainDlg (hwndDlg);
+ }
+ }
+ return 1;
+ }
+
+ if (lw == IDM_HOTKEY_SETTINGS)
+ {
+ DialogBoxParamW (hInst,
+ MAKEINTRESOURCEW (IDD_HOTKEYS_DLG), hwndDlg,
+ (DLGPROC) HotkeysDlgProc, (LPARAM) 0);
+ return 1;
+ }
+
+ if (lw == IDM_PERFORMANCE_SETTINGS)
+ {
+ DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_PERFORMANCE_SETTINGS), hwndDlg, (DLGPROC) PerformanceSettingsDlgProc, 0);
+ return 1;
+ }
+
+ if (lw == IDM_DEFAULT_KEYFILES)
+ {
+ KeyfileDefaultsDlg (hwndDlg);
+ return 1;
+ }
+
+ if (lw == IDM_ADD_VOLUME_TO_FAVORITES || lw == IDM_ADD_VOLUME_TO_SYSTEM_FAVORITES)
+ {
+ LPARAM selectedDrive = GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST));
+
+ char volPathLower[TC_MAX_PATH];
+ wchar_t volPathLowerW[TC_MAX_PATH];
+
+ // volPathLower will contain the volume path (if any) from the input field below the drive list
+ GetWindowText (GetDlgItem (hwndDlg, IDC_VOLUME), volPathLower, sizeof (volPathLower));
+
+ if (LOWORD (selectedDrive) != TC_MLIST_ITEM_NONSYS_VOL
+ && !(VolumeSelected (hwndDlg) && IsMountedVolume (volPathLower)))
+ {
+ Warning ("SELECT_A_MOUNTED_VOLUME");
+
+ return 1;
+ }
+
+ int driveNo;
+
+ if (VolumeSelected (hwndDlg)
+ && IsMountedVolume (volPathLower))
+ {
+ if (LOWORD (selectedDrive) != TC_MLIST_ITEM_NONSYS_VOL)
+ {
+ driveNo = GetMountedVolumeDriveNo (volPathLower);
+ }
+ else
+ {
+ /* We need to resolve selection ambiguity. Two different mounted volumes are currently
+ selected (one in the drive letter list and the other in the input field below the list). */
+
+ VOLUME_PROPERTIES_STRUCT prop;
+ DWORD dwResult;
+
+ memset (&prop, 0, sizeof(prop));
+ prop.driveNo = HIWORD (selectedDrive) - 'A';
+
+ if (!DeviceIoControl (hDriver, TC_IOCTL_GET_VOLUME_PROPERTIES, &prop, sizeof (prop), &prop, sizeof (prop), &dwResult, NULL) || dwResult == 0)
+ {
+ Warning ("SELECT_A_MOUNTED_VOLUME");
+ return 1;
+ }
+
+ // volPathHigher will contain the volume path selected in the main drive list
+ wstring volPathHigher (prop.wszVolume);
+
+ ToSBCS (prop.wszVolume);
+ strcpy ((char *) volPathLowerW, volPathLower);
+ ToUNICODE ((char *) volPathLowerW);
+
+ if (strcmp (((memcmp ((char *) prop.wszVolume, "\\??\\", 4) == 0) ? (char *) prop.wszVolume + 4 : (char *) prop.wszVolume), volPathLower) != 0)
+ {
+ // The path selected in the input field is different from the path to the volume selected
+ // in the drive lettter list. We have to resolve possible ambiguity.
+
+ wchar_t *tmp[] = {L"", L"", L"", L"", L"", 0};
+ const int maxVolPathLen = 80;
+
+ if (volPathHigher.length () > maxVolPathLen)
+ {
+ volPathHigher = wstring (L"...") + volPathHigher.substr (volPathHigher.length () - maxVolPathLen, maxVolPathLen);
+ }
+
+ wstring volPathLowerWStr (volPathLowerW);
+
+ if (volPathLowerWStr.length () > maxVolPathLen)
+ {
+ volPathLowerWStr = wstring (L"...") + volPathLowerWStr.substr (volPathLowerWStr.length () - maxVolPathLen, maxVolPathLen);
+ }
+
+ tmp[1] = GetString ("AMBIGUOUS_VOL_SELECTION");
+ tmp[2] = (wchar_t *) volPathHigher.c_str();
+ tmp[3] = (wchar_t *) volPathLowerWStr.c_str();
+ tmp[4] = GetString ("IDCANCEL");
+
+ switch (AskMultiChoice ((void **) tmp, FALSE))
+ {
+ case 1:
+ driveNo = HIWORD (selectedDrive) - 'A';
+ break;
+
+ case 2:
+ driveNo = GetMountedVolumeDriveNo (volPathLower);
+ break;
+
+ default:
+ return 1;
+ }
+ }
+ else
+ {
+ driveNo = HIWORD (selectedDrive) - 'A';
+ }
+ }
+ }
+ else
+ {
+ driveNo = HIWORD (selectedDrive) - 'A';
+ }
+
+ AddMountedVolumeToFavorites (hwndDlg, driveNo, lw == IDM_ADD_VOLUME_TO_SYSTEM_FAVORITES);
+
+ return 1;
+ }
+
+ if (lw == IDM_ORGANIZE_FAVORITES || lw == IDM_ORGANIZE_SYSTEM_FAVORITES)
+ {
+ OrganizeFavoriteVolumes (hwndDlg, lw == IDM_ORGANIZE_SYSTEM_FAVORITES);
+ return 1;
+ }
+
+ if (lw == IDM_TOKEN_PREFERENCES)
+ {
+ SecurityTokenPreferencesDialog (hwndDlg);
+ return 1;
+ }
+
+ if (lw == IDM_SYSENC_SETTINGS || lw == IDM_SYS_ENC_SETTINGS)
+ {
+ DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_SYSENC_SETTINGS), hwndDlg, (DLGPROC) BootLoaderPreferencesDlgProc, 0);
+ return 1;
+ }
+
+ if (lw == IDM_SYS_FAVORITES_SETTINGS)
+ {
+ OrganizeFavoriteVolumes (hwndDlg, true);
+ return 1;
+ }
+
+ if (lw == IDM_BENCHMARK)
+ {
+ Benchmark (hwndDlg);
+ return 1;
+ }
+
+ if (lw == IDM_TRAVELER)
+ {
+ DialogBoxParamW (hInst,
+ MAKEINTRESOURCEW (IDD_TRAVELER_DLG), hwndDlg,
+ (DLGPROC) TravelerDlgProc, (LPARAM) 0);
+ return 1;
+ }
+
+ if (lw == IDM_BACKUP_VOL_HEADER)
+ {
+ if (!VolumeSelected(hwndDlg))
+ {
+ Warning ("NO_VOLUME_SELECTED");
+ }
+ else
+ {
+ char volPath[TC_MAX_PATH]; /* Volume to mount */
+
+ GetWindowText (GetDlgItem (hwndDlg, IDC_VOLUME), volPath, sizeof (volPath));
+
+ WaitCursor ();
+
+ if (!IsAdmin () && IsUacSupported () && IsVolumeDeviceHosted (volPath))
+ UacBackupVolumeHeader (hwndDlg, TRUE, volPath);
+ else
+ BackupVolumeHeader (hwndDlg, TRUE, volPath);
+
+ NormalCursor ();
+ }
+ return 1;
+ }
+
+ if (lw == IDM_RESTORE_VOL_HEADER)
+ {
+ if (!VolumeSelected(hwndDlg))
+ {
+ Warning ("NO_VOLUME_SELECTED");
+ }
+ else
+ {
+ char volPath[TC_MAX_PATH]; /* Volume to mount */
+
+ GetWindowText (GetDlgItem (hwndDlg, IDC_VOLUME), volPath, sizeof (volPath));
+
+ WaitCursor ();
+
+ if (!IsAdmin () && IsUacSupported () && IsVolumeDeviceHosted (volPath))
+ UacRestoreVolumeHeader (hwndDlg, volPath);
+ else
+ RestoreVolumeHeader (hwndDlg, volPath);
+
+ NormalCursor ();
+ }
+ return 1;
+ }
+
+ if (lw == IDM_LANGUAGE)
+ {
+ BOOL p;
+ if (DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_LANGUAGE), hwndDlg,
+ (DLGPROC) LanguageDlgProc, (LPARAM) 0) == IDOK)
+ {
+ LoadLanguageFile ();
+ SaveSettings (hwndDlg);
+
+ p = LocalizationActive;
+ LocalizationActive = TRUE;
+ InitMainDialog (hwndDlg);
+ InvalidateRect (hwndDlg, NULL, FALSE);
+ LocalizationActive = p;
+ DrawMenuBar (hwndDlg);
+ }
+ return 1;
+ }
+
+ if (lw == IDM_TEST_VECTORS)
+ {
+ DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_CIPHER_TEST_DLG), hwndDlg, (DLGPROC) CipherTestDialogProc, (LPARAM) 1);
+ return 1;
+ }
+
+ if (lw == IDM_REFRESH_DRIVE_LETTERS)
+ {
+ DWORD driveMap = GetLogicalDrives ();
+
+ WaitCursor ();
+
+ if (!(nCurrentOS == WIN_2000 && RemoteSession))
+ {
+ BroadcastDeviceChange (DBT_DEVICEREMOVECOMPLETE, 0, ~driveMap);
+ Sleep (100);
+ BroadcastDeviceChange (DBT_DEVICEARRIVAL, 0, driveMap);
+ }
+
+ LoadDriveLetters (GetDlgItem (hwndDlg, IDC_DRIVELIST), 0);
+
+ if (nSelectedDriveIndex >= 0)
+ {
+ SelectItem (GetDlgItem (hwndDlg, IDC_DRIVELIST),
+ (char) HIWORD (GetItemLong (GetDlgItem (hwndDlg, IDC_DRIVELIST), nSelectedDriveIndex)));
+ }
+
+ NormalCursor ();
+ return 1;
+ }
+
+ if (lw == IDM_MOUNT_FAVORITE_VOLUMES)
+ {
+ MountFavoriteVolumes();
+ return 1;
+ }
+
+ if (lw == IDM_RESUME_INTERRUPTED_PROC)
+ {
+ ResumeInterruptedNonSysInplaceEncProcess ();
+ return 1;
+ }
+
+ if (lw == IDC_VOLUME_PROPERTIES || lw == IDM_VOLUME_PROPERTIES)
+ {
+ DialogBoxParamW (hInst,
+ MAKEINTRESOURCEW (IDD_VOLUME_PROPERTIES), hwndDlg,
+ (DLGPROC) VolumePropertiesDlgProc, (LPARAM) 0);
+ return 1;
+ }
+
+ if (lw == IDC_VOLUME && hw == CBN_EDITCHANGE)
+ {
+ EnableDisableButtons (hwndDlg);
+ return 1;
+ }
+
+ if (lw == IDC_VOLUME && hw == CBN_SELCHANGE)
+ {
+ UpdateComboOrder (GetDlgItem (hwndDlg, IDC_VOLUME));
+ MoveEditToCombo ((HWND) lParam, bHistory);
+ PostMessage (hwndDlg, TC_APPMSG_MOUNT_ENABLE_DISABLE_CONTROLS, 0, 0);
+ return 1;
+ }
+
+ if (lw == IDC_NO_HISTORY)
+ {
+ if (!(bHistory = !IsButtonChecked (GetDlgItem (hwndDlg, IDC_NO_HISTORY))))
+ ClearHistory (GetDlgItem (hwndDlg, IDC_VOLUME));
+
+ return 1;
+ }
+
+ if (lw >= TC_FAVORITE_MENU_CMD_ID_OFFSET && lw < TC_FAVORITE_MENU_CMD_ID_OFFSET_END)
+ {
+ size_t favoriteIndex = lw - TC_FAVORITE_MENU_CMD_ID_OFFSET;
+
+ if (favoriteIndex < FavoriteVolumes.size())
+ {
+ if (IsMountedVolume (FavoriteVolumes[favoriteIndex].Path.c_str()))
+ {
+ WaitCursor();
+ OpenVolumeExplorerWindow (GetMountedVolumeDriveNo ((char *) FavoriteVolumes[favoriteIndex].Path.c_str()));
+ NormalCursor();
+ }
+ else
+ MountFavoriteVolumes (FALSE, FALSE, FALSE, FavoriteVolumes[favoriteIndex]);
+ }
+
+ return 1;
+ }
+
+ return 0;
+
+ case WM_DROPFILES:
+ {
+ HDROP hdrop = (HDROP) wParam;
+ DragQueryFile (hdrop, 0, szFileName, sizeof szFileName);
+ DragFinish (hdrop);
+
+ AddComboItem (GetDlgItem (hwndDlg, IDC_VOLUME), szFileName, bHistory);
+ EnableDisableButtons (hwndDlg);
+ SetFocus (GetDlgItem (hwndDlg, IDC_DRIVELIST));
+ }
+ return 1;
+
+ case TC_APPMSG_MOUNT_ENABLE_DISABLE_CONTROLS:
+ EnableDisableButtons (hwndDlg);
+ return 1;
+
+ case TC_APPMSG_MOUNT_SHOW_WINDOW:
+ MainWindowHidden = FALSE;
+ ShowWindow (hwndDlg, SW_SHOW);
+ ShowWindow (hwndDlg, SW_RESTORE);
+ return 1;
+
+ case WM_COPYDATA:
+ {
+ PCOPYDATASTRUCT cd = (PCOPYDATASTRUCT)lParam;
+ if (memcmp (&cd->dwData, WM_COPY_SET_VOLUME_NAME, 4) == 0)
+ {
+ if (cd->cbData > 0)
+ {
+ ((char *) cd->lpData)[cd->cbData - 1] = 0;
+ AddComboItem (GetDlgItem (hwndDlg, IDC_VOLUME), (char *)cd->lpData, bHistory);
+ }
+
+ EnableDisableButtons (hwndDlg);
+ SetFocus (GetDlgItem (hwndDlg, IDC_DRIVELIST));
+ }
+ }
+ return 1;
+
+ case WM_CLOSE:
+ EndMainDlg (hwndDlg);
+ return 1;
+
+ default:
+ // Recreate tray icon if Explorer restarted
+ if (taskBarCreatedMsg != 0 && uMsg == taskBarCreatedMsg && TaskBarIconMutex != NULL)
+ {
+ TaskBarIconRemove (hwndDlg);
+ TaskBarIconAdd (hwndDlg);
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+void ExtractCommandLine (HWND hwndDlg, char *lpszCommandLine)
+{
+ char **lpszCommandLineArgs; /* Array of command line arguments */
+ int nNoCommandLineArgs; /* The number of arguments in the array */
+ char tmpPath[MAX_PATH * 2];
+
+ /* Defaults */
+ mountOptions.PreserveTimestamp = TRUE;
+
+ if (_stricmp (lpszCommandLine, "-Embedding") == 0)
+ {
+ ComServerMode = TRUE;
+ return;
+ }
+
+ /* Extract command line arguments */
+ NoCmdLineArgs = nNoCommandLineArgs = Win32CommandLine (lpszCommandLine, &lpszCommandLineArgs);
+
+ if (nNoCommandLineArgs > 0)
+ {
+ int i;
+
+ for (i = 0; i < nNoCommandLineArgs; i++)
+ {
+ enum
+ {
+ OptionAuto,
+ OptionBeep,
+ OptionCache,
+ CommandDismount,
+ OptionExplore,
+ OptionForce,
+ CommandHelp,
+ OptionHistory,
+ OptionKeyfile,
+ OptionLetter,
+ OptionMountOption,
+ OptionPassword,
+ OptionQuit,
+ OptionSilent,
+ OptionTokenLib,
+ OptionVolume,
+ CommandWipeCache
+ };
+
+ argument args[]=
+ {
+ { OptionAuto, "/auto", "/a", FALSE },
+ { OptionBeep, "/beep", "/b", FALSE },
+ { OptionCache, "/cache", "/c", FALSE },
+ { CommandDismount, "/dismount", "/d", FALSE },
+ { OptionExplore, "/explore", "/e", FALSE },
+ { OptionForce, "/force", "/f", FALSE },
+ { CommandHelp, "/help", "/?", FALSE },
+ { OptionHistory, "/history", "/h", FALSE },
+ { OptionKeyfile, "/keyfile", "/k", FALSE },
+ { OptionLetter, "/letter", "/l", FALSE },
+ { OptionMountOption, "/mountoption", "/m", FALSE },
+ { OptionPassword, "/password", "/p", FALSE },
+ { OptionQuit, "/quit", "/q", FALSE },
+ { OptionSilent, "/silent", "/s", FALSE },
+ { OptionTokenLib, "/tokenlib", NULL, FALSE },
+ { OptionVolume, "/volume", "/v", FALSE },
+ { CommandWipeCache, "/wipecache", "/w", FALSE }
+ };
+
+ argumentspec as;
+
+ int nArgPos;
+
+ as.args = args;
+ as.arg_cnt = sizeof(args)/ sizeof(args[0]);
+
+ switch (GetArgumentID (&as, lpszCommandLineArgs[i], &nArgPos))
+ {
+ case OptionAuto:
+ {
+ char szTmp[32];
+ bAuto = TRUE;
+
+ if (HAS_ARGUMENT == GetArgumentValue (lpszCommandLineArgs,
+ nArgPos, &i, nNoCommandLineArgs, szTmp, sizeof (szTmp)))
+ {
+ if (!_stricmp (szTmp, "devices"))
+ bAutoMountDevices = TRUE;
+ else if (!_stricmp (szTmp, "favorites"))
+ bAutoMountFavorites = TRUE;
+ else if (!_stricmp (szTmp, "logon"))
+ LogOn = TRUE;
+ }
+ }
+ break;
+
+ case OptionBeep:
+ bBeep = TRUE;
+ break;
+
+ case OptionCache:
+ {
+ char szTmp[8];
+ bCacheInDriver = TRUE;
+
+ GetArgumentValue (lpszCommandLineArgs, nArgPos, &i, nNoCommandLineArgs,
+ szTmp, sizeof (szTmp));
+
+ if (!_stricmp(szTmp,"n") || !_stricmp(szTmp,"no"))
+ bCacheInDriver = FALSE;
+ }
+ break;
+
+ case CommandDismount:
+
+ if (HAS_ARGUMENT == GetArgumentValue (lpszCommandLineArgs, nArgPos, &i, nNoCommandLineArgs,
+ szDriveLetter, sizeof (szDriveLetter)))
+ cmdUnmountDrive = toupper(szDriveLetter[0]) - 'A';
+ else
+ cmdUnmountDrive = -1;
+
+ break;
+
+ case OptionExplore:
+ bExplore = TRUE;
+ break;
+
+ case OptionForce:
+ bForceMount = TRUE;
+ bForceUnmount = TRUE;
+ break;
+
+ case OptionKeyfile:
+ if (HAS_ARGUMENT == GetArgumentValue (lpszCommandLineArgs, nArgPos, &i,
+ nNoCommandLineArgs, tmpPath, sizeof (tmpPath)))
+ {
+ KeyFile *kf;
+ RelativePath2Absolute (tmpPath);
+ kf = (KeyFile *) malloc (sizeof (KeyFile));
+ strncpy (kf->FileName, tmpPath, sizeof (kf->FileName));
+ FirstCmdKeyFile = KeyFileAdd (FirstCmdKeyFile, kf);
+ }
+ break;
+
+ case OptionLetter:
+ GetArgumentValue (lpszCommandLineArgs, nArgPos, &i, nNoCommandLineArgs,
+ szDriveLetter, sizeof (szDriveLetter));
+ commandLineDrive = *szDriveLetter = (char) toupper (*szDriveLetter);
+
+ if (commandLineDrive < 'C' || commandLineDrive > 'Z')
+ AbortProcess ("BAD_DRIVE_LETTER");
+
+ break;
+
+ case OptionHistory:
+ {
+ char szTmp[8];
+ bHistory = bHistoryCmdLine = TRUE;
+
+ GetArgumentValue (lpszCommandLineArgs, nArgPos, &i, nNoCommandLineArgs,
+ szTmp, sizeof (szTmp));
+
+ if (!_stricmp(szTmp,"n") || !_stricmp(szTmp,"no"))
+ bHistory = FALSE;
+ }
+ break;
+
+ case OptionMountOption:
+ {
+ char szTmp[16];
+ if (HAS_ARGUMENT == GetArgumentValue (lpszCommandLineArgs,
+ nArgPos, &i, nNoCommandLineArgs, szTmp, sizeof (szTmp)))
+ {
+ if (!_stricmp (szTmp, "ro") || !_stricmp (szTmp, "readonly"))
+ mountOptions.ReadOnly = TRUE;
+
+ if (!_stricmp (szTmp, "rm") || !_stricmp (szTmp, "removable"))
+ mountOptions.Removable = TRUE;
+
+ if (!_stricmp (szTmp, "ts") || !_stricmp (szTmp, "timestamp"))
+ mountOptions.PreserveTimestamp = FALSE;
+
+ if (!_stricmp (szTmp, "sm") || !_stricmp (szTmp, "system"))
+ mountOptions.PartitionInInactiveSysEncScope = bPrebootPasswordDlgMode = TRUE;
+
+ if (!_stricmp (szTmp, "bk") || !_stricmp (szTmp, "headerbak"))
+ mountOptions.UseBackupHeader = TRUE;
+
+ if (!_stricmp (szTmp, "recovery"))
+ mountOptions.RecoveryMode = TRUE;
+
+ CmdMountOptions = mountOptions;
+ CmdMountOptionsValid = TRUE;
+ }
+ }
+ break;
+
+ case OptionPassword:
+ GetArgumentValue (lpszCommandLineArgs, nArgPos, &i, nNoCommandLineArgs,
+ (char *) CmdVolumePassword.Text, sizeof (CmdVolumePassword.Text));
+ CmdVolumePassword.Length = strlen ((char *) CmdVolumePassword.Text);
+ CmdVolumePasswordValid = TRUE;
+ break;
+
+ case OptionVolume:
+ if (HAS_ARGUMENT == GetArgumentValue (lpszCommandLineArgs, nArgPos, &i,
+ nNoCommandLineArgs, szFileName, sizeof (szFileName)))
+ {
+ RelativePath2Absolute (szFileName);
+ AddComboItem (GetDlgItem (hwndDlg, IDC_VOLUME), szFileName, bHistory);
+ CmdLineVolumeSpecified = TRUE;
+ }
+ break;
+
+ case OptionQuit:
+ {
+ char szTmp[32];
+
+ if (HAS_ARGUMENT == GetArgumentValue (lpszCommandLineArgs,
+ nArgPos, &i, nNoCommandLineArgs, szTmp, sizeof (szTmp)))
+ {
+ if (!_stricmp (szTmp, "UAC")) // Used to indicate non-install elevation
+ break;
+
+ if (!_stricmp (szTmp, "preferences"))
+ {
+ Quit = TRUE;
+ UsePreferences = TRUE;
+ break;
+ }
+
+ if (!_stricmp (szTmp, "background"))
+ bEnableBkgTask = TRUE;
+ }
+
+ Quit = TRUE;
+ UsePreferences = FALSE;
+ }
+ break;
+
+ case OptionSilent:
+ Silent = TRUE;
+ break;
+
+ case OptionTokenLib:
+ if (GetArgumentValue (lpszCommandLineArgs, nArgPos, &i, nNoCommandLineArgs, SecurityTokenLibraryPath, sizeof (SecurityTokenLibraryPath)) == HAS_ARGUMENT)
+ InitSecurityTokenLibrary();
+ else
+ Error ("COMMAND_LINE_ERROR");
+
+ break;
+
+ case CommandWipeCache:
+ bWipe = TRUE;
+ break;
+
+ case CommandHelp:
+ DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_COMMANDHELP_DLG), hwndDlg, (DLGPROC)
+ CommandHelpDlgProc, (LPARAM) &as);
+ exit(0);
+ break;
+
+ // no option = file name
+ default:
+ {
+ strcpy_s (szFileName, array_capacity (szFileName), lpszCommandLineArgs[i]);
+ RelativePath2Absolute (szFileName);
+
+ if (nNoCommandLineArgs == 1)
+ CmdLineVolumeSpecified = TRUE;
+ AddComboItem (GetDlgItem (hwndDlg, IDC_VOLUME), szFileName, bHistory);
+ }
+ }
+ }
+ }
+
+ /* Free up the command line arguments */
+ while (--nNoCommandLineArgs >= 0)
+ {
+ free (lpszCommandLineArgs[nNoCommandLineArgs]);
+ }
+}
+
+
+static SERVICE_STATUS SystemFavoritesServiceStatus;
+static SERVICE_STATUS_HANDLE SystemFavoritesServiceStatusHandle;
+
+
+static void SystemFavoritesServiceLogError (const string &errorMessage)
+{
+ HANDLE eventSource = RegisterEventSource (NULL, TC_SYSTEM_FAVORITES_SERVICE_NAME);
+
+ if (eventSource)
+ {
+ LPCTSTR strings[] = { TC_SYSTEM_FAVORITES_SERVICE_NAME, errorMessage.c_str() };
+ ReportEvent (eventSource, EVENTLOG_ERROR_TYPE, 0, 0xC0000001, NULL, array_capacity (strings), 0, strings, NULL);
+
+ DeregisterEventSource (eventSource);
+ }
+}
+
+
+static void SystemFavoritesServiceSetStatus (DWORD status, DWORD waitHint = 0)
+{
+ SystemFavoritesServiceStatus.dwCurrentState = status;
+ SystemFavoritesServiceStatus.dwWaitHint = waitHint;
+ SystemFavoritesServiceStatus.dwWin32ExitCode = NO_ERROR;
+
+ SetServiceStatus (SystemFavoritesServiceStatusHandle, &SystemFavoritesServiceStatus);
+}
+
+
+static VOID WINAPI SystemFavoritesServiceCtrlHandler (DWORD control)
+{
+ if (control == SERVICE_CONTROL_STOP)
+ SystemFavoritesServiceSetStatus (SERVICE_STOP_PENDING);
+ else
+ SystemFavoritesServiceSetStatus (SystemFavoritesServiceStatus.dwCurrentState);
+}
+
+
+static VOID WINAPI SystemFavoritesServiceMain (DWORD argc, LPTSTR *argv)
+{
+ memset (&SystemFavoritesServiceStatus, 0, sizeof (SystemFavoritesServiceStatus));
+ SystemFavoritesServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
+
+ SystemFavoritesServiceStatusHandle = RegisterServiceCtrlHandler (TC_SYSTEM_FAVORITES_SERVICE_NAME, SystemFavoritesServiceCtrlHandler);
+ if (!SystemFavoritesServiceStatusHandle)
+ return;
+
+ SystemFavoritesServiceSetStatus (SERVICE_START_PENDING, 60000);
+
+ try
+ {
+ MountFavoriteVolumes (TRUE);
+ }
+ catch (...) { }
+
+ SystemFavoritesServiceSetStatus (SERVICE_RUNNING);
+ SystemFavoritesServiceSetStatus (SERVICE_STOPPED);
+}
+
+
+static BOOL StartSystemFavoritesService ()
+{
+ ServiceMode = TRUE;
+ Silent = TRUE;
+ DeviceChangeBroadcastDisabled = TRUE;
+
+ InitOSVersionInfo();
+
+ if (DriverAttach() != ERR_SUCCESS)
+ return FALSE;
+
+ SERVICE_TABLE_ENTRY serviceTable[2];
+ serviceTable[0].lpServiceName = TC_SYSTEM_FAVORITES_SERVICE_NAME;
+ serviceTable[0].lpServiceProc = SystemFavoritesServiceMain;
+
+ serviceTable[1].lpServiceName = NULL;
+ serviceTable[1].lpServiceProc = NULL;
+
+ BOOL result = StartServiceCtrlDispatcher (serviceTable);
+
+ if (!(ReadDriverConfigurationFlags() & TC_DRIVER_CONFIG_CACHE_BOOT_PASSWORD))
+ WipeCache (NULL, TRUE);
+
+ return result;
+}
+
+
+int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, char *lpszCommandLine, int nCmdShow)
+{
+ int argc;
+ LPWSTR *argv = CommandLineToArgvW (GetCommandLineW(), &argc);
+
+ if (argv && argc == 2 && SingleStringToWide (TC_SYSTEM_FAVORITES_SERVICE_CMDLINE_OPTION) == argv[1])
+ return StartSystemFavoritesService() ? 0 : 1;
+
+ int status;
+ atexit (localcleanup);
+ SetProcessShutdownParameters (0x100, 0);
+
+ VirtualLock (&VolumePassword, sizeof (VolumePassword));
+ VirtualLock (&CmdVolumePassword, sizeof (CmdVolumePassword));
+ VirtualLock (&mountOptions, sizeof (mountOptions));
+ VirtualLock (&defaultMountOptions, sizeof (defaultMountOptions));
+ VirtualLock (&szFileName, sizeof(szFileName));
+
+ try
+ {
+ BootEncObj = new BootEncryption (NULL);
+ }
+ catch (Exception &e)
+ {
+ e.Show (NULL);
+ }
+
+ if (BootEncObj == NULL)
+ AbortProcess ("INIT_SYS_ENC");
+
+ InitCommonControls ();
+ InitApp (hInstance, lpszCommandLine);
+
+ RegisterRedTick(hInstance);
+
+ /* Allocate, dup, then store away the application title */
+ lpszTitle = L"TrueCrypt";
+
+ status = DriverAttach ();
+ if (status != 0)
+ {
+ if (status == ERR_OS_ERROR)
+ handleWin32Error (NULL);
+ else
+ handleError (NULL, status);
+
+ AbortProcess ("NODRIVER");
+ }
+
+ /* Create the main dialog box */
+ DialogBoxParamW (hInstance, MAKEINTRESOURCEW (IDD_MOUNT_DLG), NULL, (DLGPROC) MainDialogProc,
+ (LPARAM) lpszCommandLine);
+
+ /* Terminate */
+ return 0;
+}
+
+
+BOOL TaskBarIconAdd (HWND hwnd)
+{
+ NOTIFYICONDATAW tnid;
+
+ ZeroMemory (&tnid, sizeof (tnid));
+
+ // Only one icon may be created
+ if (TaskBarIconMutex != NULL) return TRUE;
+
+ TaskBarIconMutex = CreateMutex (NULL, TRUE, "TrueCryptTaskBarIcon");
+ if (TaskBarIconMutex == NULL || GetLastError () == ERROR_ALREADY_EXISTS)
+ {
+ TaskBarIconMutex = NULL;
+ return FALSE;
+ }
+
+ tnid.cbSize = sizeof (NOTIFYICONDATAW);
+ tnid.hWnd = hwnd;
+ tnid.uID = IDI_TRUECRYPT_ICON;
+ tnid.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
+ tnid.uCallbackMessage = TC_APPMSG_TASKBAR_ICON;
+ tnid.hIcon = (HICON) LoadImage (hInst, MAKEINTRESOURCE (IDI_TRUECRYPT_ICON),
+ IMAGE_ICON,
+ ScreenDPI >= 120 ? 0 : 16,
+ ScreenDPI >= 120 ? 0 : 16,
+ (ScreenDPI >= 120 ? LR_DEFAULTSIZE : 0)
+ | LR_SHARED
+ | (nCurrentOS != WIN_2000 ? LR_DEFAULTCOLOR : LR_VGACOLOR)); // Windows 2000 cannot display more than 16 fixed colors in notification tray
+
+ wcscpy (tnid.szTip, L"TrueCrypt");
+
+ return Shell_NotifyIconW (NIM_ADD, &tnid);
+}
+
+
+BOOL TaskBarIconRemove (HWND hwnd)
+{
+ if (TaskBarIconMutex != NULL)
+ {
+ NOTIFYICONDATA tnid;
+ BOOL res;
+
+ ZeroMemory (&tnid, sizeof (tnid));
+ tnid.cbSize = sizeof(NOTIFYICONDATA);
+ tnid.hWnd = hwnd;
+ tnid.uID = IDI_TRUECRYPT_ICON;
+
+ res = Shell_NotifyIcon (NIM_DELETE, &tnid);
+ if (TaskBarIconMutex)
+ {
+ CloseHandle (TaskBarIconMutex);
+ TaskBarIconMutex = NULL;
+ }
+ return res;
+ }
+ else
+ return FALSE;
+}
+
+
+BOOL TaskBarIconChange (HWND hwnd, int iconId)
+{
+ if (TaskBarIconMutex == NULL)
+ return FALSE;
+
+ NOTIFYICONDATA tnid;
+
+ ZeroMemory (&tnid, sizeof (tnid));
+
+ tnid.cbSize = sizeof (tnid);
+ tnid.hWnd = hwnd;
+ tnid.uID = IDI_TRUECRYPT_ICON;
+ tnid.uFlags = NIF_ICON;
+ tnid.hIcon = (HICON) LoadImage (hInst, MAKEINTRESOURCE (iconId),
+ IMAGE_ICON,
+ ScreenDPI >= 120 ? 0 : 16,
+ ScreenDPI >= 120 ? 0 : 16,
+ (ScreenDPI >= 120 ? LR_DEFAULTSIZE : 0)
+ | LR_SHARED
+ | (nCurrentOS != WIN_2000 ? LR_DEFAULTCOLOR : LR_VGACOLOR)); // Windows 2000 cannot display more than 16 fixed colors in notification tray
+
+ return Shell_NotifyIcon (NIM_MODIFY, &tnid);
+}
+
+
+void DismountIdleVolumes ()
+{
+ static DWORD lastMinTickCount;
+ static int InactivityTime[26];
+ static unsigned __int64 LastRead[26], LastWritten[26];
+ static int LastId[26];
+
+ VOLUME_PROPERTIES_STRUCT prop;
+ DWORD dwResult;
+ BOOL bResult;
+ int i;
+
+ if (GetTickCount() > lastMinTickCount && GetTickCount() - lastMinTickCount < 60 * 1000)
+ return;
+
+ lastMinTickCount = GetTickCount();
+
+ for (i = 0; i < 26; i++)
+ {
+ if (LastKnownMountList.ulMountedDrives & (1 << i))
+ {
+ memset (&prop, 0, sizeof(prop));
+ prop.driveNo = i;
+
+ bResult = DeviceIoControl (hDriver, TC_IOCTL_GET_VOLUME_PROPERTIES, &prop,
+ sizeof (prop), &prop, sizeof (prop), &dwResult, NULL);
+
+ if (bResult)
+ {
+ if (LastRead[i] == prop.totalBytesRead
+ && LastWritten[i] == prop.totalBytesWritten
+ && LastId[i] == prop.uniqueId)
+ {
+ if (++InactivityTime[i] >= MaxVolumeIdleTime)
+ {
+ BroadcastDeviceChange (DBT_DEVICEREMOVEPENDING, i, 0);
+
+ if (bCloseDismountedWindows && CloseVolumeExplorerWindows (MainDlg, i))
+ Sleep (250);
+
+ if (DriverUnmountVolume (MainDlg, i, bForceAutoDismount) == 0)
+ {
+ InactivityTime[i] = 0;
+ BroadcastDeviceChange (DBT_DEVICEREMOVECOMPLETE, i, 0);
+
+ if (bWipeCacheOnAutoDismount)
+ {
+ DeviceIoControl (hDriver, TC_IOCTL_WIPE_PASSWORD_CACHE, NULL, 0, NULL, 0, &dwResult, NULL);
+ SecurityToken::CloseAllSessions();
+ }
+ }
+ }
+ }
+ else
+ {
+ InactivityTime[i] = 0;
+ LastRead[i] = prop.totalBytesRead;
+ LastWritten[i] = prop.totalBytesWritten;
+ LastId[i] = prop.uniqueId;
+ }
+ }
+ }
+ }
+}
+
+
+BOOL MountFavoriteVolumes (BOOL systemFavorites, BOOL logOnMount, BOOL hotKeyMount, const FavoriteVolume &favoriteVolumeToMount)
+{
+ BOOL status = TRUE;
+ BOOL lastbExplore;
+ BOOL userForcedReadOnly = FALSE;
+
+ mountOptions = defaultMountOptions;
+
+ VolumePassword.Length = 0;
+ MultipleMountOperationInProgress = (favoriteVolumeToMount.Path.empty() || FavoriteMountOnArrivalInProgress);
+
+ vector <FavoriteVolume> favorites;
+
+ if (systemFavorites)
+ {
+ try
+ {
+ LoadFavoriteVolumes (favorites, true);
+ }
+ catch (...)
+ {
+ return false;
+ }
+ }
+ else if (!favoriteVolumeToMount.Path.empty())
+ favorites.push_back (favoriteVolumeToMount);
+ else
+ favorites = FavoriteVolumes;
+
+ foreach (const FavoriteVolume &favorite, favorites)
+ {
+ if (favorite.DisconnectedDevice
+ || (logOnMount && !favorite.MountOnLogOn)
+ || (hotKeyMount && favorite.DisableHotkeyMount))
+ {
+ continue;
+ }
+
+ int drive;
+ drive = toupper (favorite.MountPoint[0]) - 'A';
+
+ mountOptions.ReadOnly = favorite.ReadOnly || userForcedReadOnly;
+ mountOptions.Removable = favorite.Removable;
+
+ if (favorite.SystemEncryption)
+ {
+ mountOptions.PartitionInInactiveSysEncScope = TRUE;
+ bPrebootPasswordDlgMode = TRUE;
+ }
+ else
+ {
+ mountOptions.PartitionInInactiveSysEncScope = FALSE;
+ bPrebootPasswordDlgMode = FALSE;
+ }
+
+ if ((LastKnownMountList.ulMountedDrives & (1 << drive)) == 0)
+ {
+ MountVolumesAsSystemFavorite = systemFavorites;
+
+ string mountPoint = (char) (drive + 'A') + string (":\\");
+ char prevVolumeAtMountPoint[MAX_PATH] = { 0 };
+
+ if (systemFavorites)
+ {
+ // Partitions of new drives are assigned free drive letters by Windows on boot. Make sure this does not prevent system favorite volumes
+ // from being mounted. Each partition (using the same drive letter as a system favorite volume) is assigned another free drive letter.
+
+ if (GetVolumeNameForVolumeMountPoint (mountPoint.c_str(), prevVolumeAtMountPoint, sizeof (prevVolumeAtMountPoint)))
+ DeleteVolumeMountPoint (mountPoint.c_str());
+ else
+ prevVolumeAtMountPoint[0] = 0;
+ }
+
+ lastbExplore = bExplore;
+
+ bExplore = (BOOL) favorite.OpenExplorerWindow;
+
+ if (!systemFavorites
+ && !logOnMount
+ && !hotKeyMount
+ && !favoriteVolumeToMount.Path.empty()
+ && GetAsyncKeyState (VK_CONTROL) < 0)
+ {
+ if (DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_MOUNT_OPTIONS), MainDlg, MountOptionsDlgProc, (LPARAM) &mountOptions) == IDCANCEL)
+ {
+ status = FALSE;
+ goto skipMount;
+ }
+ }
+
+ BOOL prevReadOnly = mountOptions.ReadOnly;
+
+ if (!Mount (MainDlg, drive, (char *) favorite.Path.c_str()))
+ status = FALSE;
+
+ if (status && mountOptions.ReadOnly != prevReadOnly)
+ userForcedReadOnly = mountOptions.ReadOnly;
+
+skipMount:
+ bExplore = lastbExplore;
+
+ if (systemFavorites && prevVolumeAtMountPoint[0])
+ {
+ if (status)
+ {
+ int freeDrive = GetFirstAvailableDrive();
+ if (freeDrive != -1)
+ {
+ mountPoint[0] = (char) (freeDrive + 'A');
+ SetVolumeMountPoint (mountPoint.c_str(), prevVolumeAtMountPoint);
+ }
+ }
+ else
+ SetVolumeMountPoint (mountPoint.c_str(), prevVolumeAtMountPoint);
+ }
+
+ LoadDriveLetters (GetDlgItem (MainDlg, IDC_DRIVELIST), 0);
+
+ MountVolumesAsSystemFavorite = FALSE;
+
+ if (ServiceMode && LastMountedVolumeDirty)
+ {
+ DWORD bytesOut;
+ DeviceIoControl (hDriver, TC_IOCTL_SET_SYSTEM_FAVORITE_VOLUME_DIRTY, NULL, 0, NULL, 0, &bytesOut, NULL);
+
+ SystemFavoritesServiceLogError (string ("The filesystem of the volume mounted as ") + (char) (drive + 'A') + ": was not cleanly dismounted and needs to be checked for errors.");
+ }
+ }
+ else if (!systemFavorites && !favoriteVolumeToMount.Path.empty())
+ Error ("DRIVE_LETTER_UNAVAILABLE");
+ }
+
+ MultipleMountOperationInProgress = FALSE;
+ burn (&VolumePassword, sizeof (VolumePassword));
+
+ if (status && CloseSecurityTokenSessionsAfterMount)
+ SecurityToken::CloseAllSessions();
+
+ return status;
+}
+
+
+static void SaveDefaultKeyFilesParam (void)
+{
+ if (defaultKeyFilesParam.FirstKeyFile == NULL)
+ {
+ /* No keyfiles selected */
+ remove (GetConfigPath (TC_APPD_FILENAME_DEFAULT_KEYFILES));
+ }
+ else
+ {
+ FILE *f;
+ KeyFile *kf = FirstKeyFile;
+
+ f = fopen (GetConfigPath (TC_APPD_FILENAME_DEFAULT_KEYFILES), "w");
+ if (f == NULL)
+ {
+ handleWin32Error (MainDlg);
+ return;
+ }
+
+ XmlWriteHeader (f);
+
+ fputs ("\n\t<defaultkeyfiles>", f);
+
+ while (kf != NULL)
+ {
+ char q[TC_MAX_PATH * 2];
+
+ XmlQuoteText (kf->FileName, q, sizeof (q));
+ fprintf (f, "\n\t\t<keyfile>%s</keyfile>", q);
+
+ kf = kf->Next;
+ }
+
+ fputs ("\n\t</defaultkeyfiles>", f);
+
+ XmlWriteFooter (f);
+
+ CheckFileStreamWriteErrors (f, TC_APPD_FILENAME_DEFAULT_KEYFILES);
+ fclose (f);
+ return;
+ }
+}
+
+
+static void KeyfileDefaultsDlg (HWND hwndDlg)
+{
+ KeyFilesDlgParam param;
+
+ param.EnableKeyFiles = defaultKeyFilesParam.EnableKeyFiles;
+ param.FirstKeyFile = defaultKeyFilesParam.FirstKeyFile;
+
+ if (DialogBoxParamW (hInst,
+ MAKEINTRESOURCEW (IDD_KEYFILES), hwndDlg,
+ (DLGPROC) KeyFilesDlgProc, (LPARAM) &param) == IDOK)
+ {
+ if (!param.EnableKeyFiles || AskWarnYesNo ("CONFIRM_SAVE_DEFAULT_KEYFILES") == IDYES)
+ {
+ KeyFileRemoveAll (&defaultKeyFilesParam.FirstKeyFile);
+ defaultKeyFilesParam.EnableKeyFiles = param.EnableKeyFiles;
+ defaultKeyFilesParam.FirstKeyFile = param.FirstKeyFile;
+
+ RestoreDefaultKeyFilesParam ();
+ SaveDefaultKeyFilesParam ();
+ }
+ }
+}
+
+
+static void HandleHotKey (HWND hwndDlg, WPARAM wParam)
+{
+ DWORD dwResult;
+ BOOL success = TRUE;
+
+ switch (wParam)
+ {
+ case HK_AUTOMOUNT_DEVICES:
+ MountAllDevices (hwndDlg, TRUE);
+ break;
+
+ case HK_DISMOUNT_ALL:
+ case HK_DISMOUNT_ALL_AND_WIPE:
+
+ if (wParam == HK_DISMOUNT_ALL_AND_WIPE)
+ WipeCache (hwndDlg, TRUE);
+
+ if (DismountAll (hwndDlg, FALSE, TRUE, UNMOUNT_MAX_AUTO_RETRIES, UNMOUNT_AUTO_RETRY_DELAY))
+ {
+ if (bDisplayBalloonOnSuccessfulHkDismount)
+ InfoBalloon ("SUCCESSFULLY_DISMOUNTED", (wParam == HK_DISMOUNT_ALL_AND_WIPE ? "VOLUMES_DISMOUNTED_CACHE_WIPED" : "MOUNTED_VOLUMES_DISMOUNTED"));
+
+ if (bPlaySoundOnSuccessfulHkDismount)
+ MessageBeep (0xFFFFFFFF);
+ }
+
+ break;
+
+ case HK_WIPE_CACHE:
+ WipeCache (hwndDlg, FALSE);
+
+ break;
+
+ case HK_FORCE_DISMOUNT_ALL_AND_WIPE:
+ success = DismountAll (hwndDlg, TRUE, FALSE, UNMOUNT_MAX_AUTO_RETRIES, UNMOUNT_AUTO_RETRY_DELAY);
+ success &= DeviceIoControl (hDriver, TC_IOCTL_WIPE_PASSWORD_CACHE, NULL, 0, NULL, 0, &dwResult, NULL);
+ if (success)
+ {
+ if (bDisplayBalloonOnSuccessfulHkDismount)
+ InfoBalloon ("SUCCESSFULLY_DISMOUNTED", "VOLUMES_DISMOUNTED_CACHE_WIPED");
+
+ if (bPlaySoundOnSuccessfulHkDismount)
+ MessageBeep (0xFFFFFFFF);
+ }
+ break;
+
+ case HK_FORCE_DISMOUNT_ALL_AND_WIPE_AND_EXIT:
+ success = DismountAll (hwndDlg, TRUE, FALSE, UNMOUNT_MAX_AUTO_RETRIES, UNMOUNT_AUTO_RETRY_DELAY);
+ success &= DeviceIoControl (hDriver, TC_IOCTL_WIPE_PASSWORD_CACHE, NULL, 0, NULL, 0, &dwResult, NULL);
+ if (success)
+ {
+ if (bDisplayBalloonOnSuccessfulHkDismount)
+ InfoBalloon ("SUCCESSFULLY_DISMOUNTED", "VOLUMES_DISMOUNTED_CACHE_WIPED");
+
+ if (bPlaySoundOnSuccessfulHkDismount)
+ MessageBeep (0xFFFFFFFF);
+ }
+ TaskBarIconRemove (hwndDlg);
+ EndMainDlg (hwndDlg);
+ break;
+
+ case HK_MOUNT_FAVORITE_VOLUMES:
+ MountFavoriteVolumes (FALSE, FALSE, TRUE);
+ break;
+
+ case HK_SHOW_HIDE_MAIN_WINDOW:
+ ChangeMainWindowVisibility ();
+ break;
+
+ case HK_CLOSE_SECURITY_TOKEN_SESSIONS:
+ SecurityToken::CloseAllSessions();
+
+ InfoBalloon (NULL, "ALL_TOKEN_SESSIONS_CLOSED");
+
+ break;
+ }
+}
+
+
+void ChangeMainWindowVisibility ()
+{
+ MainWindowHidden = !MainWindowHidden;
+
+ if (!MainWindowHidden)
+ SetForegroundWindow (MainDlg);
+
+ ShowWindow (MainDlg, !MainWindowHidden ? SW_SHOW : SW_HIDE);
+
+ if (!MainWindowHidden)
+ ShowWindow (MainDlg, SW_RESTORE);
+}
+
+
+int BackupVolumeHeader (HWND hwndDlg, BOOL bRequireConfirmation, char *lpszVolume)
+{
+ int nStatus = ERR_OS_ERROR;
+ wchar_t szTmp[4096];
+ int fBackup = -1;
+ OpenVolumeContext volume;
+ OpenVolumeContext hiddenVolume;
+ Password hiddenVolPassword;
+ byte temporaryKey[MASTER_KEYDATA_SIZE];
+ byte originalK2[MASTER_KEYDATA_SIZE];
+
+ volume.VolumeIsOpen = FALSE;
+ hiddenVolume.VolumeIsOpen = FALSE;
+
+ switch (IsSystemDevicePath (lpszVolume, hwndDlg, TRUE))
+ {
+ case 1:
+ case 2:
+ if (AskErrNoYes ("BACKUP_HEADER_NOT_FOR_SYS_DEVICE") == IDYES)
+ CreateRescueDisk ();
+
+ return 0;
+ }
+
+ if (IsMountedVolume (lpszVolume))
+ {
+ Warning ("DISMOUNT_FIRST");
+ goto ret;
+ }
+
+ if (!VolumePathExists (lpszVolume))
+ {
+ handleWin32Error (hwndDlg);
+ goto ret;
+ }
+
+ Info ("EXTERNAL_VOL_HEADER_BAK_FIRST_INFO");
+
+
+ WaitCursor();
+
+ // Open both types of volumes
+ for (int type = TC_VOLUME_TYPE_NORMAL; type <= TC_VOLUME_TYPE_HIDDEN; ++type)
+ {
+ OpenVolumeContext *askVol = (type == TC_VOLUME_TYPE_HIDDEN ? &hiddenVolume : &volume);
+ Password *askPassword = (type == TC_VOLUME_TYPE_HIDDEN ? &hiddenVolPassword : &VolumePassword);
+
+ while (TRUE)
+ {
+ if (!AskVolumePassword (hwndDlg, askPassword, type == TC_VOLUME_TYPE_HIDDEN ? "ENTER_HIDDEN_VOL_PASSWORD" : "ENTER_NORMAL_VOL_PASSWORD", FALSE))
+ {
+ nStatus = ERR_SUCCESS;
+ goto ret;
+ }
+
+ WaitCursor();
+
+ if (KeyFilesEnable && FirstKeyFile)
+ KeyFilesApply (askPassword, FirstKeyFile);
+
+ nStatus = OpenVolume (askVol, lpszVolume, askPassword, FALSE, bPreserveTimestamp, FALSE);
+
+ NormalCursor();
+
+ if (nStatus == ERR_SUCCESS)
+ {
+ if ((type == TC_VOLUME_TYPE_NORMAL && askVol->CryptoInfo->hiddenVolume)
+ || (type == TC_VOLUME_TYPE_HIDDEN && !askVol->CryptoInfo->hiddenVolume))
+ {
+ CloseVolume (askVol);
+ handleError (hwndDlg, ERR_PASSWORD_WRONG);
+ continue;
+ }
+
+ RandSetHashFunction (askVol->CryptoInfo->pkcs5);
+
+ if (type == TC_VOLUME_TYPE_NORMAL)
+ {
+ // Ask the user if there is a hidden volume
+ char *volTypeChoices[] = {0, "DOES_VOLUME_CONTAIN_HIDDEN", "VOLUME_CONTAINS_HIDDEN", "VOLUME_DOES_NOT_CONTAIN_HIDDEN", "IDCANCEL", 0};
+ switch (AskMultiChoice ((void **) volTypeChoices, FALSE))
+ {
+ case 1:
+ break;
+ case 2:
+ goto noHidden;
+
+ default:
+ nStatus = ERR_SUCCESS;
+ goto ret;
+ }
+ }
+
+ break;
+ }
+
+ if (nStatus != ERR_PASSWORD_WRONG)
+ goto error;
+
+ handleError (hwndDlg, nStatus);
+ }
+ }
+noHidden:
+
+ if (hiddenVolume.VolumeIsOpen && volume.CryptoInfo->LegacyVolume != hiddenVolume.CryptoInfo->LegacyVolume)
+ {
+ nStatus = ERR_PARAMETER_INCORRECT;
+ goto error;
+ }
+
+ swprintf (szTmp, GetString ("CONFIRM_VOL_HEADER_BAK"), lpszVolume);
+
+ if (bRequireConfirmation
+ && (MessageBoxW (hwndDlg, szTmp, lpszTitle, YES_NO|MB_ICONQUESTION|MB_DEFBUTTON1) == IDNO))
+ goto ret;
+
+ /* Select backup file */
+ if (!BrowseFiles (hwndDlg, "OPEN_TITLE", szFileName, bHistory, TRUE, NULL))
+ goto ret;
+
+ /* Conceive the backup file */
+ if ((fBackup = _open(szFileName, _O_CREAT|_O_TRUNC|_O_WRONLY|_O_BINARY, _S_IREAD|_S_IWRITE)) == -1)
+ {
+ nStatus = ERR_OS_ERROR;
+ goto error;
+ }
+
+ // Backup headers
+
+ byte backup[TC_VOLUME_HEADER_GROUP_SIZE];
+
+ bool legacyVolume = volume.CryptoInfo->LegacyVolume ? true : false;
+ int backupFileSize = legacyVolume ? TC_VOLUME_HEADER_SIZE_LEGACY * 2 : TC_VOLUME_HEADER_GROUP_SIZE;
+
+ // Fill backup buffer with random data
+ memcpy (originalK2, volume.CryptoInfo->k2, sizeof (volume.CryptoInfo->k2));
+
+ if (Randinit() != ERR_SUCCESS)
+ {
+ nStatus = ERR_PARAMETER_INCORRECT;
+ goto error;
+ }
+
+ NormalCursor();
+ UserEnrichRandomPool (hwndDlg);
+ WaitCursor();
+
+ // Temporary keys
+ if (!RandgetBytes (temporaryKey, EAGetKeySize (volume.CryptoInfo->ea), TRUE)
+ || !RandgetBytes (volume.CryptoInfo->k2, sizeof (volume.CryptoInfo->k2), FALSE))
+ {
+ nStatus = ERR_PARAMETER_INCORRECT;
+ goto error;
+ }
+
+ if (EAInit (volume.CryptoInfo->ea, temporaryKey, volume.CryptoInfo->ks) != ERR_SUCCESS || !EAInitMode (volume.CryptoInfo))
+ {
+ nStatus = ERR_PARAMETER_INCORRECT;
+ goto error;
+ }
+
+ EncryptBuffer (backup, backupFileSize, volume.CryptoInfo);
+
+ memcpy (volume.CryptoInfo->k2, originalK2, sizeof (volume.CryptoInfo->k2));
+ if (EAInit (volume.CryptoInfo->ea, volume.CryptoInfo->master_keydata, volume.CryptoInfo->ks) != ERR_SUCCESS || !EAInitMode (volume.CryptoInfo))
+ {
+ nStatus = ERR_PARAMETER_INCORRECT;
+ goto error;
+ }
+
+ // Store header encrypted with a new key
+ nStatus = ReEncryptVolumeHeader ((char *) backup, FALSE, volume.CryptoInfo, &VolumePassword, FALSE);
+ if (nStatus != ERR_SUCCESS)
+ goto error;
+
+ if (hiddenVolume.VolumeIsOpen)
+ {
+ nStatus = ReEncryptVolumeHeader ((char *) backup + (legacyVolume ? TC_VOLUME_HEADER_SIZE_LEGACY : TC_VOLUME_HEADER_SIZE),
+ FALSE, hiddenVolume.CryptoInfo, &hiddenVolPassword, FALSE);
+
+ if (nStatus != ERR_SUCCESS)
+ goto error;
+ }
+
+ if (_write (fBackup, backup, backupFileSize) == -1)
+ {
+ nStatus = ERR_OS_ERROR;
+ goto error;
+ }
+
+ /* Backup has been successfully created */
+ Warning("VOL_HEADER_BACKED_UP");
+
+ret:
+ nStatus = ERR_SUCCESS;
+
+error:
+ DWORD dwError = GetLastError ();
+
+ CloseVolume (&volume);
+ CloseVolume (&hiddenVolume);
+
+ if (fBackup != -1)
+ _close (fBackup);
+
+ SetLastError (dwError);
+ if (nStatus != 0)
+ handleError (hwndDlg, nStatus);
+
+ burn (&VolumePassword, sizeof (VolumePassword));
+ burn (&hiddenVolPassword, sizeof (hiddenVolPassword));
+ burn (temporaryKey, sizeof (temporaryKey));
+ burn (originalK2, sizeof (originalK2));
+
+ RestoreDefaultKeyFilesParam();
+ RandStop (FALSE);
+ NormalCursor();
+
+ return nStatus;
+}
+
+
+int RestoreVolumeHeader (HWND hwndDlg, char *lpszVolume)
+{
+ int nDosLinkCreated = -1, nStatus = ERR_OS_ERROR;
+ char szDiskFile[TC_MAX_PATH], szCFDevice[TC_MAX_PATH];
+ char szFileName[TC_MAX_PATH];
+ char szDosDevice[TC_MAX_PATH];
+ void *dev = INVALID_HANDLE_VALUE;
+ DWORD dwError;
+ BOOL bDevice;
+ unsigned __int64 hostSize = 0;
+ FILETIME ftCreationTime;
+ FILETIME ftLastWriteTime;
+ FILETIME ftLastAccessTime;
+ wchar_t szTmp[4096];
+ BOOL bTimeStampValid = FALSE;
+ HANDLE fBackup = INVALID_HANDLE_VALUE;
+ LARGE_INTEGER headerOffset;
+ CRYPTO_INFO *restoredCryptoInfo = NULL;
+
+ switch (IsSystemDevicePath (lpszVolume, hwndDlg, TRUE))
+ {
+ case 1:
+ case 2:
+ if (AskErrNoYes ("RESTORE_HEADER_NOT_FOR_SYS_DEVICE") == IDYES)
+ CreateRescueDisk ();
+
+ return 0;
+
+ case -1:
+ // In some environments (such as PE), the system volume is not located on a hard drive.
+ // Therefore, we must interpret this return code as "Not a system device path" (otherwise,
+ // it would not be possible to restore headers on non-system devices in such environments).
+ // Note that this is rather safe, because bReliableRequired is set to TRUE.
+
+ // NOP
+ break;
+ }
+
+ if (IsMountedVolume (lpszVolume))
+ {
+ Warning ("DISMOUNT_FIRST");
+ return 0;
+ }
+
+ if (!VolumePathExists (lpszVolume))
+ {
+ handleWin32Error (hwndDlg);
+ return 0;
+ }
+
+ BOOL restoreInternalBackup;
+
+ // Ask the user to select the type of backup (internal/external)
+ char *volTypeChoices[] = {0, "HEADER_RESTORE_EXTERNAL_INTERNAL", "HEADER_RESTORE_INTERNAL", "HEADER_RESTORE_EXTERNAL", "IDCANCEL", 0};
+ switch (AskMultiChoice ((void **) volTypeChoices, FALSE))
+ {
+ case 1:
+ restoreInternalBackup = TRUE;
+ break;
+ case 2:
+ restoreInternalBackup = FALSE;
+ break;
+ default:
+ return 0;
+ }
+
+ OpenVolumeContext volume;
+ volume.VolumeIsOpen = FALSE;
+
+ WaitCursor();
+
+ if (restoreInternalBackup)
+ {
+ // Restore header from the internal backup
+
+ // Open the volume using backup header
+ while (TRUE)
+ {
+ strncpy (PasswordDlgVolume, lpszVolume, sizeof (PasswordDlgVolume));
+ if (!AskVolumePassword (hwndDlg, &VolumePassword, NULL, FALSE))
+ {
+ nStatus = ERR_SUCCESS;
+ goto ret;
+ }
+
+ WaitCursor();
+
+ if (KeyFilesEnable && FirstKeyFile)
+ KeyFilesApply (&VolumePassword, FirstKeyFile);
+
+ nStatus = OpenVolume (&volume, lpszVolume, &VolumePassword, TRUE, bPreserveTimestamp, TRUE);
+
+ NormalCursor();
+
+ if (nStatus == ERR_SUCCESS)
+ break;
+
+ if (nStatus != ERR_PASSWORD_WRONG)
+ goto error;
+
+ handleError (hwndDlg, nStatus);
+ }
+
+ if (volume.CryptoInfo->LegacyVolume)
+ {
+ Error ("VOLUME_HAS_NO_BACKUP_HEADER");
+ nStatus = ERROR_SUCCESS;
+ goto error;
+ }
+
+ // Create a new header with a new salt
+ char buffer[TC_VOLUME_HEADER_EFFECTIVE_SIZE];
+
+ nStatus = ReEncryptVolumeHeader (buffer, FALSE, volume.CryptoInfo, &VolumePassword, FALSE);
+ if (nStatus != 0)
+ goto error;
+
+ headerOffset.QuadPart = volume.CryptoInfo->hiddenVolume ? TC_HIDDEN_VOLUME_HEADER_OFFSET : TC_VOLUME_HEADER_OFFSET;
+ if (!SetFilePointerEx (volume.HostFileHandle, headerOffset, NULL, FILE_BEGIN))
+ {
+ nStatus = ERR_OS_ERROR;
+ goto error;
+ }
+
+ if (!WriteEffectiveVolumeHeader (volume.IsDevice, volume.HostFileHandle, (byte *) buffer))
+ {
+ nStatus = ERR_OS_ERROR;
+ goto error;
+ }
+ }
+ else
+ {
+ // Restore header from an external backup
+
+ swprintf (szTmp, GetString ("CONFIRM_VOL_HEADER_RESTORE"), lpszVolume);
+
+ if (MessageBoxW (hwndDlg, szTmp, lpszTitle, YES_NO|MB_ICONWARNING|MB_DEFBUTTON2) == IDNO)
+ {
+ nStatus = ERR_SUCCESS;
+ goto ret;
+ }
+
+ /* Select backup file */
+ if (!BrowseFiles (hwndDlg, "OPEN_TITLE", szFileName, bHistory, FALSE, NULL))
+ {
+ nStatus = ERR_SUCCESS;
+ goto ret;
+ }
+
+ /* Open the backup file */
+ fBackup = CreateFile (szFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
+ if (fBackup == INVALID_HANDLE_VALUE)
+ {
+ nStatus = ERR_OS_ERROR;
+ goto error;
+ }
+
+ // Determine size of the backup file
+ LARGE_INTEGER backupSize;
+ if (!GetFileSizeEx (fBackup, &backupSize))
+ {
+ nStatus = ERR_OS_ERROR;
+ goto error;
+ }
+
+ CreateFullVolumePath (szDiskFile, lpszVolume, &bDevice);
+
+ if (bDevice == FALSE)
+ strcpy (szCFDevice, szDiskFile);
+ else
+ {
+ nDosLinkCreated = FakeDosNameForDevice (szDiskFile, szDosDevice, szCFDevice, FALSE);
+ if (nDosLinkCreated != 0)
+ goto error;
+ }
+
+ // Open the volume
+ dev = CreateFile (szCFDevice, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
+
+ if (dev == INVALID_HANDLE_VALUE)
+ {
+ nStatus = ERR_OS_ERROR;
+ goto error;
+ }
+
+ // Determine volume host size
+ if (bDevice)
+ {
+ PARTITION_INFORMATION diskInfo;
+ DWORD dwResult;
+ BOOL bResult;
+
+ bResult = GetPartitionInfo (lpszVolume, &diskInfo);
+
+ if (bResult)
+ {
+ hostSize = diskInfo.PartitionLength.QuadPart;
+ }
+ else
+ {
+ DISK_GEOMETRY driveInfo;
+
+ bResult = DeviceIoControl (dev, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0,
+ &driveInfo, sizeof (driveInfo), &dwResult, NULL);
+
+ if (!bResult)
+ goto error;
+
+ hostSize = driveInfo.Cylinders.QuadPart * driveInfo.BytesPerSector *
+ driveInfo.SectorsPerTrack * driveInfo.TracksPerCylinder;
+ }
+
+ if (hostSize == 0)
+ {
+ nStatus = ERR_VOL_SIZE_WRONG;
+ goto error;
+ }
+ }
+ else
+ {
+ LARGE_INTEGER fileSize;
+ if (!GetFileSizeEx (dev, &fileSize))
+ {
+ nStatus = ERR_OS_ERROR;
+ goto error;
+ }
+
+ hostSize = fileSize.QuadPart;
+ }
+
+ if (!bDevice && bPreserveTimestamp)
+ {
+ /* Remember the container modification/creation date and time. */
+
+ if (GetFileTime ((HANDLE) dev, &ftCreationTime, &ftLastAccessTime, &ftLastWriteTime) == 0)
+ bTimeStampValid = FALSE;
+ else
+ bTimeStampValid = TRUE;
+ }
+
+ /* Read the volume header from the backup file */
+ char buffer[TC_VOLUME_HEADER_GROUP_SIZE];
+
+ DWORD bytesRead;
+ if (!ReadFile (fBackup, buffer, sizeof (buffer), &bytesRead, NULL))
+ {
+ nStatus = ERR_OS_ERROR;
+ goto error;
+ }
+
+ if (bytesRead != backupSize.QuadPart)
+ {
+ nStatus = ERR_VOL_SIZE_WRONG;
+ goto error;
+ }
+
+ LARGE_INTEGER headerOffset;
+ LARGE_INTEGER headerBackupOffset;
+ bool legacyBackup;
+ int headerOffsetBackupFile;
+
+ // Determine the format of the backup file
+ switch (backupSize.QuadPart)
+ {
+ case TC_VOLUME_HEADER_GROUP_SIZE:
+ legacyBackup = false;
+ break;
+
+ case TC_VOLUME_HEADER_SIZE_LEGACY * 2:
+ legacyBackup = true;
+ break;
+
+ default:
+ Error ("HEADER_BACKUP_SIZE_INCORRECT");
+ nStatus = ERR_SUCCESS;
+ goto error;
+ }
+
+ // Open the header
+ while (TRUE)
+ {
+ if (!AskVolumePassword (hwndDlg, &VolumePassword, "ENTER_HEADER_BACKUP_PASSWORD", FALSE))
+ {
+ nStatus = ERR_SUCCESS;
+ goto ret;
+ }
+
+ if (KeyFilesEnable && FirstKeyFile)
+ KeyFilesApply (&VolumePassword, FirstKeyFile);
+
+ // Decrypt volume header
+ headerOffsetBackupFile = 0;
+ for (int type = TC_VOLUME_TYPE_NORMAL; type <= TC_VOLUME_TYPE_HIDDEN; ++type)
+ {
+ if (type == TC_VOLUME_TYPE_HIDDEN)
+ headerOffsetBackupFile += (legacyBackup ? TC_VOLUME_HEADER_SIZE_LEGACY : TC_VOLUME_HEADER_SIZE);
+
+ nStatus = ReadVolumeHeader (FALSE, buffer + headerOffsetBackupFile, &VolumePassword, &restoredCryptoInfo, NULL);
+ if (nStatus == ERR_SUCCESS)
+ break;
+ }
+
+ if (nStatus == ERR_SUCCESS)
+ break;
+
+ if (nStatus != ERR_PASSWORD_WRONG)
+ goto error;
+
+ handleError (hwndDlg, nStatus);
+ }
+
+ BOOL hiddenVol = restoredCryptoInfo->hiddenVolume;
+
+ if (legacyBackup)
+ {
+ headerOffset.QuadPart = hiddenVol ? hostSize - TC_HIDDEN_VOLUME_HEADER_OFFSET_LEGACY : TC_VOLUME_HEADER_OFFSET;
+ }
+ else
+ {
+ headerOffset.QuadPart = hiddenVol ? TC_HIDDEN_VOLUME_HEADER_OFFSET : TC_VOLUME_HEADER_OFFSET;
+ headerBackupOffset.QuadPart = hiddenVol ? hostSize - TC_VOLUME_HEADER_SIZE : hostSize - TC_VOLUME_HEADER_GROUP_SIZE;
+ }
+
+ WaitCursor();
+
+ // Restore header encrypted with a new key
+ nStatus = ReEncryptVolumeHeader (buffer, FALSE, restoredCryptoInfo, &VolumePassword, FALSE);
+ if (nStatus != ERR_SUCCESS)
+ goto error;
+
+ if (!SetFilePointerEx (dev, headerOffset, NULL, FILE_BEGIN))
+ {
+ nStatus = ERR_OS_ERROR;
+ goto error;
+ }
+
+ if (!WriteEffectiveVolumeHeader (bDevice, dev, (byte *) buffer))
+ {
+ nStatus = ERR_OS_ERROR;
+ goto error;
+ }
+
+ if (!restoredCryptoInfo->LegacyVolume)
+ {
+ // Restore backup header encrypted with a new key
+ nStatus = ReEncryptVolumeHeader (buffer, FALSE, restoredCryptoInfo, &VolumePassword, FALSE);
+ if (nStatus != ERR_SUCCESS)
+ goto error;
+
+ if (!SetFilePointerEx (dev, headerBackupOffset, NULL, FILE_BEGIN))
+ {
+ nStatus = ERR_OS_ERROR;
+ goto error;
+ }
+
+ if (!WriteEffectiveVolumeHeader (bDevice, dev, (byte *) buffer))
+ {
+ nStatus = ERR_OS_ERROR;
+ goto error;
+ }
+ }
+ }
+
+
+ /* Volume header has been successfully restored */
+
+ Info("VOL_HEADER_RESTORED");
+ret:
+ nStatus = ERR_SUCCESS;
+
+error:
+ dwError = GetLastError ();
+ NormalCursor();
+
+ if (restoreInternalBackup)
+ {
+ CloseVolume (&volume);
+ }
+ else
+ {
+ if (restoredCryptoInfo)
+ crypto_close (restoredCryptoInfo);
+
+ if (bTimeStampValid)
+ SetFileTime (dev, &ftCreationTime, &ftLastAccessTime, &ftLastWriteTime);
+
+ if (dev != INVALID_HANDLE_VALUE)
+ CloseHandle (dev);
+
+ if (fBackup != INVALID_HANDLE_VALUE)
+ CloseHandle (fBackup);
+
+ if (nDosLinkCreated == 0)
+ RemoveFakeDosName (szDiskFile, szDosDevice);
+ }
+
+ SetLastError (dwError);
+ if (nStatus != 0)
+ handleError (hwndDlg, nStatus);
+
+ burn (&VolumePassword, sizeof (VolumePassword));
+ RestoreDefaultKeyFilesParam();
+ RandStop (FALSE);
+ NormalCursor();
+
+ return nStatus;
+}
+
+
+void SetDriverConfigurationFlag (uint32 flag, BOOL state)
+{
+ BootEncObj->SetDriverConfigurationFlag (flag, state ? true : false);
+}
+
+
+static BOOL CALLBACK PerformanceSettingsDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+ WORD lw = LOWORD (wParam);
+
+ switch (msg)
+ {
+ case WM_INITDIALOG:
+ {
+ LocalizeDialog (hwndDlg, "IDD_PERFORMANCE_SETTINGS");
+
+ uint32 driverConfig = ReadDriverConfigurationFlags();
+ CheckDlgButton (hwndDlg, IDC_ENABLE_HARDWARE_ENCRYPTION, (driverConfig & TC_DRIVER_CONFIG_DISABLE_HARDWARE_ENCRYPTION) ? BST_UNCHECKED : BST_CHECKED);
+
+ SYSTEM_INFO sysInfo;
+ GetSystemInfo (&sysInfo);
+
+ HWND freeCpuCombo = GetDlgItem (hwndDlg, IDC_ENCRYPTION_FREE_CPU_COUNT);
+ uint32 encryptionFreeCpuCount = ReadEncryptionThreadPoolFreeCpuCountLimit();
+
+ if (encryptionFreeCpuCount > sysInfo.dwNumberOfProcessors - 1)
+ encryptionFreeCpuCount = sysInfo.dwNumberOfProcessors - 1;
+
+ for (uint32 i = 1; i < sysInfo.dwNumberOfProcessors; ++i)
+ {
+ stringstream s;
+ s << i;
+ AddComboPair (freeCpuCombo, s.str().c_str(), i);
+ }
+
+ if (sysInfo.dwNumberOfProcessors < 2 || encryptionFreeCpuCount == 0)
+ EnableWindow (freeCpuCombo, FALSE);
+
+ if (sysInfo.dwNumberOfProcessors < 2)
+ EnableWindow (GetDlgItem (hwndDlg, IDC_LIMIT_ENC_THREAD_POOL), FALSE);
+
+ if (encryptionFreeCpuCount != 0)
+ {
+ CheckDlgButton (hwndDlg, IDC_LIMIT_ENC_THREAD_POOL, BST_CHECKED);
+ SendMessage (freeCpuCombo, CB_SETCURSEL, encryptionFreeCpuCount - 1, 0);
+ }
+
+ SetWindowTextW (GetDlgItem (hwndDlg, IDT_LIMIT_ENC_THREAD_POOL_NOTE), GetString("LIMIT_ENC_THREAD_POOL_NOTE"));
+
+ SetDlgItemTextW (hwndDlg, IDC_HW_AES_SUPPORTED_BY_CPU, (wstring (L" ") + (GetString (is_aes_hw_cpu_supported() ? "UISTR_YES" : "UISTR_NO"))).c_str());
+
+ ToHyperlink (hwndDlg, IDC_MORE_INFO_ON_HW_ACCELERATION);
+ ToHyperlink (hwndDlg, IDC_MORE_INFO_ON_THREAD_BASED_PARALLELIZATION);
+ }
+ return 0;
+
+ case WM_COMMAND:
+
+ switch (lw)
+ {
+ case IDCANCEL:
+ EndDialog (hwndDlg, lw);
+ return 1;
+
+ case IDOK:
+ {
+ if (IsNonInstallMode())
+ {
+ Error ("FEATURE_REQUIRES_INSTALLATION");
+ EndDialog (hwndDlg, IDCANCEL);
+ return 1;
+ }
+
+ BOOL disableHW = !IsDlgButtonChecked (hwndDlg, IDC_ENABLE_HARDWARE_ENCRYPTION);
+
+ try
+ {
+ try
+ {
+ BootEncStatus = BootEncObj->GetStatus();
+ }
+ catch (...)
+ {
+ BootEncStatus.DriveMounted = false;
+ }
+
+ if (BootEncStatus.DriveMounted)
+ {
+ byte userConfig;
+ string customUserMessage;
+ uint16 bootLoaderVersion;
+
+ BootEncObj->ReadBootSectorConfig (nullptr, 0, &userConfig, &customUserMessage, &bootLoaderVersion);
+
+ if (bootLoaderVersion != VERSION_NUM)
+ Warning ("BOOT_LOADER_VERSION_INCORRECT_PREFERENCES");
+
+ if (disableHW)
+ userConfig |= TC_BOOT_USER_CFG_FLAG_DISABLE_HW_ENCRYPTION;
+ else
+ userConfig &= ~TC_BOOT_USER_CFG_FLAG_DISABLE_HW_ENCRYPTION;
+
+ BootEncObj->WriteBootSectorUserConfig (userConfig, customUserMessage);
+ }
+
+ SetDriverConfigurationFlag (TC_DRIVER_CONFIG_DISABLE_HARDWARE_ENCRYPTION, disableHW);
+
+ DWORD bytesReturned;
+ if (!DeviceIoControl (hDriver, TC_IOCTL_REREAD_DRIVER_CONFIG, NULL, 0, NULL, 0, &bytesReturned, NULL))
+ handleWin32Error (hwndDlg);
+
+ EnableHwEncryption (!disableHW);
+
+ uint32 cpuFreeCount = 0;
+ if (IsDlgButtonChecked (hwndDlg, IDC_LIMIT_ENC_THREAD_POOL))
+ {
+ LRESULT cpuFreeItem = SendMessage (GetDlgItem (hwndDlg, IDC_ENCRYPTION_FREE_CPU_COUNT), CB_GETCURSEL, 0, 0);
+ if (cpuFreeItem != CB_ERR)
+ cpuFreeCount = (uint32) (cpuFreeItem + 1);
+ }
+
+ if (ReadEncryptionThreadPoolFreeCpuCountLimit() != cpuFreeCount)
+ {
+ BootEncObj->WriteLocalMachineRegistryDwordValue ("SYSTEM\\CurrentControlSet\\Services\\truecrypt", TC_ENCRYPTION_FREE_CPU_COUNT_REG_VALUE_NAME, cpuFreeCount);
+ Warning ("SETTING_REQUIRES_REBOOT");
+ }
+
+ EndDialog (hwndDlg, lw);
+ return 1;
+ }
+ catch (Exception &e)
+ {
+ e.Show (hwndDlg);
+ }
+ }
+ return 1;
+
+ case IDC_ENABLE_HARDWARE_ENCRYPTION:
+ if (!IsDlgButtonChecked (hwndDlg, IDC_ENABLE_HARDWARE_ENCRYPTION)
+ && AskWarnYesNo ("CONFIRM_SETTING_DEGRADES_PERFORMANCE") == IDNO)
+ {
+ CheckDlgButton (hwndDlg, IDC_ENABLE_HARDWARE_ENCRYPTION, BST_CHECKED);
+ }
+ return 1;
+
+ case IDC_LIMIT_ENC_THREAD_POOL:
+ if (IsDlgButtonChecked (hwndDlg, IDC_LIMIT_ENC_THREAD_POOL)
+ && AskWarnYesNo ("CONFIRM_SETTING_DEGRADES_PERFORMANCE") == IDNO)
+ {
+ CheckDlgButton (hwndDlg, IDC_LIMIT_ENC_THREAD_POOL, BST_UNCHECKED);
+ }
+ else
+ {
+ SendMessage (GetDlgItem (hwndDlg, IDC_ENCRYPTION_FREE_CPU_COUNT), CB_SETCURSEL, 0, 0);
+ Warning ("SETTING_REQUIRES_REBOOT"); // Warn the user before he thinks about benchmarking
+ }
+
+ EnableWindow (GetDlgItem (hwndDlg, IDC_ENCRYPTION_FREE_CPU_COUNT), IsDlgButtonChecked (hwndDlg, IDC_LIMIT_ENC_THREAD_POOL));
+ return 1;
+
+ case IDC_BENCHMARK:
+ Benchmark (hwndDlg);
+ return 1;
+
+ case IDC_MORE_INFO_ON_HW_ACCELERATION:
+ Applink ("hwacceleration", TRUE, "");
+ return 1;
+
+ case IDC_MORE_INFO_ON_THREAD_BASED_PARALLELIZATION:
+ Applink ("parallelization", TRUE, "");
+ return 1;
+ }
+
+ return 0;
+ }
+
+ return 0;
+}
+
+
+static BOOL CALLBACK SecurityTokenPreferencesDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+ WORD lw = LOWORD (wParam);
+
+ switch (msg)
+ {
+ case WM_INITDIALOG:
+ LocalizeDialog (hwndDlg, "IDD_TOKEN_PREFERENCES");
+ SetDlgItemText (hwndDlg, IDC_PKCS11_MODULE, SecurityTokenLibraryPath);
+ CheckDlgButton (hwndDlg, IDC_CLOSE_TOKEN_SESSION_AFTER_MOUNT, CloseSecurityTokenSessionsAfterMount ? BST_CHECKED : BST_UNCHECKED);
+
+ SetWindowTextW (GetDlgItem (hwndDlg, IDT_PKCS11_LIB_HELP), GetString("PKCS11_LIB_LOCATION_HELP"));
+
+ return 0;
+
+ case WM_COMMAND:
+
+ switch (lw)
+ {
+ case IDCANCEL:
+ EndDialog (hwndDlg, lw);
+ return 1;
+
+ case IDOK:
+ {
+ char securityTokenLibraryPath[MAX_PATH];
+ GetDlgItemText (hwndDlg, IDC_PKCS11_MODULE, securityTokenLibraryPath, sizeof (securityTokenLibraryPath));
+
+ if (securityTokenLibraryPath[0] == 0)
+ {
+ try
+ {
+ SecurityToken::CloseLibrary();
+ }
+ catch (...) { }
+
+ SecurityTokenLibraryPath[0] = 0;
+ }
+ else
+ {
+ char prevSecurityTokenLibraryPath[MAX_PATH];
+ strcpy (prevSecurityTokenLibraryPath, SecurityTokenLibraryPath);
+ strcpy (SecurityTokenLibraryPath, securityTokenLibraryPath);
+
+ if (!InitSecurityTokenLibrary())
+ {
+ strcpy (SecurityTokenLibraryPath, prevSecurityTokenLibraryPath);
+ return 1;
+ }
+ }
+
+ CloseSecurityTokenSessionsAfterMount = (IsDlgButtonChecked (hwndDlg, IDC_CLOSE_TOKEN_SESSION_AFTER_MOUNT) == BST_CHECKED);
+
+ WaitCursor ();
+ SaveSettings (hwndDlg);
+ NormalCursor ();
+
+ EndDialog (hwndDlg, lw);
+ return 1;
+ }
+
+ case IDC_AUTO_DETECT_PKCS11_MODULE:
+ {
+ char systemDir[MAX_PATH];
+ GetSystemDirectory (systemDir, sizeof (systemDir));
+ WIN32_FIND_DATA findData;
+ bool found = false;
+
+ WaitCursor();
+
+ HANDLE find = FindFirstFile ((string (systemDir) + "\\*.dll").c_str(), &findData);
+ while (!found && find != INVALID_HANDLE_VALUE)
+ {
+ string dllPathname = string (systemDir) + "\\" + findData.cFileName;
+ DWORD fileSize;
+
+ char *file = LoadFile (dllPathname.c_str(), &fileSize);
+ if (file)
+ {
+ const char *functionName = "C_GetFunctionList";
+ size_t strLen = strlen (functionName);
+
+ if (fileSize > strLen)
+ {
+ for (size_t i = 0; i < fileSize - strLen; ++i)
+ {
+ if (memcmp (file + i, functionName, strLen) == 0)
+ {
+ HMODULE module = LoadLibrary (dllPathname.c_str());
+ if (module)
+ {
+ if (GetProcAddress (module, functionName))
+ {
+ SetDlgItemText (hwndDlg, IDC_PKCS11_MODULE, dllPathname.c_str());
+ found = true;
+
+ FreeLibrary (module);
+ break;
+ }
+
+ FreeLibrary (module);
+ }
+ }
+ }
+ }
+
+ free (file);
+ }
+
+ if (!FindNextFile (find, &findData))
+ break;
+ }
+
+ if (find != INVALID_HANDLE_VALUE)
+ FindClose (find);
+
+ NormalCursor();
+
+ if (!found)
+ Warning ("PKCS11_MODULE_AUTO_DETECTION_FAILED");
+
+ return 1;
+ }
+
+ case IDC_SELECT_PKCS11_MODULE:
+ {
+ char securityTokenLibraryPath[MAX_PATH];
+ char systemDir[MAX_PATH];
+ wchar_t browseFilter[1024];
+
+ Info ("SELECT_PKCS11_MODULE_HELP");
+
+ wsprintfW (browseFilter, L"%ls (*.dll)%c*.dll%c%c", GetString ("DLL_FILES"), 0, 0, 0);
+ GetSystemDirectory (systemDir, sizeof (systemDir));
+
+ if (BrowseFilesInDir (hwndDlg, "SELECT_PKCS11_MODULE", systemDir, securityTokenLibraryPath, TRUE, FALSE, browseFilter))
+ SetDlgItemText (hwndDlg, IDC_PKCS11_MODULE, securityTokenLibraryPath);
+ return 1;
+ }
+ }
+ return 0;
+ }
+
+ return 0;
+}
+
+
+void SecurityTokenPreferencesDialog (HWND hwndDlg)
+{
+ DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_TOKEN_PREFERENCES), hwndDlg, (DLGPROC) SecurityTokenPreferencesDlgProc, 0);
+}
+
+
+static BOOL CALLBACK BootLoaderPreferencesDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+ WORD lw = LOWORD (wParam);
+
+ switch (msg)
+ {
+ case WM_INITDIALOG:
+ {
+ if (!BootEncObj->GetStatus().DriveMounted)
+ {
+ Warning ("SYS_DRIVE_NOT_ENCRYPTED");
+ EndDialog (hwndDlg, IDCANCEL);
+ return 1;
+ }
+
+ try
+ {
+ LocalizeDialog (hwndDlg, "IDD_SYSENC_SETTINGS");
+
+ uint32 driverConfig = ReadDriverConfigurationFlags();
+ byte userConfig;
+ string customUserMessage;
+ uint16 bootLoaderVersion;
+
+ BootEncObj->ReadBootSectorConfig (nullptr, 0, &userConfig, &customUserMessage, &bootLoaderVersion);
+
+ if (bootLoaderVersion != VERSION_NUM)
+ Warning ("BOOT_LOADER_VERSION_INCORRECT_PREFERENCES");
+
+ SendMessage (GetDlgItem (hwndDlg, IDC_CUSTOM_BOOT_LOADER_MESSAGE), EM_LIMITTEXT, TC_BOOT_SECTOR_USER_MESSAGE_MAX_LENGTH, 0);
+ SetDlgItemText (hwndDlg, IDC_CUSTOM_BOOT_LOADER_MESSAGE, customUserMessage.c_str());
+
+ CheckDlgButton (hwndDlg, IDC_DISABLE_BOOT_LOADER_OUTPUT, (userConfig & TC_BOOT_USER_CFG_FLAG_SILENT_MODE) ? BST_CHECKED : BST_UNCHECKED);
+ CheckDlgButton (hwndDlg, IDC_ALLOW_ESC_PBA_BYPASS, (userConfig & TC_BOOT_USER_CFG_FLAG_DISABLE_ESC) ? BST_UNCHECKED : BST_CHECKED);
+ CheckDlgButton (hwndDlg, IDC_BOOT_LOADER_CACHE_PASSWORD, (driverConfig & TC_DRIVER_CONFIG_CACHE_BOOT_PASSWORD) ? BST_CHECKED : BST_UNCHECKED);
+
+ SetWindowTextW (GetDlgItem (hwndDlg, IDC_CUSTOM_BOOT_LOADER_MESSAGE_HELP), GetString("CUSTOM_BOOT_LOADER_MESSAGE_HELP"));
+ }
+ catch (Exception &e)
+ {
+ e.Show (hwndDlg);
+ EndDialog (hwndDlg, IDCANCEL);
+ return 1;
+ }
+ }
+ return 0;
+
+ case WM_COMMAND:
+
+ switch (lw)
+ {
+ case IDCANCEL:
+ EndDialog (hwndDlg, lw);
+ return 1;
+
+ case IDOK:
+ {
+ if (!BootEncObj->GetStatus().DriveMounted)
+ {
+ EndDialog (hwndDlg, IDCANCEL);
+ return 1;
+ }
+
+ char customUserMessage[TC_BOOT_SECTOR_USER_MESSAGE_MAX_LENGTH + 1];
+ GetDlgItemText (hwndDlg, IDC_CUSTOM_BOOT_LOADER_MESSAGE, customUserMessage, sizeof (customUserMessage));
+
+ byte userConfig;
+ try
+ {
+ BootEncObj->ReadBootSectorConfig (nullptr, 0, &userConfig);
+ }
+ catch (Exception &e)
+ {
+ e.Show (hwndDlg);
+ return 1;
+ }
+
+ if (IsDlgButtonChecked (hwndDlg, IDC_DISABLE_BOOT_LOADER_OUTPUT))
+ userConfig |= TC_BOOT_USER_CFG_FLAG_SILENT_MODE;
+ else
+ userConfig &= ~TC_BOOT_USER_CFG_FLAG_SILENT_MODE;
+
+ if (!IsDlgButtonChecked (hwndDlg, IDC_ALLOW_ESC_PBA_BYPASS))
+ userConfig |= TC_BOOT_USER_CFG_FLAG_DISABLE_ESC;
+ else
+ userConfig &= ~TC_BOOT_USER_CFG_FLAG_DISABLE_ESC;
+
+ try
+ {
+ BootEncObj->WriteBootSectorUserConfig (userConfig, customUserMessage);
+ SetDriverConfigurationFlag (TC_DRIVER_CONFIG_CACHE_BOOT_PASSWORD, IsDlgButtonChecked (hwndDlg, IDC_BOOT_LOADER_CACHE_PASSWORD));
+ }
+ catch (Exception &e)
+ {
+ e.Show (hwndDlg);
+ return 1;
+ }
+
+ EndDialog (hwndDlg, lw);
+ return 1;
+ }
+
+ case IDC_DISABLE_BOOT_LOADER_OUTPUT:
+ if ((IsDlgButtonChecked (hwndDlg, IDC_DISABLE_BOOT_LOADER_OUTPUT))
+ && AskWarnYesNo ("CUSTOM_BOOT_LOADER_MESSAGE_PROMPT") == IDNO)
+ {
+ CheckDlgButton (hwndDlg, IDC_DISABLE_BOOT_LOADER_OUTPUT, BST_UNCHECKED);
+ }
+
+ break;
+
+ case IDC_BOOT_LOADER_CACHE_PASSWORD:
+ if (IsDlgButtonChecked (hwndDlg, IDC_BOOT_LOADER_CACHE_PASSWORD))
+ Warning ("BOOT_PASSWORD_CACHE_KEYBOARD_WARNING");
+
+ break;
+ }
+ return 0;
+ }
+
+ return 0;
+}
+
+
+void MountSelectedVolume (HWND hwndDlg, BOOL mountWithOptions)
+{
+ if (!VolumeSelected(hwndDlg))
+ {
+ Warning ("NO_VOLUME_SELECTED");
+ }
+ else if (LOWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) == TC_MLIST_ITEM_FREE)
+ {
+ mountOptions = defaultMountOptions;
+ bPrebootPasswordDlgMode = FALSE;
+
+ if (mountWithOptions || GetAsyncKeyState (VK_CONTROL) < 0)
+ {
+ if (IDCANCEL == DialogBoxParamW (hInst,
+ MAKEINTRESOURCEW (IDD_MOUNT_OPTIONS), hwndDlg,
+ (DLGPROC) MountOptionsDlgProc, (LPARAM) &mountOptions))
+ return;
+
+ if (mountOptions.ProtectHiddenVolume && hidVolProtKeyFilesParam.EnableKeyFiles)
+ KeyFilesApply (&mountOptions.ProtectedHidVolPassword, hidVolProtKeyFilesParam.FirstKeyFile);
+ }
+
+ if (CheckMountList ())
+ Mount (hwndDlg, 0, 0);
+ }
+ else
+ Warning ("SELECT_FREE_DRIVE");
+}
+
+
+BOOL GetExecutableImageInformation (const string &path, string &version, string &description, string &companyName, string &productName)
+{
+ DWORD handle;
+ DWORD size = GetFileVersionInfoSize (path.c_str(), &handle);
+ if (size == 0)
+ return FALSE;
+
+ void *buf = err_malloc (size);
+ finally_do_arg (void*, buf, { free (finally_arg); });
+
+ if (!GetFileVersionInfo (path.c_str(), handle, size, buf))
+ return FALSE;
+
+ version = description = companyName = productName = "";
+
+ UINT varSize;
+ VS_FIXEDFILEINFO *fileInfo;
+ if (VerQueryValue (buf, "\\", (LPVOID *) &fileInfo, &varSize) && varSize > 0)
+ {
+ stringstream s;
+ s << HIWORD (fileInfo->dwFileVersionMS) << '.' << LOWORD (fileInfo->dwFileVersionMS) << '.' << HIWORD (fileInfo->dwFileVersionLS) << '.' << LOWORD (fileInfo->dwFileVersionLS);
+ version = s.str();
+ }
+
+ DWORD *langCodes;
+ if (VerQueryValue (buf, "\\VarFileInfo\\Translation", (LPVOID *) &langCodes, &varSize) && varSize >= sizeof (DWORD))
+ {
+ char prefix[128];
+ sprintf_s (prefix, sizeof (prefix), "\\StringFileInfo\\%04x%04x\\", LOWORD (langCodes[0]), HIWORD (langCodes[0]));
+
+ char *str;
+ if (VerQueryValue (buf, (string (prefix) + "FileDescription").c_str(), (LPVOID *) &str, &varSize) && varSize > 0)
+ description = str;
+
+ if (VerQueryValue (buf, (string (prefix) + "CompanyName").c_str(), (LPVOID *) &str, &varSize) && varSize > 0)
+ companyName = str;
+
+ if (VerQueryValue (buf, (string (prefix) + "ProductName").c_str(), (LPVOID *) &str, &varSize) && varSize > 0)
+ productName = str;
+ }
+
+ return TRUE;
+}
+
+
+void AnalyzeKernelMiniDump (HWND hwndDlg)
+{
+ char winDir[MAX_PATH] = { 0 };
+ GetWindowsDirectory (winDir, sizeof (winDir));
+ string memDumpPath = string (winDir) + "\\MEMORY.DMP";
+ string tmpDumpPath;
+
+ string dumpPath = FindLatestFileOrDirectory (string (winDir) + "\\Minidump", "*.dmp", false, true);
+ if (dumpPath.empty())
+ {
+ Error ("NO_MINIDUMP_FOUND");
+ return;
+ }
+
+ WIN32_FIND_DATA findData;
+ HANDLE find = FindFirstFile (memDumpPath.c_str(), &findData);
+
+ if (find != INVALID_HANDLE_VALUE)
+ {
+ ULARGE_INTEGER memDumpTime, miniDumpTime;
+ memDumpTime.HighPart = findData.ftLastWriteTime.dwHighDateTime;
+ memDumpTime.LowPart = findData.ftLastWriteTime.dwLowDateTime;
+
+ FindClose (find);
+
+ find = FindFirstFile (dumpPath.c_str(), &findData);
+ if (find != INVALID_HANDLE_VALUE)
+ {
+ miniDumpTime.HighPart = findData.ftLastWriteTime.dwHighDateTime;
+ miniDumpTime.LowPart = findData.ftLastWriteTime.dwLowDateTime;
+
+ if (_abs64 (miniDumpTime.QuadPart - memDumpTime.QuadPart) < 10I64 * 1000 * 1000 * 60 * 5)
+ {
+ // Rename MEMORY.DMP file first as it can be deleted by Windows when system crash dialog is closed
+ tmpDumpPath = memDumpPath + ".true_crypt.dmp"; // Application name must be mangled to avoid interfering with crash analysis
+
+ if (MoveFile (memDumpPath.c_str(), tmpDumpPath.c_str()))
+ dumpPath = tmpDumpPath;
+ else
+ tmpDumpPath.clear();
+ }
+
+ FindClose (find);
+ }
+ }
+
+ finally_do_arg2 (string, tmpDumpPath, string, memDumpPath,
+ {
+ if (!finally_arg.empty())
+ {
+ if (AskYesNo ("ASK_DELETE_KERNEL_CRASH_DUMP") == IDYES)
+ DeleteFile (finally_arg.c_str());
+ else
+ MoveFile (finally_arg.c_str(), finally_arg2.c_str());
+ }
+ });
+
+ STARTUPINFO startupInfo;
+ PROCESS_INFORMATION procInfo;
+
+ ZeroMemory (&startupInfo, sizeof (startupInfo));
+ ZeroMemory (&procInfo, sizeof (procInfo));
+
+ if (!IsApplicationInstalled (Is64BitOs() ? "Debugging Tools for Windows (x64)" : "Debugging Tools for Windows (x86)"))
+ {
+ if (AskOkCancel ("ASK_DEBUGGER_INSTALL") != IDOK)
+ return;
+
+ if (!CreateProcess (NULL, (LPSTR) (string ("msiexec.exe /qb /i " TC_APPLINK "&dest=ms-debug-tools-x") + (Is64BitOs() ? "64" : "86")).c_str(),
+ NULL, NULL, FALSE, 0, NULL, NULL, &startupInfo, &procInfo))
+ {
+ handleWin32Error (hwndDlg);
+ return;
+ }
+
+ WaitCursor();
+ WaitForSingleObject (procInfo.hProcess, INFINITE);
+ NormalCursor();
+
+ DWORD exitCode;
+ if (!GetExitCodeProcess (procInfo.hProcess, &exitCode) || exitCode != 0)
+ return;
+ }
+
+ if (AskOkCancel ("SYSTEM_CRASH_ANALYSIS_INFO") == IDCANCEL)
+ return;
+
+ ZeroMemory (&startupInfo, sizeof (startupInfo));
+ ZeroMemory (&procInfo, sizeof (procInfo));
+
+ SECURITY_ATTRIBUTES securityAttrib;
+ securityAttrib.bInheritHandle = TRUE;
+ securityAttrib.nLength = sizeof (securityAttrib);
+ securityAttrib.lpSecurityDescriptor = NULL;
+
+ HANDLE hChildStdoutWrite = INVALID_HANDLE_VALUE;
+ HANDLE hChildStdoutRead = INVALID_HANDLE_VALUE;
+ if (!CreatePipe (&hChildStdoutRead, &hChildStdoutWrite, &securityAttrib, 0))
+ {
+ handleWin32Error (hwndDlg);
+ return;
+ }
+ SetHandleInformation (hChildStdoutRead, HANDLE_FLAG_INHERIT, 0);
+
+ startupInfo.hStdInput = INVALID_HANDLE_VALUE;
+ startupInfo.hStdOutput = hChildStdoutWrite;
+ startupInfo.cb = sizeof (startupInfo);
+ startupInfo.hStdError = hChildStdoutWrite;
+ startupInfo.dwFlags |= STARTF_USESTDHANDLES;
+
+ list <string> kdPaths;
+ string kdPath;
+ char progPath[MAX_PATH];
+ if (SHGetSpecialFolderPath (hwndDlg, progPath, CSIDL_PROGRAM_FILES, FALSE))
+ {
+ if (Is64BitOs())
+ {
+ string s = progPath;
+ size_t p = s.find (" (x86)");
+ if (p != string::npos)
+ {
+ s = s.substr (0, p);
+ if (_access (s.c_str(), 0) != -1)
+ strcpy_s (progPath, sizeof (progPath), s.c_str());
+ }
+ }
+
+ kdPath = string (progPath) + "\\Debugging Tools for Windows (" + (Is64BitOs() ? "x64" : "x86") + ")\\kd.exe";
+ kdPaths.push_back (kdPath);
+ }
+
+ kdPath = FindLatestFileOrDirectory (string (winDir).substr (0, 1) + ":\\WinDDK", "*", true, false);
+ kdPath += "\\Debuggers\\kd.exe";
+ kdPaths.push_back (kdPath);
+
+ kdPaths.push_back ("kd.exe");
+
+ bool kdRunning = false;
+ foreach (const string &kdPath, kdPaths)
+ {
+ if (CreateProcess (NULL, (LPSTR) ("\"" + kdPath + "\" -z \"" + dumpPath + "\" -y http://msdl.microsoft.com/download/symbols -c \".bugcheck; !analyze -v; q\"").c_str(),
+ NULL, NULL, TRUE, CREATE_NO_WINDOW, NULL, NULL, &startupInfo, &procInfo))
+ {
+ kdRunning = true;
+ break;
+ }
+ }
+
+ if (!kdRunning)
+ {
+ handleWin32Error (hwndDlg);
+ Error ("DEBUGGER_NOT_FOUND");
+ return;
+ }
+
+ EnableElevatedCursorChange (hwndDlg);
+ WaitCursor();
+
+ CloseHandle (procInfo.hProcess);
+ CloseHandle (procInfo.hThread);
+ CloseHandle (hChildStdoutWrite);
+
+ string output;
+
+ while (TRUE)
+ {
+ DWORD bytesReceived;
+ char pipeBuffer [4096];
+
+ if (!ReadFile (hChildStdoutRead, pipeBuffer, sizeof (pipeBuffer), &bytesReceived, NULL))
+ break;
+
+ output.insert (output.size(), pipeBuffer, bytesReceived);
+ }
+
+ NormalCursor();
+
+ bool otherDriver = (StringToUpperCase (output).find (StringToUpperCase (TC_APP_NAME)) == string::npos);
+
+ size_t p, p2;
+ while ((p = output.find ('`')) != string::npos)
+ output.erase (output.begin() + p);
+
+ p = output.find ("Bugcheck code ");
+ if (p == string::npos)
+ {
+ Error ("ERR_PARAMETER_INCORRECT");
+ return;
+ }
+
+ uint64 bugcheckCode;
+ int n = sscanf (output.substr (p + 14, 8).c_str(), "%I64X", &bugcheckCode);
+ if (n != 1)
+ {
+ Error ("ERR_PARAMETER_INCORRECT");
+ return;
+ }
+
+ p = output.find ("Arguments ", p);
+
+ uint64 bugcheckArgs[4];
+ n = sscanf (output.substr (p + 10, (Is64BitOs() ? 17 : 9) * 4).c_str(), "%I64X %I64X %I64X %I64X", &bugcheckArgs[0], &bugcheckArgs[1], &bugcheckArgs[2], &bugcheckArgs[3]);
+ if (n != 4)
+ {
+ Error ("ERR_PARAMETER_INCORRECT");
+ return;
+ }
+
+ // Image name
+ string imageName, imageVersion;
+ p = output.find ("IMAGE_NAME:");
+ if (p != string::npos)
+ {
+ p += 13;
+ p2 = output.find ('\n', p);
+ if (p2 != string::npos)
+ imageName = output.substr (p, p2 - p);
+ }
+
+ // Stack trace
+ p = output.find ("STACK_TEXT:");
+ if (p == string::npos)
+ {
+ Error ("ERR_PARAMETER_INCORRECT");
+ return;
+ }
+
+ p2 = output.find ("FOLLOWUP_IP:", p);
+ if (p2 == string::npos)
+ p2 = output.find ("STACK_COMMAND:", p);
+ if (p2 == string::npos)
+ p2 = output.size();
+
+ output = output.substr (p, p2 - p);
+
+ list <string> retAddrs;
+ p = 0;
+ while ((p = output.find ("+", p)) != string::npos)
+ {
+ size_t p1 = output.rfind (" ", p);
+ if (p1 == string::npos)
+ break;
+
+ p = output.find ('\n', p);
+ if (p == string::npos)
+ p = output.size() - 1;
+
+ string s = output.substr (p1 + 1, p - p1 - 1);
+
+ if (s.find ('(') == 0)
+ s = s.substr (1);
+ if (s.rfind (')') == s.size() - 1)
+ s = s.substr (0, s.size() - 1);
+
+ retAddrs.push_back (s);
+ }
+
+ char url[MAX_URL_LENGTH];
+ sprintf (url, TC_APPLINK_SECURE "&dest=syserr-report&os=%s&osver=%d.%d.%d&arch=%s&err=%I64x&arg1=%I64x&arg2=%I64x&arg3=%I64x&arg4=%I64x&flag=%s&drv=%s",
+ GetWindowsEdition().c_str(),
+ CurrentOSMajor,
+ CurrentOSMinor,
+ CurrentOSServicePack,
+ Is64BitOs() ? "x64" : "x86",
+ bugcheckCode,
+ bugcheckArgs[0],
+ bugcheckArgs[1],
+ bugcheckArgs[2],
+ bugcheckArgs[3],
+ otherDriver ? "0" : "1",
+ imageName.empty() ? "-" : imageName.c_str()
+ );
+
+ stringstream stackTraceArgs;
+ int i = 0;
+ foreach (const string &retAddr, retAddrs)
+ {
+ stackTraceArgs << "&st" << i++ << "=" << retAddr;
+ }
+
+ wstring msg;
+
+ if (!imageName.empty() && StringToUpperCase (imageName) != StringToUpperCase (TC_APP_NAME) + ".SYS")
+ {
+ msg += wstring (GetString ("SYSTEM_CRASH_UPDATE_DRIVER")) + L"\n\n" + SingleStringToWide (imageName);
+
+ string description, company, product;
+ if (GetExecutableImageInformation (string (winDir) + "\\System32\\drivers\\" + imageName, imageVersion, description, company, product))
+ {
+ string s;
+ if (!description.empty())
+ s += description;
+ if (!company.empty())
+ s += "; " + company;
+ if (!product.empty())
+ s += "; " + product;
+
+ if (s.find ("; ") == 0)
+ s = s.substr (3);
+
+ if (!s.empty())
+ msg += SingleStringToWide (" (" + s + ")");
+ }
+
+ msg += L"\n\n";
+ }
+
+ if (otherDriver)
+ {
+ msg += GetString ("SYSTEM_CRASH_NO_TRUECRYPT");
+ msg += L"\n\n";
+ }
+
+ string urlStr = string (url) + "&drvver=" + (imageVersion.empty() ? "-" : imageVersion) + stackTraceArgs.str();
+
+ for (size_t i = 0; i < urlStr.size(); ++i)
+ {
+ if (urlStr[i] == '+')
+ urlStr[i] = '.';
+ }
+
+ msg += GetString ("SYSTEM_CRASH_REPORT");
+ msg += L"\n\n";
+
+ msg += SingleStringToWide (urlStr);
+
+ msg += L"\n\n";
+ msg += GetString ("ASK_SEND_ERROR_REPORT");
+
+ if (AskYesNoString (msg.c_str()) == IDYES)
+ ShellExecute (NULL, "open", urlStr.c_str(), NULL, NULL, SW_SHOWNORMAL);
+}
+
+
+static BOOL HandleDriveListMouseWheelEvent (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL bListMustBePointed)
+{
+ static BOOL eventHandlerActive = FALSE;
+ if (eventHandlerActive)
+ return 0;
+
+ RECT listRect;
+ int mouseX = GET_X_LPARAM (lParam);
+ int mouseY = GET_Y_LPARAM (lParam);
+
+ GetWindowRect (GetDlgItem (MainDlg, IDC_DRIVELIST), &listRect);
+
+ // Determine if the mouse pointer is within the main drive list
+ bool bListPointed = (mouseX >= listRect.left && mouseX <= listRect.right
+ && mouseY >= listRect.top && mouseY <= listRect.bottom);
+
+ if (bListMustBePointed && bListPointed
+ || !bListMustBePointed)
+ {
+ eventHandlerActive = TRUE;
+
+ if (!bListMustBePointed && bListPointed)
+ SetFocus (GetDlgItem (MainDlg, IDC_DRIVELIST));
+
+ SendMessage (GetDlgItem (MainDlg, IDC_DRIVELIST), uMsg, wParam, lParam);
+
+ eventHandlerActive = FALSE;
+ return 0; // Do not process this event any further e.g. to prevent two lists from being scrolled at once
+ }
+
+ return 1;
+}
+
+
+static LRESULT CALLBACK MouseWheelProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+ WNDPROC wp = (WNDPROC) GetWindowLongPtr (hwnd, GWLP_USERDATA);
+
+ switch (message)
+ {
+ case WM_MOUSEWHEEL:
+
+ if (HandleDriveListMouseWheelEvent (message, wParam, lParam, TRUE) == 0)
+ return 0; // Do not process this event any further e.g. to prevent two lists from being scrolled at once
+ }
+
+ return CallWindowProc (wp, hwnd, message, wParam, lParam);
+}
+
+
+void HookMouseWheel (HWND hwndDlg, UINT ctrlId)
+{
+ HWND hwndCtrl = GetDlgItem (hwndDlg, ctrlId);
+
+ SetWindowLongPtr (hwndCtrl, GWLP_USERDATA, (LONG_PTR) GetWindowLongPtr (hwndCtrl, GWLP_WNDPROC));
+ SetWindowLongPtr (hwndCtrl, GWLP_WNDPROC, (LONG_PTR) MouseWheelProc);
+}