/* 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" #include <Strsafe.h> #include <wtsapi32.h> typedef BOOL (WINAPI *WTSREGISTERSESSIONNOTIFICATION)(HWND, DWORD); typedef BOOL (WINAPI *WTSUNREGISTERSESSIONNOTIFICATION)(HWND); using namespace VeraCrypt; 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 bDismountOnSessionLocked = 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 */ int VolumePkcs5 = 0; int CmdVolumePkcs5 = 0; BOOL VolumeTrueCryptMode = FALSE; BOOL CmdVolumeTrueCryptMode = FALSE; 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; // WTS handling static HMODULE hWtsLib = NULL; static WTSREGISTERSESSIONNOTIFICATION fnWtsRegisterSessionNotification = NULL; static WTSUNREGISTERSESSIONNOTIFICATION fnWtsUnRegisterSessionNotification = NULL; static void RegisterWtsNotification(HWND hWnd) { if (!hWtsLib) { char dllPath[MAX_PATH]; if (GetSystemDirectory(dllPath, MAX_PATH)) StringCbCatA(dllPath, sizeof(dllPath), "\\wtsapi32.dll"); else StringCbCopyA(dllPath, sizeof(dllPath), "c:\\Windows\\System32\\wtsapi32.dll"); hWtsLib = LoadLibrary(dllPath); if (hWtsLib) { fnWtsRegisterSessionNotification = (WTSREGISTERSESSIONNOTIFICATION) GetProcAddress(hWtsLib, "WTSRegisterSessionNotification" ); fnWtsUnRegisterSessionNotification = (WTSUNREGISTERSESSIONNOTIFICATION) GetProcAddress(hWtsLib, "WTSUnRegisterSessionNotification" ); if ( !fnWtsRegisterSessionNotification || !fnWtsUnRegisterSessionNotification || !fnWtsRegisterSessionNotification( hWnd, NOTIFY_FOR_THIS_SESSION ) ) { fnWtsRegisterSessionNotification = NULL; fnWtsUnRegisterSessionNotification = NULL; FreeLibrary(hWtsLib); hWtsLib = NULL; } } } } static void UnregisterWtsNotification(HWND hWnd) { if (hWtsLib && fnWtsUnRegisterSessionNotification) { fnWtsUnRegisterSessionNotification(hWnd); FreeLibrary(hWtsLib); hWtsLib = NULL; fnWtsRegisterSessionNotification = NULL; fnWtsUnRegisterSessionNotification = NULL; } } 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 (&VolumePkcs5, sizeof (VolumePkcs5)); burn (&CmdVolumePkcs5, sizeof (CmdVolumePkcs5)); burn (&VolumeTrueCryptMode, sizeof (VolumeTrueCryptMode)); burn (&CmdVolumeTrueCryptMode, sizeof (CmdVolumeTrueCryptMode)); 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 (hwndDlg, 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); UnregisterWtsNotification(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 (hwndDlg, 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())); bDismountOnSessionLocked = ConfigReadInt ("DismountOnSessionLocked", FALSE); 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.ProtectedHidVolPkcs5Prf = 0; 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(hwndDlg); // 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 ("DismountOnSessionLocked", bDismountOnSessionLocked); 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) StringCbPrintfA (szTmp, sizeof(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 (hwndDlg); // 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(); if (BootEncStatus.BootDriveLength.QuadPart < 1) // paranoid check return FALSE; else 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 1; } if ( BootEncStatus.ConfiguredEncryptedAreaEnd < 0 || BootEncStatus.ConfiguredEncryptedAreaStart < 0 || BootEncStatus.ConfiguredEncryptedAreaEnd < BootEncStatus.ConfiguredEncryptedAreaStart ) return 1; // we return 1 to avoid devision by zero else return ((unsigned __int64)(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 0; } if ( BootEncStatus.EncryptedAreaEnd < 0 || BootEncStatus.EncryptedAreaStart < 0 || BootEncStatus.EncryptedAreaEnd < BootEncStatus.EncryptedAreaStart ) return 0; else return ((unsigned __int64)(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, ""); } } 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, ""); AppendMenuW (popup, MF_STRING, IDM_SYS_ENC_SETTINGS, GetString ("IDM_SYS_ENC_SETTINGS")); if (!IsHiddenOSRunning()) { AppendMenu (popup, MF_SEPARATOR, 0, ""); 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, ""); AppendMenuW (popup, MF_STRING, IDM_PERMANENTLY_DECRYPT_SYS, GetString ("PERMANENTLY_DECRYPT")); } AppendMenu (popup, MF_SEPARATOR, 0, ""); 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 (HWND hwndDlg, 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, sizeof(szDiskFile), szDevicePath, &tmpbDevice); if (!tmpbDevice) { if (!quiet) Warning ("NO_SYSENC_PARTITION_SELECTED", hwndDlg); return FALSE; } if (LOWORD (GetSelectedLong (GetDlgItem (MainDlg, IDC_DRIVELIST))) != TC_MLIST_ITEM_FREE) { if (!quiet) Warning ("SELECT_FREE_DRIVE", hwndDlg); return FALSE; } } else StringCbCopyA (szDevicePath, sizeof(szDevicePath), devicePath); char *partionPortion = strrchr (szDevicePath, '\\'); if (!partionPortion || !_stricmp (partionPortion, "\\Partition0")) { // Only partitions are supported (not whole drives) if (!quiet) Warning ("NO_SYSENC_PARTITION_SELECTED", hwndDlg); 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", hwndDlg); return FALSE; } StringCbPrintfA (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", hwndDlg); return FALSE; } } else return TRUE; } catch (Exception &e) { NormalCursor(); e.Show (hwndDlg); } 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; StringCbPrintfA (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)); *tmp = 0; StringCbCatA (t, sizeof(t), "\\VeraCrypt Format.exe\""); if (!FileExists(t)) Error ("VOL_CREATION_WIZARD_NOT_FOUND", hwndDlg); // Display a user-friendly error message and advise what to do if (strlen (arg) > 0) { StringCbCatA (t, sizeof(t), " "); StringCbCatA (t, sizeof(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 hwndDlg, 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", hwndDlg); 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; szTmp[0] = ' '; szTmp[1] = 0; 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)) { StringCbCopyW (szTmpW, sizeof(szTmpW), GetString ("SYSTEM_DRIVE")); } else { // Partially encrypted if (BootEncStatus.SetupInProgress) { // Currently encrypting/decrypting if (BootEncStatus.SetupMode != SetupDecryption) { StringCbPrintfW (szTmpW, sizeof szTmpW, GetString ("SYSTEM_DRIVE_ENCRYPTING"), (double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0); } else { StringCbPrintfW (szTmpW, sizeof szTmpW, GetString ("SYSTEM_DRIVE_DECRYPTING"), 100.0 - ((double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0)); } } else { StringCbPrintfW (szTmpW, sizeof szTmpW, GetString ("SYSTEM_DRIVE_PARTIALLY_ENCRYPTED"), (double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0); } } ListSubItemSetW (hTree, listItem.iItem, 1, szTmpW); GetSizeString (GetSysEncDeviceSize(TRUE), szTmpW, sizeof(szTmpW)); ListSubItemSetW (hTree, listItem.iItem, 2, szTmpW); EAGetName (szTmp, propSysEnc.ea, 1); 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)) { StringCbCopyW (szTmpW, sizeof(szTmpW), GetString (IsHiddenOSRunning() ? "HIDDEN_SYSTEM_PARTITION" : "SYSTEM_PARTITION")); } else { // Partially encrypted if (BootEncStatus.SetupInProgress) { // Currently encrypting/decrypting if (BootEncStatus.SetupMode != SetupDecryption) { StringCbPrintfW (szTmpW, sizeof szTmpW, GetString ("SYSTEM_PARTITION_ENCRYPTING"), (double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0); } else { StringCbPrintfW (szTmpW, sizeof szTmpW, GetString ("SYSTEM_PARTITION_DECRYPTING"), 100.0 - ((double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0)); } } else { StringCbPrintfW (szTmpW, sizeof szTmpW, GetString ("SYSTEM_PARTITION_PARTIALLY_ENCRYPTED"), (double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0); } } ListSubItemSetW (hTree, listItem.iItem, 1, szTmpW); } else { ToSBCS (driver.wszVolume[i], sizeof(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, sizeof(szTmpW)); ListSubItemSetW (hTree, listItem.iItem, 2, szTmpW); EAGetName (szTmp, bSysEncPartition ? propSysEnc.ea : driver.ea[i], 1); 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"?"; } if (driver.truecryptMode[i]) { StringCbPrintfW (szTmpW, sizeof(szTmpW), L"TrueCrypt-%s", ws); ListSubItemSetW (hTree, listItem.iItem, 4, szTmpW); } else 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; StringCbPrintfW (szTmp, sizeof(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); } // implementation for support of change password operation in wait dialog mechanism typedef struct { Password *oldPassword; int old_pkcs5; Password *newPassword; int pkcs5; int wipePassCount; BOOL truecryptMode; int* pnStatus; } ChangePwdThreadParam; void CALLBACK ChangePwdWaitThreadProc(void* pArg, HWND hwndDlg) { ChangePwdThreadParam* pThreadParam = (ChangePwdThreadParam*) pArg; if (bSysEncPwdChangeDlgMode) { // System try { VOLUME_PROPERTIES_STRUCT properties; BootEncObj->GetVolumeProperties(&properties); pThreadParam->old_pkcs5 = properties.pkcs5; } catch(...) {} pThreadParam->pkcs5 = 0; // PKCS-5 PRF unchanged (currently we can't change PRF of system encryption) try { *pThreadParam->pnStatus = BootEncObj->ChangePassword (pThreadParam->oldPassword, pThreadParam->old_pkcs5, pThreadParam->newPassword, pThreadParam->pkcs5, pThreadParam->wipePassCount, hwndDlg); } catch (Exception &e) { e.Show (hwndDlg); *(pThreadParam->pnStatus) = ERR_OS_ERROR; } } else { // Non-system *pThreadParam->pnStatus = ChangePwd (szFileName, pThreadParam->oldPassword, pThreadParam->old_pkcs5, pThreadParam->truecryptMode, pThreadParam->newPassword, pThreadParam->pkcs5, pThreadParam->wipePassCount, hwndDlg); if (*pThreadParam->pnStatus == ERR_OS_ERROR && GetLastError () == ERROR_ACCESS_DENIED && IsUacSupported () && IsVolumeDeviceHosted (szFileName)) { *pThreadParam->pnStatus = UacChangePwd (szFileName, pThreadParam->oldPassword, pThreadParam->old_pkcs5, pThreadParam->truecryptMode, pThreadParam->newPassword, pThreadParam->pkcs5, pThreadParam->wipePassCount, hwndDlg); } } } // implementation for support of backup header operation in wait dialog mechanism typedef struct { BOOL bRequireConfirmation; char *lpszVolume; int* iResult; } BackupHeaderThreadParam; void CALLBACK BackupHeaderWaitThreadProc(void* pArg, HWND hwndDlg) { BackupHeaderThreadParam* pThreadParam = (BackupHeaderThreadParam*) pArg; if (!IsAdmin () && IsUacSupported () && IsVolumeDeviceHosted (pThreadParam->lpszVolume)) *(pThreadParam->iResult) = UacBackupVolumeHeader (hwndDlg, pThreadParam->bRequireConfirmation, pThreadParam->lpszVolume); else *(pThreadParam->iResult) = BackupVolumeHeader (hwndDlg, pThreadParam->bRequireConfirmation, pThreadParam->lpszVolume); } // implementation for support of restoring header operation in wait dialog mechanism typedef struct { char *lpszVolume; int* iResult; } RestoreHeaderThreadParam; void CALLBACK RestoreHeaderWaitThreadProc(void* pArg, HWND hwndDlg) { RestoreHeaderThreadParam* pThreadParam = (RestoreHeaderThreadParam*) pArg; if (!IsAdmin () && IsUacSupported () && IsVolumeDeviceHosted (pThreadParam->lpszVolume)) *(pThreadParam->iResult) = UacRestoreVolumeHeader (hwndDlg, pThreadParam->lpszVolume); else *(pThreadParam->iResult) = RestoreVolumeHeader (hwndDlg, pThreadParam->lpszVolume); } /* 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_OLD_PRF_ID); int i; WipeAlgorithmId headerWipeMode = TC_WIPE_3_DOD_5220; 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); /* Add PRF algorithm list for current password */ SendMessage (hComboBox, CB_RESETCONTENT, 0, 0); nIndex = SendMessageW (hComboBox, CB_ADDSTRING, 0, (LPARAM) GetString ("AUTODETECTION")); SendMessage (hComboBox, CB_SETITEMDATA, nIndex, (LPARAM) 0); for (i = FIRST_PRF_ID; i <= LAST_PRF_ID; 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); /* Add PRF algorithm list for new password */ hComboBox = GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID); 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); PopulateWipeModeCombo (GetDlgItem (hwndDlg, IDC_WIPE_MODE), FALSE, FALSE, TRUE); SelectAlgo (GetDlgItem (hwndDlg, IDC_WIPE_MODE), (int *) &headerWipeMode); 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); EnableWindow (GetDlgItem (hwndDlg, IDT_PKCS5_PRF), FALSE); EnableWindow (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), 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) { /* No support for changing the password of TrueCrypt system partition */ SetCheckBox (hwndDlg, IDC_TRUECRYPT_MODE, FALSE); EnableWindow (GetDlgItem (hwndDlg, IDC_TRUECRYPT_MODE), FALSE); 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", hwndDlg); 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); /* for system encryption, we can't change the PRF */ EnableWindow (GetDlgItem (hwndDlg, IDT_PKCS5_PRF), FALSE); EnableWindow (GetDlgItem (hwndDlg, IDT_NEW_PKCS5_PRF), FALSE); EnableWindow (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), FALSE); EnableWindow (GetDlgItem (hwndDlg, IDC_PKCS5_OLD_PRF_ID), FALSE); if (SetTimer (hwndDlg, TIMER_ID_KEYB_LAYOUT_GUARD, TIMER_INTERVAL_KEYB_LAYOUT_GUARD, NULL) == 0) { Error ("CANNOT_SET_TIMER", hwndDlg); 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", hwndDlg); EndDialog (hwndDlg, IDCANCEL); return 1; } bKeyboardLayoutChanged = TRUE; wchar_t szTmp [4096]; StringCbCopyW (szTmp, sizeof(szTmp), GetString ("KEYB_LAYOUT_CHANGE_PREVENTED")); StringCbCatW (szTmp, sizeof(szTmp), L"\n\n"); StringCbCatW (szTmp, sizeof(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]; StringCbCopyW (szTmp, sizeof(szTmp), GetString ("ALT_KEY_CHARS_NOT_FOR_SYS_ENCRYPTION")); StringCbCatW (szTmp, sizeof(szTmp), L"\n\n"); StringCbCatW (szTmp, sizeof(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", hwndDlg); return 1; } KeyFilesDlgParam param; param.EnableKeyFiles = KeyFilesEnable; param.FirstKeyFile = FirstKeyFile; if (IDOK == DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_KEYFILES), hwndDlg, (DLGPROC) KeyFilesDlgProc, (LPARAM) ¶m)) { 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", hwndDlg); 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 && !HashForSystemEncryption(new_hash_algo_id)) { int new_hash_algo_id = DEFAULT_HASH_ALGORITHM_BOOT; Info ("ALGO_NOT_SUPPORTED_FOR_SYS_ENCRYPTION", hwndDlg); 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; WipeAlgorithmId headerWiperMode = (WipeAlgorithmId) SendMessage ( GetDlgItem (hwndDlg, IDC_WIPE_MODE), CB_GETITEMDATA, SendMessage (GetDlgItem (hwndDlg, IDC_WIPE_MODE), CB_GETCURSEL, 0, 0), 0); int nStatus; int old_pkcs5 = SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_OLD_PRF_ID), CB_GETITEMDATA, SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_OLD_PRF_ID), CB_GETCURSEL, 0, 0), 0); int pkcs5 = SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETITEMDATA, SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETCURSEL, 0, 0), 0); BOOL truecryptMode = GetCheckBox (hwndDlg, IDC_TRUECRYPT_MODE); if (truecryptMode && (old_pkcs5 == SHA256)) { Error ("ALGO_NOT_SUPPORTED_FOR_TRUECRYPT_MODE", hwndDlg); return 1; } if (!CheckPasswordCharEncoding (GetDlgItem (hwndDlg, IDC_PASSWORD), NULL)) { Error ("UNSUPPORTED_CHARS_IN_PWD", hwndDlg); 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 (hwndDlg, &oldPassword, FirstKeyFile); if (newKeyFilesParam.EnableKeyFiles) { if (!KeyFilesApply (hwndDlg, &newPassword, pwdChangeDlgMode == PCDM_CHANGE_PKCS5_PRF ? FirstKeyFile : newKeyFilesParam.FirstKeyFile)) { nStatus = ERR_DONT_REPORT; goto err; } } ChangePwdThreadParam changePwdParam; changePwdParam.oldPassword = &oldPassword; changePwdParam.old_pkcs5 = old_pkcs5; changePwdParam.newPassword = &newPassword; changePwdParam.pkcs5 = pkcs5; changePwdParam.wipePassCount = GetWipePassCount(headerWiperMode); changePwdParam.pnStatus = &nStatus; changePwdParam.truecryptMode = truecryptMode; ShowWaitDialog(hwndDlg, TRUE, ChangePwdWaitThreadProc, &changePwdParam); 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 + 1]; 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; static int *pkcs5; static BOOL* truecryptMode; switch (msg) { case WM_INITDIALOG: { int i, nIndex, defaultPrfIndex = 0; szXPwd = ((PasswordDlgParam *) lParam) -> password; pkcs5 = ((PasswordDlgParam *) lParam) -> pkcs5; truecryptMode = ((PasswordDlgParam *) lParam) -> truecryptMode; 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()) { StringCbPrintfW (s, sizeof(s), GetString ("ENTER_PASSWORD_FOR_LABEL"), label.c_str()); } else { StringCbPrintfW (s, sizeof(s), GetString ("ENTER_PASSWORD_FOR"), "___"); StringCbPrintfW (s, sizeof(s), GetString ("ENTER_PASSWORD_FOR"), FitPathInGfxWidth (hwndDlg, WindowTitleBarFont, rect.right - rect.left - GetTextGfxWidth (hwndDlg, s, WindowTitleBarFont), PasswordDlgVolume).c_str()); } SetWindowTextW (hwndDlg, s); } /* Populate the PRF algorithms list */ HWND hComboBox = GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID); SendMessage (hComboBox, CB_RESETCONTENT, 0, 0); nIndex = SendMessageW (hComboBox, CB_ADDSTRING, 0, (LPARAM) GetString ("AUTODETECTION")); SendMessage (hComboBox, CB_SETITEMDATA, nIndex, (LPARAM) 0); for (i = FIRST_PRF_ID; i <= LAST_PRF_ID; i++) { nIndex = SendMessage (hComboBox, CB_ADDSTRING, 0, (LPARAM) get_pkcs5_prf_name(i)); SendMessage (hComboBox, CB_SETITEMDATA, nIndex, (LPARAM) i); if (*pkcs5 && (*pkcs5 == i)) defaultPrfIndex = nIndex; } /* make autodetection the default unless a specific PRF was specified in the command line */ SendMessage (hComboBox, CB_SETCURSEL, defaultPrfIndex, 0); 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); /* Disable TrueCrypt mode option in case of backup/restore header operation */ SetCheckBox (hwndDlg, IDC_TRUECRYPT_MODE, FALSE); EnableWindow (GetDlgItem (hwndDlg, IDC_TRUECRYPT_MODE), FALSE); } else if (*truecryptMode) { /* Check TrueCryptMode if it is enabled on the command line */ SetCheckBox (hwndDlg, IDC_TRUECRYPT_MODE, TRUE); } 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: { /* Repopulate the PRF algorithms list with algorithms that support system encryption */ HWND hComboBox = GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID); SendMessage (hComboBox, CB_RESETCONTENT, 0, 0); int i, defaultPrfIndex = 0, nIndex = SendMessageW (hComboBox, CB_ADDSTRING, 0, (LPARAM) GetString ("AUTODETECTION")); SendMessage (hComboBox, CB_SETITEMDATA, nIndex, (LPARAM) 0); for (i = FIRST_PRF_ID; i <= LAST_PRF_ID; i++) { if (HashForSystemEncryption(i)) { nIndex = SendMessage (hComboBox, CB_ADDSTRING, 0, (LPARAM) get_pkcs5_prf_name(i)); SendMessage (hComboBox, CB_SETITEMDATA, nIndex, (LPARAM) i); if (*pkcs5 && (*pkcs5 == i)) defaultPrfIndex = nIndex; } } /* make autodetection the default unless a specific PRF was specified in the command line */ SendMessage (hComboBox, CB_SETCURSEL, defaultPrfIndex, 0); 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), ""); StringCbPrintfA (OrigKeyboardLayout, sizeof(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", hwndDlg); EndDialog (hwndDlg, IDCANCEL); return 1; } if (SetTimer (hwndDlg, TIMER_ID_KEYB_LAYOUT_GUARD, TIMER_INTERVAL_KEYB_LAYOUT_GUARD, NULL) == 0) { Error ("CANNOT_SET_TIMER", hwndDlg); 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", hwndDlg); EndDialog (hwndDlg, IDCANCEL); return 1; } wchar_t szTmp [4096]; StringCbCopyW (szTmp, sizeof(szTmp), GetString ("KEYB_LAYOUT_CHANGE_PREVENTED")); StringCbCatW (szTmp, sizeof(szTmp), L"\n\n"); StringCbCatW (szTmp, sizeof(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) ¶m)) { 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 (hwndDlg, &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)); *pkcs5 = (int) SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETITEMDATA, SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETCURSEL, 0, 0), 0); *truecryptMode = GetCheckBox (hwndDlg, IDC_TRUECRYPT_MODE); /* SHA-256 is not supported by TrueCrypt */ if ( (*truecryptMode) && ((*pkcs5 == SHA256) || (mountOptions.ProtectHiddenVolume && mountOptions.ProtectedHidVolPkcs5Prf == SHA256)) ) { Error ("ALGO_NOT_SUPPORTED_FOR_TRUECRYPT_MODE", hwndDlg); return 1; } } // 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", hwndDlg); } 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, ¶m)) { 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)); if (kf) { 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(); BOOL wtsEnabled = (hWtsLib != NULL) ? TRUE : FALSE; 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_SESSION_LOCKED), back && wtsEnabled); 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_SESSION_LOCKED), BM_SETCHECK, bDismountOnSessionLocked ? 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", hwndDlg) == 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_SESSION_LOCKED || 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 sl = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_SESSION_LOCKED)); 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 || sl || p || s)) { if (AskWarnNoYes ("CONFIRM_NO_FORCED_AUTODISMOUNT", hwndDlg) == 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_SESSION_LOCKED && sl || lw == IDC_PREF_DISMOUNT_POWERSAVING && p || lw == IDC_PREF_DISMOUNT_SCREENSAVER && s)) Warning ("WARN_PREF_AUTO_DISMOUNT", hwndDlg); } if (p && lw == IDC_PREF_DISMOUNT_POWERSAVING) Warning ("WARN_PREF_AUTO_DISMOUNT_ON_POWER", hwndDlg); } 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)); bDismountOnSessionLocked = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_SESSION_LOCKED)); 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 (); if (popup) { 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; } else return 0; } 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); /* Add PRF algorithm list for hidden volume password */ HWND hComboBox = GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID); SendMessage (hComboBox, CB_RESETCONTENT, 0, 0); int i, nSelectedIndex = 0, nIndex = SendMessageW (hComboBox, CB_ADDSTRING, 0, (LPARAM) GetString ("AUTODETECTION")); SendMessage (hComboBox, CB_SETITEMDATA, nIndex, (LPARAM) 0); for (i = FIRST_PRF_ID; i <= LAST_PRF_ID; i++) { nIndex = SendMessage (hComboBox, CB_ADDSTRING, 0, (LPARAM) get_pkcs5_prf_name(i)); SendMessage (hComboBox, CB_SETITEMDATA, nIndex, (LPARAM) i); /* if a PRF was selected previously, select it */ if (i == mountOptions->ProtectedHidVolPkcs5Prf) nSelectedIndex = nIndex; } SendMessage (hComboBox, CB_SETCURSEL, nSelectedIndex, 0); 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); EnableWindow (GetDlgItem (hwndDlg, IDT_PKCS5_PRF), protect); EnableWindow (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), 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); mountOptions->ProtectedHidVolPkcs5Prf = SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETITEMDATA, SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETCURSEL, 0, 0), 0); } // 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", hwndDlg) == 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); EnableWindow (GetDlgItem (hwndDlg, IDT_PKCS5_PRF), protect); EnableWindow (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), 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)) { if ( (prop.driveNo == nDosDriveNo) && (prop.ea >= EAGetFirst() && prop.ea <= EAGetCount()) ) { 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)) { if ( (prop.driveNo == nDosDriveNo) && (prop.ea >= EAGetFirst() && prop.ea <= EAGetCount()) && (prop.mode >= FIRST_MODE_OF_OPERATION_ID && prop.mode < MODE_ENUM_END_ID) ) { 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")); StringCbPrintfW (sw, sizeof(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 { bool truecryptMode = prop.pkcs5Iterations == get_pkcs5_iteration_count(prop.pkcs5, TRUE, prop.partitionInInactiveSysEncScope); s = prop.hiddenVolume ? GetString ("HIDDEN") : (prop.hiddenVolProtection != HIDVOL_PROT_STATUS_NONE ? GetString ("OUTER") : GetString ("NORMAL")); if (truecryptMode) { StringCbPrintfW (sw, sizeof(sw), L"TrueCrypt - %s", s); ListSubItemSetW (list, i++, 1, sw); } else ListSubItemSetW (list, i++, 1, s); } 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, 1); ListSubItemSet (list, i++, 1, szTmp); // Key size(s) { char name[128]; int size = EAGetKeySize (prop.ea); EAGetName (name, prop.ea, 1); // Primary key ListItemAddW (list, i, GetString ("KEY_SIZE")); StringCbPrintfW (sw, sizeof(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); } } // Block size ListItemAddW (list, i, GetString ("BLOCK_SIZE")); StringCbPrintfW (sw, sizeof(sw), L"%d ", CipherGetBlockSize (EAGetFirstCipher(prop.ea))*8); StringCbCatW (sw, sizeof(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")); StringCbPrintfA (szTmp, sizeof(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, sizeof(sw)); ListSubItemSetW (list, i++, 1, sw); // Total data written ListItemAddW (list, i, GetString ("TOTAL_DATA_WRITTEN")); GetSizeString (prop.totalBytesWritten, sw, sizeof(sw)); ListSubItemSetW (list, i++, 1, sw); if (bSysEnc) { // TrueCrypt Boot Loader version ListItemAddW (list, i, GetString ("VC_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 { StringCbPrintfW (sw, sizeof sw, 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", hwndDlg); } 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; char* ptr; GetDlgItemText (hwndDlg, IDC_DIRECTORY, dstDir, sizeof dstDir); volName[0] = 0; GetDlgItemText (hwndDlg, IDC_VOLUME_NAME, volName + 1, (sizeof volName) - 1); 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] = '"'; StringCbCatA (volName, sizeof(volName), "\""); } GetModuleFileName (NULL, appDir, sizeof (appDir)); if (ptr = strrchr (appDir, '\\')) ptr[0] = 0; WaitCursor (); GetSystemDirectory (sysDir, sizeof (sysDir)); StringCbPrintfA (dstPath, sizeof(dstPath), "%s\\VeraCrypt", dstDir); CreateDirectory (dstPath, NULL); // Main app StringCbPrintfA (srcPath, sizeof(srcPath), "%s\\VeraCrypt.exe", appDir); StringCbPrintfA (dstPath, sizeof(dstPath), "%s\\VeraCrypt\\VeraCrypt.exe", dstDir); if (!TCCopyFile (srcPath, dstPath)) { handleWin32Error (hwndDlg); goto stop; } // Wizard if (copyWizard) { StringCbPrintfA (srcPath, sizeof(srcPath), "%s\\VeraCrypt Format.exe", appDir); StringCbPrintfA (dstPath, sizeof(dstPath), "%s\\VeraCrypt\\VeraCrypt Format.exe", dstDir); if (!TCCopyFile (srcPath, dstPath)) { handleWin32Error (hwndDlg); goto stop; } } // Driver StringCbPrintfA (srcPath, sizeof(srcPath), "%s\\veracrypt.sys", appDir); StringCbPrintfA (dstPath, sizeof(dstPath), "%s\\VeraCrypt\\veracrypt.sys", dstDir); if (!TCCopyFile (srcPath, dstPath)) { handleWin32Error (hwndDlg); goto stop; } // Driver x64 StringCbPrintfA (srcPath, sizeof(srcPath), "%s\\veracrypt-x64.sys", appDir); StringCbPrintfA (dstPath, sizeof(dstPath), "%s\\VeraCrypt\\veracrypt-x64.sys", dstDir); if (!TCCopyFile (srcPath, dstPath)) { handleWin32Error (hwndDlg); goto stop; } if (GetPreferredLangId () && strcmp (GetPreferredLangId (), "en") != 0) { // Language pack StringCbPrintfA (srcPath, sizeof(srcPath), "%s\\Language.%s.xml", appDir, GetPreferredLangId ()); StringCbPrintfA (dstPath, sizeof(dstPath), "%s\\VeraCrypt\\Language.%s.xml", dstDir, GetPreferredLangId ()); TCCopyFile (srcPath, dstPath); } // AutoRun StringCbPrintfA (dstPath, sizeof(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; } StringCbPrintfA (autoMount, sizeof(autoMount), "VeraCrypt\\VeraCrypt.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=VeraCrypt\\VeraCrypt.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 : "VeraCrypt\\VeraCrypt.exe"); fwprintf (af, L"shell\\start=%s\nshell\\start\\command=VeraCrypt\\VeraCrypt.exe\n", GetString ("IDC_PREF_LOGON_START")); fwprintf (af, L"shell\\dismount=%s\nshell\\dismount\\command=VeraCrypt\\VeraCrypt.exe /q /d\n", GetString ("DISMOUNT_ALL_TC_VOLUMES")); CheckFileStreamWriteErrors (hwndDlg, af, dstPath); fclose (af); } MessageBoxW (hwndDlg, GetString ("TRAVELER_DISK_CREATED"), lpszTitle, MB_ICONINFORMATION); stop: NormalCursor (); return 1; } return 0; } return 0; } void BuildTree (HWND hwndDlg, 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 (200); 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 (123); lvCol.fmt = LVCFMT_LEFT; SendMessage (hTree,LVM_INSERTCOLUMNW,3,(LPARAM)&lvCol); lvCol.pszText = GetString ("TYPE"); lvCol.cx = CompensateXDPI (100); 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 (hwndDlg, 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, int *pkcs5, BOOL* truecryptMode, char *titleStringId, BOOL enableMountOptions) { int result; PasswordDlgParam dlgParam; PasswordDialogTitleStringId = titleStringId; PasswordDialogDisableMountOptions = !enableMountOptions; dlgParam.password = password; dlgParam.pkcs5 = pkcs5; dlgParam.truecryptMode = truecryptMode; result = DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_PASSWORD_DLG), hwndDlg, (DLGPROC) PasswordDlgProc, (LPARAM) &dlgParam); if (result != IDOK) { password->Length = 0; *pkcs5 = 0; *truecryptMode = FALSE; burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword)); burn (&mountOptions.ProtectedHidVolPkcs5Prf, sizeof (mountOptions.ProtectedHidVolPkcs5Prf)); } return result == IDOK; } // GUI actions static BOOL Mount (HWND hwndDlg, int nDosDriveNo, char *szFileName) { BOOL status = FALSE; char fileName[MAX_PATH]; int mounted = 0; bPrebootPasswordDlgMode = mountOptions.PartitionInInactiveSysEncScope; if (nDosDriveNo == 0) nDosDriveNo = HIWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) - 'A'; if (!MultipleMountOperationInProgress) { VolumePassword.Length = 0; VolumePkcs5 = 0; VolumeTrueCryptMode = FALSE; } 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", hwndDlg); 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, CmdVolumePkcs5, CmdVolumeTrueCryptMode, bCacheInDriver, bForceMount, &mountOptions, Silent, FALSE); // If keyfiles are enabled, test empty password first if (!mounted && KeyFilesEnable && FirstKeyFile) { Password emptyPassword; emptyPassword.Length = 0; KeyFilesApply (hwndDlg, &emptyPassword, FirstKeyFile); mounted = MountVolume (hwndDlg, nDosDriveNo, szFileName, &emptyPassword, CmdVolumePkcs5, CmdVolumeTrueCryptMode, bCacheInDriver, bForceMount, &mountOptions, Silent, FALSE); if (mounted) { VolumePkcs5 = CmdVolumePkcs5; VolumeTrueCryptMode = CmdVolumeTrueCryptMode; } 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, VolumePkcs5, VolumeTrueCryptMode, bCacheInDriver, bForceMount, &mountOptions, Silent, FALSE); NormalCursor (); if (mounted) { // Check for problematic file extensions (exe, dll, sys) if (CheckFileExtension(szFileName)) Warning ("EXE_FILE_EXTENSION_MOUNT_WARNING", hwndDlg); } while (mounted == 0) { if (CmdVolumePassword.Length > 0) { VolumePassword = CmdVolumePassword; VolumePkcs5 = CmdVolumePkcs5; VolumeTrueCryptMode = CmdVolumeTrueCryptMode; } else if (!Silent) { int GuiPkcs5 = CmdVolumePkcs5; BOOL GuiTrueCryptMode = CmdVolumeTrueCryptMode; StringCbCopyA (PasswordDlgVolume, sizeof(PasswordDlgVolume), szFileName); if (!AskVolumePassword (hwndDlg, &VolumePassword, &GuiPkcs5, &GuiTrueCryptMode, NULL, TRUE)) goto ret; else { VolumePkcs5 = GuiPkcs5; VolumeTrueCryptMode = GuiTrueCryptMode; burn (&GuiPkcs5, sizeof(GuiPkcs5)); burn (&GuiTrueCryptMode, sizeof(GuiTrueCryptMode)); } } WaitCursor (); if (KeyFilesEnable) KeyFilesApply (hwndDlg, &VolumePassword, FirstKeyFile); mounted = MountVolume (hwndDlg, nDosDriveNo, szFileName, &VolumePassword, VolumePkcs5, VolumeTrueCryptMode, bCacheInDriver, bForceMount, &mountOptions, Silent, !Silent); NormalCursor (); // Check for legacy non-ASCII passwords if (mounted > 0 && !KeyFilesEnable && !CheckPasswordCharEncoding (NULL, &VolumePassword)) Warning ("UNSUPPORTED_CHARS_IN_PWD_RECOM", hwndDlg); // Check for problematic file extensions (exe, dll, sys) if (mounted > 0 && CheckFileExtension (szFileName)) Warning ("EXE_FILE_EXTENSION_MOUNT_WARNING", hwndDlg); if (!MultipleMountOperationInProgress) { burn (&VolumePassword, sizeof (VolumePassword)); burn (&VolumePkcs5, sizeof (VolumePkcs5)); burn (&VolumeTrueCryptMode, sizeof (VolumeTrueCryptMode)); } burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword)); burn (&mountOptions.ProtectedHidVolPkcs5Prf, sizeof (mountOptions.ProtectedHidVolPkcs5Prf)); 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", hwndDlg); } ret: if (!MultipleMountOperationInProgress) { burn (&VolumePassword, sizeof (VolumePassword)); burn (&VolumePkcs5, sizeof (VolumePkcs5)); burn (&VolumeTrueCryptMode, sizeof (VolumeTrueCryptMode)); } burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword)); burn (&mountOptions.ProtectedHidVolPkcs5Prf, sizeof (mountOptions.ProtectedHidVolPkcs5Prf)); 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 (hwndDlg, GetDlgItem (hwndDlg, IDC_DRIVELIST), 0); } NormalCursor (); return status; } void __cdecl mountThreadFunction (void *hwndDlgArg) { HWND hwndDlg =(HWND) hwndDlgArg; // Disable parent dialog during processing to avoid user interaction EnableWindow(hwndDlg, FALSE); finally_do_arg (HWND, hwndDlg, { EnableWindow(finally_arg, TRUE); }); Mount (hwndDlg, 0, 0); } static BOOL DismountAll (HWND hwndDlg, BOOL forceUnmount, BOOL interact, int dismountMaxRetries, int dismountAutoRetryDelay) { BOOL status = TRUE; MOUNT_LIST_STRUCT mountList = {0}; DWORD dwResult; UNMOUNT_STRUCT unmount = {0}; 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 ( unmount.nDosDriveNo < 0 || unmount.nDosDriveNo > 25 || (unmount.ignoreOpenFiles != TRUE && unmount.ignoreOpenFiles != FALSE) || (unmount.HiddenVolumeProtectionTriggered != TRUE && unmount.HiddenVolumeProtectionTriggered != FALSE) || (unmount.nReturnCode < 0) ) { if (bResult) SetLastError (ERROR_INTERNAL_ERROR); bResult = FALSE; } 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; StringCbPrintfW (msg, sizeof(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 (hwndDlg, 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", hwndDlg)) { 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, bHeaderBakRetry = FALSE; int mountedVolCount = 0; vector <HostDevice> devices; VolumePassword.Length = 0; mountOptions = defaultMountOptions; bPrebootPasswordDlgMode = FALSE; if (selDrive == -1) selDrive = 0; ResetWrongPwdRetryCount (); MultipleMountOperationInProgress = TRUE; do { if (!bHeaderBakRetry) { if (!CmdVolumePasswordValid && bPasswordPrompt) { int GuiPkcs5 = CmdVolumePkcs5; BOOL GuiTrueCryptMode = CmdVolumeTrueCryptMode; PasswordDlgVolume[0] = '\0'; if (!AskVolumePassword (hwndDlg, &VolumePassword, &GuiPkcs5, &GuiTrueCryptMode, NULL, TRUE)) goto ret; else { VolumePkcs5 = GuiPkcs5; VolumeTrueCryptMode = GuiTrueCryptMode; burn (&GuiPkcs5, sizeof(GuiPkcs5)); burn (&GuiTrueCryptMode, sizeof(GuiTrueCryptMode)); } } else if (CmdVolumePasswordValid) { bPasswordPrompt = FALSE; VolumePassword = CmdVolumePassword; VolumePkcs5 = CmdVolumePkcs5; VolumeTrueCryptMode = CmdVolumeTrueCryptMode; } WaitCursor(); if (FirstCmdKeyFile) KeyFilesApply (hwndDlg, &VolumePassword, FirstCmdKeyFile); else if (KeyFilesEnable) KeyFilesApply (hwndDlg, &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, VolumePkcs5, VolumeTrueCryptMode, bCacheInDriver, bForceMount, &mountOptions, TRUE, FALSE)) > 0 || (mounted = MountVolume (hwndDlg, nDosDriveNo, szFileName, NULL, VolumePkcs5, VolumeTrueCryptMode, bCacheInDriver, bForceMount, &mountOptions, TRUE, FALSE)) > 0) { // A volume has been successfully mounted ResetWrongPwdRetryCount (); if (mounted == 2) shared = TRUE; LoadDriveLetters (hwndDlg, driveList, (HIWORD (GetItemLong (GetDlgItem (hwndDlg, IDC_DRIVELIST), selDrive)))); selDrive++; if (bExplore) { WaitCursor(); OpenVolumeExplorerWindow (nDosDriveNo); NormalCursor(); } if (bBeep) MessageBeep (0xFFFFFFFF); status = 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]; StringCbPrintfW (szTmp, sizeof(szTmp), GetString (KeyFilesEnable || FirstCmdKeyFile ? "PASSWORD_OR_KEYFILE_WRONG_AUTOMOUNT" : "PASSWORD_WRONG_AUTOMOUNT")); if (CheckCapsLock (hwndDlg, TRUE)) StringCbCatW (szTmp, sizeof(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", hwndDlg); } if (!bHeaderBakRetry) { burn (&VolumePassword, sizeof (VolumePassword)); burn (&VolumePkcs5, sizeof (VolumePkcs5)); burn (&VolumeTrueCryptMode, sizeof (VolumeTrueCryptMode)); burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword)); burn (&mountOptions.ProtectedHidVolPkcs5Prf, sizeof (mountOptions.ProtectedHidVolPkcs5Prf)); } } while (bPasswordPrompt && mountedVolCount < 1); /* One or more volumes successfully mounted */ ResetWrongPwdRetryCount (); if (shared) Warning ("DEVICE_IN_USE_INFO", hwndDlg); if (mountOptions.ProtectHiddenVolume) { if (mountedVolCount > 1) Info ("HIDVOL_PROT_WARN_AFTER_MOUNT_PLURAL", hwndDlg); else if (mountedVolCount == 1) Info ("HIDVOL_PROT_WARN_AFTER_MOUNT", hwndDlg); } // Check for legacy non-ASCII passwords if (!KeyFilesEnable && !FirstCmdKeyFile && mountedVolCount > 0 && !CheckPasswordCharEncoding (NULL, &VolumePassword)) Warning ("UNSUPPORTED_CHARS_IN_PWD_RECOM", hwndDlg); if (status && CloseSecurityTokenSessionsAfterMount) SecurityToken::CloseAllSessions(); ret: MultipleMountOperationInProgress = FALSE; burn (&VolumePassword, sizeof (VolumePassword)); burn (&VolumePkcs5, sizeof (VolumePkcs5)); burn (&VolumeTrueCryptMode, sizeof (VolumeTrueCryptMode)); burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword)); burn (&mountOptions.ProtectedHidVolPkcs5Prf, sizeof (mountOptions.ProtectedHidVolPkcs5Prf)); 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", hwndDlg); 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", hwndDlg); break; case PCDM_ADD_REMOVE_VOL_KEYFILES: case PCDM_REMOVE_ALL_KEYFILES_FROM_VOL: Info ("KEYFILE_CHANGED", hwndDlg); break; case PCDM_CHANGE_PASSWORD: default: Info ("PASSWORD_CHANGED", hwndDlg); } } } // 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", hwndDlg); return; } if (SysEncryptionOrDecryptionRequired () || BootEncStatus.SetupInProgress) { Warning ("SYSTEM_ENCRYPTION_NOT_COMPLETED", hwndDlg); return; } if (CreateSysEncMutex ()) // If no instance of the wizard is currently taking care of system encryption { StringCbPrintfA (OrigKeyboardLayout, sizeof(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", hwndDlg); else bKeyboardLayoutChanged = FALSE; } bKeybLayoutAltKeyWarningShown = FALSE; if (result == IDOK) { switch (pwdChangeDlgMode) { case PCDM_CHANGE_PKCS5_PRF: Info ("PKCS5_PRF_CHANGED", hwndDlg); if (!IsHiddenOSRunning()) { if (AskWarnYesNo ("SYS_HKD_ALGO_CHANGED_ASK_RESCUE_DISK", hwndDlg) == IDYES) CreateRescueDisk (hwndDlg); } 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", hwndDlg); if (!IsHiddenOSRunning()) { if (AskWarnYesNo ("SYS_PASSWORD_CHANGED_ASK_RESCUE_DISK", hwndDlg) == IDYES) CreateRescueDisk (hwndDlg); } } } CloseSysEncMutex (); } else Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE", hwndDlg); } // Initiates or resumes encryption of the system partition/drive static void EncryptSystemDevice (HWND hwndDlg) { 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", hwndDlg); 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", hwndDlg); } else if (SysDriveOrPartitionFullyEncrypted (FALSE)) { // System partition/drive appears to be fully encrypted Info ("SYS_PARTITION_OR_DRIVE_APPEARS_FULLY_ENCRYPTED", hwndDlg); return; } } // Initiates decryption of the system partition/drive static void DecryptSystemDevice (HWND hwndDlg) { 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", hwndDlg); return; } if (IsHiddenOSRunning()) { Warning ("CANNOT_DECRYPT_HIDDEN_OS", hwndDlg); return; } if (AskNoYes ("CONFIRM_DECRYPT_SYS_DEVICE", hwndDlg) == IDNO) return; if (AskWarnNoYes ("CONFIRM_DECRYPT_SYS_DEVICE_CAUTION", hwndDlg) == 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", hwndDlg); return; } CloseSysEncMutex (); LaunchVolCreationWizard (MainDlg, "/dsysenc"); } else Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE", hwndDlg); } // Initiates the process of creation of a hidden operating system static void CreateHiddenOS (HWND hwndDlg) { // 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", hwndDlg); 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 (HWND hwndDlg) { 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", hwndDlg); } void CreateRescueDisk (HWND hwndDlg) { try { BootEncStatus = BootEncObj->GetStatus(); } catch (Exception &e) { e.Show (MainDlg); } if (IsHiddenOSRunning()) { Warning ("CANNOT_CREATE_RESCUE_DISK_ON_HIDDEN_OS", hwndDlg); return; } if (!BootEncStatus.DriveEncrypted && !BootEncStatus.DriveMounted && !BootEncStatus.VolumeHeaderPresent && !SysEncryptionOrDecryptionRequired ()) { Warning ("SYS_DRIVE_NOT_ENCRYPTED", hwndDlg); return; } if (SysEncryptionOrDecryptionRequired () || BootEncStatus.SetupInProgress) { Warning ("SYSTEM_ENCRYPTION_NOT_COMPLETED", hwndDlg); 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", hwndDlg) != IDOK) { CloseSysEncMutex (); return; } char initialDir[MAX_PATH]; SHGetFolderPath (NULL, CSIDL_MYDOCUMENTS, NULL, 0, initialDir); if (!BrowseFilesInDir (hwndDlg, "OPEN_TITLE", initialDir, szRescueDiskISO, FALSE, TRUE, NULL, L"VeraCrypt Rescue Disk.iso", L"iso")) { CloseSysEncMutex (); return; } WaitCursor(); BootEncObj->CreateRescueIsoImage (false, szRescueDiskISO); StringCbPrintfW (szTmp, sizeof szTmp, GetString (IsWindowsIsoBurnerAvailable() ? "RESCUE_DISK_NON_WIZARD_CREATION_WIN_ISOBURN" : "RESCUE_DISK_NON_WIZARD_CREATION_BURN"), szRescueDiskISO); if (IsWindowsIsoBurnerAvailable()) { if (AskYesNoString (szTmp, hwndDlg) == IDYES) LaunchWindowsIsoBurner (MainDlg, szRescueDiskISO); } else InfoDirect (szTmp, hwndDlg); } catch (Exception &e) { e.Show (hwndDlg); Error ("ERROR_CREATING_RESCUE_DISK", hwndDlg); } CloseSysEncMutex (); NormalCursor (); } else Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE", hwndDlg); } static void VerifyRescueDisk (HWND hwndDlg) { try { BootEncStatus = BootEncObj->GetStatus(); } catch (Exception &e) { e.Show (MainDlg); } if (!BootEncStatus.DriveEncrypted && !BootEncStatus.DriveMounted && !BootEncStatus.VolumeHeaderPresent && !SysEncryptionOrDecryptionRequired ()) { Warning ("SYS_DRIVE_NOT_ENCRYPTED", hwndDlg); return; } if (SysEncryptionOrDecryptionRequired () || BootEncStatus.SetupInProgress) { Warning ("SYSTEM_ENCRYPTION_NOT_COMPLETED", hwndDlg); 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", hwndDlg) != 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", hwndDlg); else Info ("RESCUE_DISK_NON_WIZARD_CHECK_PASSED", hwndDlg); } catch (Exception &e) { e.Show (MainDlg); Error ("RESCUE_DISK_NON_WIZARD_CHECK_FAILED", hwndDlg); } CloseSysEncMutex (); NormalCursor (); } else Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE", hwndDlg); } static void ShowSystemEncryptionStatus (HWND hwndDlg) { 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", hwndDlg); return; } DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_VOLUME_PROPERTIES), hwndDlg, (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"); } 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; } 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", hwndDlg); } } static void Benchmark (HWND hwndDlg) { DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_BENCHMARK_DLG), hwndDlg, (DLGPROC) BenchmarkDlgProc, (LPARAM) NULL); } static BOOL CheckMountList (HWND hwndDlg, BOOL bForceTaskBarUpdate) { MOUNT_LIST_STRUCT current; static BootEncryptionStatus newBootEncStatus; static BOOL lastbUseDifferentTrayIconIfVolMounted = bUseDifferentTrayIconIfVolMounted; static uint32 lastUlMountedDrives = 0; GetMountList (¤t); if ((bForceTaskBarUpdate || 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 (bForceTaskBarUpdate) { return TRUE; } if (LastKnownLogicalDrives != GetLogicalDrives() || memcmp (&LastKnownMountList, ¤t, sizeof (current)) != 0) { char selDrive; WaitCursor (); LastKnownMountList = current; selDrive = (char) HIWORD (GetSelectedLong (GetDlgItem (MainDlg, IDC_DRIVELIST))); LoadDriveLetters (hwndDlg, 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 (hwndDlg, 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", hwndDlg); else WarningTopMost ("SYS_ENC_HIBERNATION_PREVENTED", hwndDlg); } // 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, hwndDlg)) { 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(), hwndDlg); 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(), hwndDlg); // 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; 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", hwndDlg); } else if (SysDriveOrPartitionFullyEncrypted (TRUE) && BootEncObj->GetInstalledBootLoaderVersion() != VERSION_NUM) { Warning ("BOOT_LOADER_VERSION_DIFFERENT_FROM_DRIVER_VERSION", hwndDlg); } } 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, CmdVolumePkcs5, CmdVolumeTrueCryptMode, bCacheInDriver, bForceMount, &mountOptions, Silent, FALSE); // Command line password or keyfiles if (!mounted && (CmdVolumePassword.Length != 0 || FirstCmdKeyFile)) { BOOL reportBadPasswd = CmdVolumePassword.Length > 0; if (FirstCmdKeyFile) KeyFilesApply (hwndDlg, &CmdVolumePassword, FirstCmdKeyFile); mounted = MountVolume (hwndDlg, szDriveLetter[0] - 'A', szFileName, &CmdVolumePassword, CmdVolumePkcs5, CmdVolumeTrueCryptMode, bCacheInDriver, bForceMount, &mountOptions, Silent, reportBadPasswd); burn (&CmdVolumePassword, sizeof (CmdVolumePassword)); } if (FirstCmdKeyFile) { FirstKeyFile = FirstCmdKeyFile; KeyFilesEnable = TRUE; } // Ask user for password while (!mounted && !Silent) { int GuiPkcs5 = CmdVolumePkcs5; BOOL GuiTrueCryptMode = CmdVolumeTrueCryptMode; VolumePassword.Length = 0; StringCbCopyA (PasswordDlgVolume, sizeof(PasswordDlgVolume),szFileName); if (!AskVolumePassword (hwndDlg, &VolumePassword, &GuiPkcs5, &GuiTrueCryptMode, NULL, TRUE)) break; else { VolumePkcs5 = GuiPkcs5; VolumeTrueCryptMode = GuiTrueCryptMode; burn (&GuiPkcs5, sizeof(GuiPkcs5)); burn (&GuiTrueCryptMode, sizeof(GuiTrueCryptMode)); } WaitCursor (); if (KeyFilesEnable && FirstKeyFile) KeyFilesApply (hwndDlg, &VolumePassword, FirstKeyFile); mounted = MountVolume (hwndDlg, szDriveLetter[0] - 'A', szFileName, &VolumePassword, VolumePkcs5, VolumeTrueCryptMode, bCacheInDriver, bForceMount, &mountOptions, FALSE, TRUE); burn (&VolumePassword, sizeof (VolumePassword)); burn (&VolumePkcs5, sizeof (VolumePkcs5)); burn (&VolumeTrueCryptMode, sizeof (VolumeTrueCryptMode)); burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword)); burn (&mountOptions.ProtectedHidVolPkcs5Prf, sizeof (mountOptions.ProtectedHidVolPkcs5Prf)); 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 problematic file extensions (exe, dll, sys) if (CheckFileExtension (szFileName)) Warning ("EXE_FILE_EXTENSION_MOUNT_WARNING", hwndDlg); } } else exitCode = 1; } else if (bExplore && GetMountedVolumeDriveNo (szFileName) != -1) OpenVolumeExplorerWindow (GetMountedVolumeDriveNo (szFileName)); else if (szFileName[0] != 0 && IsMountedVolume (szFileName)) Warning ("VOL_ALREADY_MOUNTED", hwndDlg); 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", hwndDlg); 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", hwndDlg); 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", hwndDlg) == 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(hwndDlg) == 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); } } } if (TaskBarIconMutex != NULL) RegisterWtsNotification(hwndDlg); DoPostInstallTasks (hwndDlg); 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_WTSSESSION_CHANGE: if (TaskBarIconMutex != NULL) { if (bDismountOnSessionLocked && (WTS_SESSION_LOCK == wParam)) { // Auto-dismount when session is locked 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_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); UnregisterWtsNotification(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 (hwndDlg, FALSE); // 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", hwndDlg); if (warnings.PagingFileCreationPrevented) WarningTopMost ("PAGING_FILE_CREATION_PREVENTED", hwndDlg); } 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", hwndDlg) == IDYES) { if (!IsAdmin() && IsUacSupported()) UacAnalyzeKernelMiniDump (hwndDlg); else AnalyzeKernelMiniDump (hwndDlg); } else if (AskYesNoTopmost ("ASK_KEEP_DETECTING_SYSTEM_CRASH", hwndDlg) == 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); UnregisterWtsNotification(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, ""); } 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, ""); } 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, ""); 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)); StringCbPrintfW (s, sizeof(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, ""); } 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, ""); 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 (hwndDlg, FALSE)) { if (Dismount (hwndDlg, sel - TRAYICON_MENU_DRIVE_OFFSET - 26)) { wchar_t txt [2048]; StringCbPrintfW (txt, sizeof(txt), GetString ("VOLUME_MOUNTED_AS_DRIVE_LETTER_X_DISMOUNTED"), sel - TRAYICON_MENU_DRIVE_OFFSET - 26 + L'A'); InfoBalloonDirect (GetString ("SUCCESSFULLY_DISMOUNTED"), txt, hwndDlg); } } } 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", hwndDlg) == IDYES) { // Close all other TC windows EnumWindows (CloseTCWindowsEnum, 0); TaskBarIconRemove (hwndDlg); UnregisterWtsNotification(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); UnregisterWtsNotification(hwndDlg); return 1; case TC_APPMSG_SYSENC_CONFIG_UPDATE: LoadSysEncSettings (hwndDlg); // The wizard added VeraCrypt.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", hwndDlg); } } } } } } // 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; StringCbPrintfA (volp, sizeof(volp), "%ls", vol); if (IsVolumeDeviceHosted (volp)) { OPEN_TEST_STRUCT ots = {0}; if (!OpenDevice (volp, &ots, FALSE)) { UnmountVolume (hwndDlg, m, TRUE); WarningBalloon ("HOST_DEVICE_REMOVAL_DISMOUNT_WARN_TITLE", "HOST_DEVICE_REMOVAL_DISMOUNT_WARN", hwndDlg); } } } } // 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 (hwndDlg, 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 (hwndDlg, &mountOptions.ProtectedHidVolPassword, hidVolProtKeyFilesParam.FirstKeyFile); } if (CheckMountList (hwndDlg, FALSE)) _beginthread(mountThreadFunction, 0, hwndDlg); } 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, ""); 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, ""); 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, ""); 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, ""); 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 (hwndDlg, (char) HIWORD (lLetter) - 'A', menuItem == IDPM_REPAIR_FILESYS); } break; case IDM_UNMOUNT_VOLUME: if (CheckMountList (hwndDlg, FALSE)) 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", hwndDlg); } else { mountOptions = defaultMountOptions; bPrebootPasswordDlgMode = FALSE; if (CheckMountList (hwndDlg, FALSE)) _beginthread(mountThreadFunction, 0, hwndDlg); } 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", hwndDlg); return 1; } if (CheckMountList (hwndDlg, FALSE)) 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"VeraCrypt", 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", hwndDlg); } 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 (hwndDlg); break; case IDM_PERMANENTLY_DECRYPT_SYS: DecryptSystemDevice (hwndDlg); break; case IDM_CREATE_HIDDEN_OS: CreateHiddenOS (hwndDlg); break; case IDM_SYSENC_RESUME: ResumeInterruptedSysEncProcess (hwndDlg); break; case IDM_SYSTEM_ENCRYPTION_STATUS: ShowSystemEncryptionStatus (hwndDlg); 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 (hwndDlg); break; case IDM_VERIFY_RESCUE_DISK: VerifyRescueDisk (hwndDlg); break; case IDM_MOUNT_SYSENC_PART_WITHOUT_PBA: if (CheckSysEncMountWithoutPBA (hwndDlg, "", FALSE)) { mountOptions = defaultMountOptions; mountOptions.PartitionInInactiveSysEncScope = TRUE; bPrebootPasswordDlgMode = TRUE; if (CheckMountList (hwndDlg, FALSE)) _beginthread(mountThreadFunction, 0, hwndDlg); 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, ""); 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, ""); 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", hwndDlg); } else { pwdChangeDlgMode = PCDM_CHANGE_PASSWORD; ChangePassword (hwndDlg); } break; case IDM_CHANGE_HEADER_KEY_DERIV_ALGO: if (!VolumeSelected(hwndDlg)) { Warning ("NO_VOLUME_SELECTED", hwndDlg); } else { pwdChangeDlgMode = PCDM_CHANGE_PKCS5_PRF; ChangePassword (hwndDlg); } break; case IDM_ADD_REMOVE_VOL_KEYFILES: if (!VolumeSelected(hwndDlg)) { Warning ("NO_VOLUME_SELECTED", hwndDlg); } else { pwdChangeDlgMode = PCDM_ADD_REMOVE_VOL_KEYFILES; ChangePassword (hwndDlg); } break; case IDM_REMOVE_ALL_KEYFILES_FROM_VOL: if (!VolumeSelected(hwndDlg)) { Warning ("NO_VOLUME_SELECTED", hwndDlg); } else { pwdChangeDlgMode = PCDM_REMOVE_ALL_KEYFILES_FROM_VOL; ChangePassword (hwndDlg); } break; case IDM_BACKUP_VOL_HEADER: if (!VolumeSelected(hwndDlg)) { Warning ("NO_VOLUME_SELECTED", hwndDlg); } else { GetWindowText (GetDlgItem (hwndDlg, IDC_VOLUME), volPath, sizeof (volPath)); WaitCursor (); int iStatus = 0; BackupHeaderThreadParam threadParam; threadParam.bRequireConfirmation = TRUE; threadParam.lpszVolume = volPath; threadParam.iResult = &iStatus; ShowWaitDialog (hwndDlg, TRUE, BackupHeaderWaitThreadProc, &threadParam); NormalCursor (); } break; case IDM_RESTORE_VOL_HEADER: if (!VolumeSelected(hwndDlg)) { Warning ("NO_VOLUME_SELECTED", hwndDlg); } else { GetWindowText (GetDlgItem (hwndDlg, IDC_VOLUME), volPath, sizeof (volPath)); WaitCursor (); int iStatus = 0; RestoreHeaderThreadParam threadParam; threadParam.lpszVolume = volPath; threadParam.iResult = &iStatus; ShowWaitDialog(hwndDlg, TRUE, RestoreHeaderWaitThreadProc, &threadParam); NormalCursor (); } break; default: SendMessage (MainDlg, WM_COMMAND, menuItem, NULL); break; } return 1; } if (lw == IDM_CHANGE_PASSWORD) { if (!VolumeSelected(hwndDlg)) { Warning ("NO_VOLUME_SELECTED", hwndDlg); } 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", hwndDlg); } 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", hwndDlg); } 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", hwndDlg); } 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", hwndDlg); return 1; } if (lw == IDM_KEYFILE_GENERATOR) { DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_KEYFILE_GENERATOR), hwndDlg, (DLGPROC) KeyfileGeneratorDlgProc, (LPARAM) 0); return 1; } if (lw == IDM_DONATE) { Applink ("donate", TRUE, ""); 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); RegisterWtsNotification(hwndDlg); } else { TaskBarIconRemove (hwndDlg); UnregisterWtsNotification(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", hwndDlg); 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", hwndDlg); return 1; } // volPathHigher will contain the volume path selected in the main drive list wstring volPathHigher (prop.wszVolume); ToSBCS (prop.wszVolume, sizeof(prop.wszVolume)); StringCbCopyA ((char *) volPathLowerW, sizeof(volPathLowerW), volPathLower); ToUNICODE ((char *) volPathLowerW, sizeof(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, hwndDlg)) { 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", hwndDlg); } else { char volPath[TC_MAX_PATH]; /* Volume to mount */ GetWindowText (GetDlgItem (hwndDlg, IDC_VOLUME), volPath, sizeof (volPath)); WaitCursor (); int iStatus = 0; BackupHeaderThreadParam threadParam; threadParam.bRequireConfirmation = TRUE; threadParam.lpszVolume = volPath; threadParam.iResult = &iStatus; ShowWaitDialog (hwndDlg, TRUE, BackupHeaderWaitThreadProc, &threadParam); NormalCursor (); } return 1; } if (lw == IDM_RESTORE_VOL_HEADER) { if (!VolumeSelected(hwndDlg)) { Warning ("NO_VOLUME_SELECTED", hwndDlg); } else { char volPath[TC_MAX_PATH]; /* Volume to mount */ GetWindowText (GetDlgItem (hwndDlg, IDC_VOLUME), volPath, sizeof (volPath)); WaitCursor (); int iStatus = 0; RestoreHeaderThreadParam threadParam; threadParam.lpszVolume = volPath; threadParam.iResult = &iStatus; ShowWaitDialog(hwndDlg, TRUE, RestoreHeaderWaitThreadProc, &threadParam); 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 (hwndDlg, 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) { _beginthread(mountFavoriteVolumeThreadFunction, 0, NULL); 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 { mountFavoriteVolumeThreadParam* pParam = (mountFavoriteVolumeThreadParam*) calloc(1, sizeof(mountFavoriteVolumeThreadParam)); pParam->systemFavorites = FALSE; pParam->logOnMount = FALSE; pParam->hotKeyMount = FALSE; pParam->favoriteVolumeToMount = &FavoriteVolumes[favoriteIndex]; _beginthread(mountFavoriteVolumeThreadFunction, 0, pParam); } } 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); CheckMountList(hwndDlg, TRUE); return 1; } } return 0; } void ExtractCommandLine (HWND hwndDlg, char *lpszCommandLine) { char **lpszCommandLineArgs = NULL; /* 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, OptionPkcs5, OptionTrueCryptMode, }; 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 }, { OptionPkcs5, "/hash", NULL , FALSE }, { OptionTrueCryptMode, "/truecrypt", "/tc", 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)); if (kf) { StringCbCopyA (kf->FileName, sizeof(kf->FileName), tmpPath); 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(hwndDlg); else Error ("COMMAND_LINE_ERROR", hwndDlg); break; case CommandWipeCache: bWipe = TRUE; break; case CommandHelp: DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_COMMANDHELP_DLG), hwndDlg, (DLGPROC) CommandHelpDlgProc, (LPARAM) &as); exit(0); break; case OptionPkcs5: { char szTmp[32]; if (HAS_ARGUMENT == GetArgumentValue (lpszCommandLineArgs, nArgPos, &i, nNoCommandLineArgs, szTmp, sizeof (szTmp))) { if (_stricmp(szTmp, "sha512") == 0 || _stricmp(szTmp, "sha-512") == 0) CmdVolumePkcs5 = SHA512; else if (_stricmp(szTmp, "whirlpool") == 0) CmdVolumePkcs5 = WHIRLPOOL; else if (_stricmp(szTmp, "sha256") == 0 || _stricmp(szTmp, "sha-256") == 0) CmdVolumePkcs5 = SHA256; else if (_stricmp(szTmp, "ripemd160") == 0 || _stricmp(szTmp, "ripemd-160") == 0) CmdVolumePkcs5 = RIPEMD160; else { CmdVolumePkcs5 = 0; Error ("COMMAND_LINE_ERROR", hwndDlg); } } else Error ("COMMAND_LINE_ERROR", hwndDlg); } break; case OptionTrueCryptMode: CmdVolumeTrueCryptMode = TRUE; 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]); } if (lpszCommandLineArgs) free (lpszCommandLineArgs); } 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; } #ifndef VCEXPANDER 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"VeraCrypt"; 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); FinalizeApp (); /* Terminate */ return 0; } #endif 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, "VeraCryptTaskBarIcon"); if (TaskBarIconMutex == NULL || GetLastError () == ERROR_ALREADY_EXISTS) { if (TaskBarIconMutex != NULL) { CloseHandle(TaskBarIconMutex); 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 StringCbCopyW (tnid.szTip, sizeof(tnid.szTip), L"VeraCrypt"); 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 && ( (prop.driveNo == i) && prop.uniqueId >= 0 && prop.ea >= EAGetFirst() && prop.ea <= EAGetCount() && prop.mode >= FIRST_MODE_OF_OPERATION_ID && prop.mode <= LAST_MODE_OF_OPERATION && prop.pkcs5 >= FIRST_PRF_ID && prop.pkcs5 <= LAST_PRF_ID && prop.pkcs5Iterations > 0 && prop.hiddenVolProtection >= 0 && prop.volFormatVersion >= 0 ) ) { 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 (MainDlg, 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", MainDlg); } MultipleMountOperationInProgress = FALSE; burn (&VolumePassword, sizeof (VolumePassword)); burn (&VolumePkcs5, sizeof (VolumePkcs5)); burn (&VolumeTrueCryptMode, sizeof (VolumeTrueCryptMode)); if (status && CloseSecurityTokenSessionsAfterMount) SecurityToken::CloseAllSessions(); return status; } void __cdecl mountFavoriteVolumeThreadFunction (void *pArg) { mountFavoriteVolumeThreadParam* pParam = (mountFavoriteVolumeThreadParam*) pArg; // Disable main dialog during processing to avoid user interaction EnableWindow(MainDlg, FALSE); finally_do ({ EnableWindow(MainDlg, TRUE); }); if (pParam) { if (pParam->favoriteVolumeToMount) MountFavoriteVolumes (pParam->systemFavorites, pParam->logOnMount, pParam->hotKeyMount, *(pParam->favoriteVolumeToMount)); else MountFavoriteVolumes (pParam->systemFavorites, pParam->logOnMount, pParam->hotKeyMount); free(pParam); } else MountFavoriteVolumes (); } static void SaveDefaultKeyFilesParam (HWND hwnd) { 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 (hwnd, 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) ¶m) == IDOK) { if (!param.EnableKeyFiles || AskWarnYesNo ("CONFIRM_SAVE_DEFAULT_KEYFILES", hwndDlg) == IDYES) { KeyFileRemoveAll (&defaultKeyFilesParam.FirstKeyFile); defaultKeyFilesParam.EnableKeyFiles = param.EnableKeyFiles; defaultKeyFilesParam.FirstKeyFile = param.FirstKeyFile; RestoreDefaultKeyFilesParam (); SaveDefaultKeyFilesParam (hwndDlg); } } } 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"), hwndDlg); 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", hwndDlg); 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", hwndDlg); if (bPlaySoundOnSuccessfulHkDismount) MessageBeep (0xFFFFFFFF); } TaskBarIconRemove (hwndDlg); UnregisterWtsNotification(hwndDlg); EndMainDlg (hwndDlg); break; case HK_MOUNT_FAVORITE_VOLUMES: { mountFavoriteVolumeThreadParam* pParam = (mountFavoriteVolumeThreadParam*) calloc(1, sizeof(mountFavoriteVolumeThreadParam)); pParam->systemFavorites = FALSE; pParam->logOnMount = FALSE; pParam->hotKeyMount = TRUE; _beginthread(mountFavoriteVolumeThreadFunction, 0, pParam); } break; case HK_SHOW_HIDE_MAIN_WINDOW: ChangeMainWindowVisibility (); break; case HK_CLOSE_SECURITY_TOKEN_SESSIONS: SecurityToken::CloseAllSessions(); InfoBalloon (NULL, "ALL_TOKEN_SESSIONS_CLOSED", hwndDlg); 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, const 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]; if (!lpszVolume) { nStatus = ERR_OUTOFMEMORY; handleError (hwndDlg, nStatus); return nStatus; } volume.VolumeIsOpen = FALSE; hiddenVolume.VolumeIsOpen = FALSE; switch (IsSystemDevicePath (lpszVolume, hwndDlg, TRUE)) { case 1: case 2: if (AskErrNoYes ("BACKUP_HEADER_NOT_FOR_SYS_DEVICE", hwndDlg) == IDYES) CreateRescueDisk (hwndDlg); return 0; } if (IsMountedVolume (lpszVolume)) { Warning ("DISMOUNT_FIRST", hwndDlg); goto ret; } if (!VolumePathExists (lpszVolume)) { handleWin32Error (hwndDlg); goto ret; } Info ("EXTERNAL_VOL_HEADER_BAK_FIRST_INFO", hwndDlg); 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, &VolumePkcs5, &VolumeTrueCryptMode, type == TC_VOLUME_TYPE_HIDDEN ? "ENTER_HIDDEN_VOL_PASSWORD" : "ENTER_NORMAL_VOL_PASSWORD", FALSE)) { nStatus = ERR_SUCCESS; goto ret; } WaitCursor(); if (KeyFilesEnable && FirstKeyFile) KeyFilesApply (hwndDlg, askPassword, FirstKeyFile); nStatus = OpenVolume (askVol, lpszVolume, askPassword, VolumePkcs5, VolumeTrueCryptMode, 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, hwndDlg)) { 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; } StringCbPrintfW (szTmp, sizeof(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; } /* force the display of the random enriching dialog */ SetRandomPoolEnrichedByUserStatus (FALSE); NormalCursor(); UserEnrichRandomPool (hwndDlg); WaitCursor(); // Temporary keys if (!RandgetBytes (hwndDlg, temporaryKey, EAGetKeySize (volume.CryptoInfo->ea), TRUE) || !RandgetBytes (hwndDlg, 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 (hwndDlg, (char *) backup, FALSE, volume.CryptoInfo, &VolumePassword, FALSE); if (nStatus != ERR_SUCCESS) goto error; if (hiddenVolume.VolumeIsOpen) { nStatus = ReEncryptVolumeHeader (hwndDlg, (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", hwndDlg); 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 (&VolumePkcs5, sizeof (VolumePkcs5)); burn (&VolumeTrueCryptMode, sizeof (VolumeTrueCryptMode)); burn (&hiddenVolPassword, sizeof (hiddenVolPassword)); burn (temporaryKey, sizeof (temporaryKey)); burn (originalK2, sizeof (originalK2)); RestoreDefaultKeyFilesParam(); RandStop (FALSE); NormalCursor(); return nStatus; } int RestoreVolumeHeader (HWND hwndDlg, const 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; if (!lpszVolume) { nStatus = ERR_OUTOFMEMORY; handleError (hwndDlg, nStatus); return nStatus; } switch (IsSystemDevicePath (lpszVolume, hwndDlg, TRUE)) { case 1: case 2: if (AskErrNoYes ("RESTORE_HEADER_NOT_FOR_SYS_DEVICE", hwndDlg) == IDYES) CreateRescueDisk (hwndDlg); 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", hwndDlg); 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, hwndDlg)) { case 1: restoreInternalBackup = TRUE; break; case 2: restoreInternalBackup = FALSE; break; default: return 0; } OpenVolumeContext volume; volume.VolumeIsOpen = FALSE; /* force the display of the random enriching dialog */ SetRandomPoolEnrichedByUserStatus (FALSE); WaitCursor(); if (restoreInternalBackup) { // Restore header from the internal backup // Open the volume using backup header while (TRUE) { StringCbCopyA (PasswordDlgVolume, sizeof(PasswordDlgVolume), lpszVolume); if (!AskVolumePassword (hwndDlg, &VolumePassword, &VolumePkcs5, &VolumeTrueCryptMode, NULL, FALSE)) { nStatus = ERR_SUCCESS; goto ret; } WaitCursor(); if (KeyFilesEnable && FirstKeyFile) KeyFilesApply (hwndDlg, &VolumePassword, FirstKeyFile); nStatus = OpenVolume (&volume, lpszVolume, &VolumePassword, VolumePkcs5, VolumeTrueCryptMode,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", hwndDlg); nStatus = ERROR_SUCCESS; goto error; } // Create a new header with a new salt char buffer[TC_VOLUME_HEADER_EFFECTIVE_SIZE]; nStatus = ReEncryptVolumeHeader (hwndDlg, 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 StringCbPrintfW (szTmp, sizeof(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, sizeof(szDiskFile), lpszVolume, &bDevice); if (bDevice == FALSE) StringCbCopyA (szCFDevice, sizeof(szCFDevice), szDiskFile); else { nDosLinkCreated = FakeDosNameForDevice (szDiskFile, szDosDevice, sizeof(szDosDevice),szCFDevice, sizeof(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", hwndDlg); nStatus = ERR_SUCCESS; goto error; } // Open the header while (TRUE) { if (!AskVolumePassword (hwndDlg, &VolumePassword, &VolumePkcs5, &VolumeTrueCryptMode, "ENTER_HEADER_BACKUP_PASSWORD", FALSE)) { nStatus = ERR_SUCCESS; goto ret; } if (KeyFilesEnable && FirstKeyFile) KeyFilesApply (hwndDlg, &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, VolumePkcs5, VolumeTrueCryptMode, &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 (hwndDlg, 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 (hwndDlg, 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", hwndDlg); 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)); burn (&VolumePkcs5, sizeof (VolumePkcs5)); burn (&VolumeTrueCryptMode, sizeof (VolumeTrueCryptMode)); 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", hwndDlg); 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", hwndDlg); 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\\veracrypt", TC_ENCRYPTION_FREE_CPU_COUNT_REG_VALUE_NAME, cpuFreeCount); Warning ("SETTING_REQUIRES_REBOOT", hwndDlg); } 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", hwndDlg) == 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", hwndDlg) == 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", hwndDlg); // 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]; StringCbCopyA (prevSecurityTokenLibraryPath, sizeof(prevSecurityTokenLibraryPath), SecurityTokenLibraryPath); StringCbCopyA (SecurityTokenLibraryPath, sizeof(SecurityTokenLibraryPath), securityTokenLibraryPath); if (!InitSecurityTokenLibrary(hwndDlg)) { StringCbCopyA (SecurityTokenLibraryPath, sizeof(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", hwndDlg); return 1; } case IDC_SELECT_PKCS11_MODULE: { char securityTokenLibraryPath[MAX_PATH]; char systemDir[MAX_PATH]; wchar_t browseFilter[1024]; Info ("SELECT_PKCS11_MODULE_HELP", hwndDlg); StringCbPrintfW (browseFilter, sizeof(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", hwndDlg); 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", hwndDlg); 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", hwndDlg) == 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", hwndDlg); break; } return 0; } return 0; } void MountSelectedVolume (HWND hwndDlg, BOOL mountWithOptions) { if (!VolumeSelected(hwndDlg)) { Warning ("NO_VOLUME_SELECTED", hwndDlg); } 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 (hwndDlg, &mountOptions.ProtectedHidVolPassword, hidVolProtKeyFilesParam.FirstKeyFile); } if (CheckMountList (hwndDlg, FALSE)) _beginthread (mountThreadFunction, 0, hwndDlg); } else Warning ("SELECT_FREE_DRIVE", hwndDlg); } 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", hwndDlg); 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 + ".hd_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", MainDlg) == 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)")) { string sDbgCmd; if (AskOkCancel ("ASK_DEBUGGER_INSTALL", hwndDlg) != IDOK) return; if (Is64BitOs()) sDbgCmd = "msiexec.exe /qb /i https://www.idrix.fr/Root/MSDebug/dbg_amd64_6.11.1.404.msi"; else sDbgCmd = "msiexec.exe /qb /i https://www.idrix.fr/Root/MSDebug/dbg_x86_6.11.1.404.msi"; if (!CreateProcess (NULL, (LPSTR) sDbgCmd.c_str(), NULL, NULL, FALSE, 0, NULL, NULL, &startupInfo, &procInfo)) { handleWin32Error (hwndDlg); return; } WaitCursor(); WaitForSingleObject (procInfo.hProcess, INFINITE); NormalCursor(); DWORD exitCode; bool bExitCheck = (!GetExitCodeProcess (procInfo.hProcess, &exitCode) || exitCode != 0); CloseHandle(procInfo.hProcess); CloseHandle(procInfo.hThread); if (bExitCheck) return; } if (AskOkCancel ("SYSTEM_CRASH_ANALYSIS_INFO", hwndDlg) == 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", hwndDlg); CloseHandle (procInfo.hProcess); CloseHandle (procInfo.hThread); CloseHandle (hChildStdoutRead); CloseHandle (hChildStdoutWrite); return; } EnableElevatedCursorChange (hwndDlg); WaitCursor(); CloseHandle (procInfo.hProcess); CloseHandle (procInfo.hThread); CloseHandle (hChildStdoutWrite); string output; BOOL bIsValidResponse = TRUE; while (TRUE) { DWORD bytesReceived = 0, i; char pipeBuffer [4096] = {0}; unsigned char uc; if (!ReadFile (hChildStdoutRead, pipeBuffer, sizeof (pipeBuffer), &bytesReceived, NULL)) break; /* check if the buffer contains printable characters only*/ for (i = 0; i < bytesReceived; i++) { uc = (unsigned char) pipeBuffer [i]; if ( uc >= 0x7f || uc < 0x20) // A non-ASCII or non-printable character? { bIsValidResponse = FALSE; break; } } if (!bIsValidResponse) break; output.insert (output.size(), pipeBuffer, bytesReceived); } CloseHandle (hChildStdoutRead); NormalCursor(); if (!bIsValidResponse) { Error ("ERR_PARAMETER_INCORRECT", hwndDlg); return; } 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", hwndDlg); return; } uint64 bugcheckCode; int n = sscanf (output.substr (p + 14, 8).c_str(), "%I64uX", &bugcheckCode); if (n != 1) { Error ("ERR_PARAMETER_INCORRECT", hwndDlg); return; } p = output.find ("Arguments ", p); uint64 bugcheckArgs[4]; n = sscanf (output.substr (p + 10, (Is64BitOs() ? 17 : 9) * 4).c_str(), "%I64uX %I64uX %I64uX %I64uX", &bugcheckArgs[0], &bugcheckArgs[1], &bugcheckArgs[2], &bugcheckArgs[3]); if (n != 4) { Error ("ERR_PARAMETER_INCORRECT", hwndDlg); 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", hwndDlg); 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_VERACRYPT"); msg += L"\n\n"; } InfoDirect(msg.c_str(), hwndDlg); /* 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); }