}

}

DWORD size;

char *favoritesXml = LoadFile (favoritesFilePath.c_str(), &size);

if (systemFavorites && !IsAdmin() && !noUacElevation)

DeleteFile (GetConfigPath (TC_APPD_FILENAME_SYSTEM_FAVORITE_VOLUMES));

char *xml = favoritesXml;

char mountPoint[MAX_PATH], volume[MAX_PATH];

if (xml == NULL)

return;

while (xml = XmlFindElement (xml, "volume"))

{

FavoriteVolume favorite;

XmlGetAttributeText (xml, "mountpoint", mountPoint, sizeof (mountPoint));

favorite.MountPoint = Utf8StringToWide (mountPoint);

XmlGetNodeText (xml, volume, sizeof (volume));

favorite.Path = Utf8StringToWide (volume);

char label[1024];

XmlGetAttributeText (xml, "ID", label, sizeof (label));

if (strlen (label) == (2*VOLUME_ID_SIZE))

{

if (HexWideStringToArray (Utf8StringToWide (label).c_str(), arr) && arr.size() == VOLUME_ID_SIZE)

{

memcpy (favorite.VolumeID, &arr[0], VOLUME_ID_SIZE);

}

}

XmlGetAttributeText (xml, "label", label, sizeof (label));

favorite.Label = Utf8StringToWide (label);

XmlGetAttributeText (xml, "pim", label, sizeof (label));

if (strlen(label) == 0)

{

/* support old attribute name before it was changed to PIM*/

XmlGetAttributeText (xml, "pin", label, sizeof (label));

}

if (label[0])

{

favorite.Pim = strtol (label, NULL, 10);

if (favorite.Pim < 0 || favorite.Pim > (systemFavorites? MAX_BOOT_PIM_VALUE : MAX_PIM_VALUE))

favorite.Pim = -1;

}

else

favorite.Pim = -1;

char boolVal[2];

XmlGetAttributeText (xml, "readonly", boolVal, sizeof (boolVal));

if (boolVal[0])

favorite.ReadOnly = (boolVal[0] == '1');

XmlGetAttributeText (xml, "removable", boolVal, sizeof (boolVal));

virtual DWORD STDMETHODCALLTYPE RestoreEfiSystemLoader ()

{

return BaseCom::RestoreEfiSystemLoader ();

}

virtual DWORD STDMETHODCALLTYPE GetEfiBootDeviceNumber (BSTR* pSdn)

{

return BaseCom::GetEfiBootDeviceNumber (pSdn);

}

virtual DWORD STDMETHODCALLTYPE GetSecureBootConfig (BOOL* pSecureBootEnabled, BOOL *pVeraCryptKeysLoaded)

{

return BaseCom::GetSecureBootConfig (pSecureBootEnabled, pVeraCryptKeysLoaded);

}

virtual DWORD STDMETHODCALLTYPE WriteEfiBootSectorUserConfig (DWORD userConfig, BSTR customUserMessage, int pim, int hashAlg)

{

return BaseCom::WriteEfiBootSectorUserConfig (userConfig, customUserMessage,pim, hashAlg);

}

virtual DWORD STDMETHODCALLTYPE UpdateSetupConfigFile (BOOL bForInstall)

{

return BaseCom::UpdateSetupConfigFile (bForInstall);

}

virtual DWORD STDMETHODCALLTYPE NotifyService (DWORD dwNotifyCode)

{

return BaseCom::NotifyService (dwNotifyCode);

}

protected:

DWORD MessageThreadId;

LONG RefCount;

};

extern "C" BOOL ComServerMain ()

{

SetProcessShutdownParameters (0x100, 0);

TrueCryptFactory<TrueCryptMainCom> factory (GetCurrentThreadId ());

DWORD cookie;

if (IsUacSupported ())

UacElevated = TRUE;

if (CoRegisterClassObject (CLSID_TrueCryptMainCom, (LPUNKNOWN) &factory,

CLSCTX_LOCAL_SERVER, REGCLS_SINGLEUSE, &cookie) != S_OK)

return FALSE;

MSG msg;

while (int r = GetMessageW (&msg, NULL, 0, 0))

{

if (r == -1)

return FALSE;

TranslateMessage (&msg);

DispatchMessageW (&msg);

if (msg.message == WM_APP

break;

}

CoRevokeClassObject (cookie);

return TRUE;

}

static BOOL ComGetInstance (HWND hWnd, ITrueCryptMainCom **tcServer)

{

return ComGetInstanceBase (hWnd, CLSID_TrueCryptMainCom, IID_ITrueCryptMainCom, (void **) tcServer);

}

ITrueCryptMainCom *GetElevatedInstance (HWND parent)

{

ITrueCryptMainCom *instance;

if (!ComGetInstance (parent, &instance))

throw UserAbort (SRC_POS);

return instance;

}

extern "C" int UacBackupVolumeHeader (HWND hwndDlg, BOOL bRequireConfirmation, wchar_t *lpszVolume)

{

CComPtr<ITrueCryptMainCom> tc;

int r;

if (ComGetInstance (hwndDlg, &tc))

{

CComBSTR volumeBstr;

BSTR bstr = W2BSTR(lpszVolume);

if (bstr)

{

volumeBstr.Attach (bstr);

r = tc->BackupVolumeHeader ((__int64) hwndDlg, bRequireConfirmation, volumeBstr);

}

else

r = ERR_OUTOFMEMORY;

}

else

r = -1;

CoUninitialize ();

return r;

}

extern "C" int UacRestoreVolumeHeader (HWND hwndDlg, wchar_t *lpszVolume)

{

CComPtr<ITrueCryptMainCom> tc;

int r;

if (ComGetInstance (hwndDlg, &tc))

{

CComBSTR volumeBstr;

BSTR bstr = W2BSTR(lpszVolume);

if (bstr)

{

volumeBstr.Attach (bstr);

r = tc->RestoreVolumeHeader ((__int64) hwndDlg, volumeBstr);

}

else

r = ERR_OUTOFMEMORY;

}

else

r = -1;

CoUninitialize ();

return r;

}

extern "C" int UacChangePwd (wchar_t *lpszVolume, Password *oldPassword, int old_pkcs5, int old_pim, Password *newPassword, int pkcs5, int pim, int wipePassCount, HWND hwndDlg)

{

CComPtr<ITrueCryptMainCom> tc;

int r;

if (ComGetInstance (hwndDlg, &tc))

{

CComBSTR bstrVolume (lpszVolume);

WaitCursor ();

r = tc->ChangePasswordEx3 (bstrVolume, oldPassword, old_pkcs5, old_pim, newPassword, pkcs5, pim, wipePassCount, (__int64) hwndDlg);

NormalCursor ();

}

else

r = -1;

CoUninitialize ();

return r;

}

helpstring("VeraCrypt Main UAC Support Interface")

]

interface ITrueCryptMainCom : IUnknown

{

void AnalyzeKernelMiniDump (__int64 hwndDlg);

int BackupVolumeHeader (__int64 hwndDlg, BOOL bRequireConfirmation, BSTR lpszVolume);

DWORD CallDriver (DWORD ioctl, BSTR input, BSTR *output);

int ChangePassword (BSTR volumePath, Password *oldPassword, Password *newPassword, int pkcs5, int wipePassCount, __int64 hWnd);

DWORD CopyFile (BSTR sourceFile, BSTR destinationFile);

DWORD DeleteFile (BSTR file);

BOOL IsPagingFileActive (BOOL checkNonWindowsPartitionsOnly);

DWORD ReadWriteFile (BOOL write, BOOL device, BSTR filePath, BSTR *bufferBstr, unsigned __int64 offset, unsigned __int32 size, DWORD *sizeDone);

DWORD RegisterFilterDriver (BOOL registerDriver, int filterType);

DWORD RegisterSystemFavoritesService (BOOL registerService);

int RestoreVolumeHeader (__int64 hwndDlg, BSTR lpszVolume);

DWORD SetDriverServiceStartType (DWORD startType);

DWORD WriteLocalMachineRegistryDwordValue (BSTR keyPath, BSTR valueName, DWORD value);

int ChangePasswordEx (BSTR volumePath, Password *oldPassword, int old_pkcs5, Password *newPassword, int pkcs5, int wipePassCount, __int64 hWnd);

int ChangePasswordEx2 (BSTR volumePath, Password *oldPassword, int old_pkcs5, Password *newPassword, int pkcs5, int wipePassCount, __int64 hWnd);

int ChangePasswordEx3 (BSTR volumePath, Password *oldPassword, int old_pkcs5, int old_pim, Password *newPassword, int pkcs5, int pim, int wipePassCount, __int64 hWnd);

DWORD GetFileSize (BSTR filePath, unsigned __int64* pSize);

DWORD DeviceIoControl (BOOL readOnly, BOOL device, BSTR filePath, DWORD dwIoControlCode, BSTR input, BSTR *output);

DWORD InstallEfiBootLoader (BOOL preserveUserConfig, BOOL hiddenOSCreation, int pim, int hashAlg);

DWORD BackupEfiSystemLoader ();

DWORD RestoreEfiSystemLoader ();

DWORD GetEfiBootDeviceNumber (BSTR* pSdn);

DWORD WriteEfiBootSectorUserConfig (DWORD userConfig, BSTR customUserMessage, int pim, int hashAlg);

DWORD UpdateSetupConfigFile (BOOL bForInstall);

DWORD GetSecureBootConfig (BOOL* pSecureBootEnabled, BOOL *pVeraCryptKeysLoaded);

DWORD NotifyService (DWORD dwNotifyCode);

};

[

uuid(FE8B3B95-C80C-41f7-830F-FBA271C26F7E),

helpstring("VeraCrypt Main UAC Support Coclass")

]

coclass TrueCryptMainCom

{

[default] interface ITrueCryptMainCom;

}

}

}

static std::vector<MSXML2::IXMLDOMNodePtr> GetReadChildNodes (MSXML2::IXMLDOMNodeListPtr childs)

{

std::vector<MSXML2::IXMLDOMNodePtr> list;

if (childs && childs->Getlength())

{

for (long i = 0; i < childs->Getlength(); i++)

{

MSXML2::IXMLDOMNodePtr node = childs->Getitem(i);

if (node)

{

//skip comments

if (node->GetnodeType() == NODE_COMMENT)

continue;

// skip root xml node

if (node->GetbaseName().GetBSTR() && (0 == strcmp ("xml", (const char*) node->GetbaseName())))

continue;

list.push_back (node);

}

}

}

return list;

}

static bool validateDcsPropXml(const char* xmlData)

{

bool bValid = false;

if(FAILED(hr))

return false;

else

{

MSXML2::IXMLDOMDocumentPtr pXMLDom;

hr= pXMLDom.CreateInstance(__uuidof(MSXML2::DOMDocument60), NULL, CLSCTX_INPROC_SERVER);

if (SUCCEEDED(hr))

{

try

{

pXMLDom->async = VARIANT_FALSE;

pXMLDom->validateOnParse = VARIANT_FALSE;

pXMLDom->resolveExternals = VARIANT_FALSE;

if(pXMLDom->loadXML(xmlData) == VARIANT_TRUE && pXMLDom->hasChildNodes())

{

MSXML2::IXMLDOMNodePtr veracryptNode, configurationNode, configNode;

std::vector<MSXML2::IXMLDOMNodePtr> nodes = GetReadChildNodes (pXMLDom->GetchildNodes());

size_t nodesCount = nodes.size();

if (nodesCount == 1

&& ((veracryptNode = nodes[0])->GetnodeType() == NODE_ELEMENT)

&& veracryptNode->GetnodeName().GetBSTR()

&& (0 == strcmp ((const char*) veracryptNode->GetnodeName(), "VeraCrypt"))

&& veracryptNode->hasChildNodes()

)

{

nodes = GetReadChildNodes (veracryptNode->GetchildNodes());

nodesCount = nodes.size();

if ((nodesCount == 1)

switch (x)

{

case TC_MLIST_ITEM_NONSYS_VOL:

{

SetWindowTextW (hOKButton, GetString ("UNMOUNT_BUTTON"));

DisableSplitButton(hwndDlg, IDOK);

EnableWindow (hOKButton, TRUE);

// Invalid the button IDOK so that it will be redrawn

InvalidateRect (hOKButton, NULL, 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:

EnableSplitButton(hwndDlg, IDOK);

EnableWindow (hOKButton, FALSE);

SetWindowTextW (hOKButton, GetString ("MOUNT_BUTTON"));

// Invalid the button IDOK so that it will be redrawn

InvalidateRect (hOKButton, NULL, TRUE);

EnableWindow (GetDlgItem (hwndDlg, IDC_VOLUME_PROPERTIES), TRUE);

EnableMenuItem (GetMenu (hwndDlg), IDM_UNMOUNT_VOLUME, MF_GRAYED);

break;

case TC_MLIST_ITEM_FREE:

default:

EnableSplitButton(hwndDlg, IDOK);

SetWindowTextW (hOKButton, GetString ("MOUNT_BUTTON"));

// Invalid the button IDOK so that it will be redrawn

InvalidateRect (hOKButton, NULL, TRUE);

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);

}

void GetVolumePath (HWND hwndDlg, LPWSTR szPath, int nMaxCount)

{

GetWindowText (GetDlgItem (hwndDlg, IDC_VOLUME), szPath, nMaxCount);

CorrectFileName (szPath);

}

/* 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

}

// 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();

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)

{

wchar_t dstDir[MAX_PATH];

wchar_t volName[MAX_PATH] = { 0 };

GetDlgItemText (hwndDlg, IDC_DIRECTORY, dstDir, ARRAYSIZE (dstDir));

if (BrowseFilesInDir (hwndDlg, "OPEN_TITLE", dstDir, volName, bHistory, FALSE, NULL))

SetDlgItemText (hwndDlg, IDC_VOLUME_NAME, wcschr (volName, L'\\') + 1);

return 1;

}

if (lw == IDC_BROWSE_DIRS)

{

wchar_t dstPath[MAX_PATH * 2];

GetDlgItemText (hwndDlg, IDC_DIRECTORY, dstPath, ARRAYSIZE (dstPath));

SetDlgItemText (hwndDlg, IDC_DIRECTORY, dstPath);

return 1;

}

if (lw == IDCANCEL || lw == IDCLOSE)

{

EndDialog (hwndDlg, lw);

return 1;

}

if (lw == IDC_CREATE)

{

BOOL copyWizard, copyExpander, bExplore, bCacheInDriver, bIncludePimInCache, bAutoRun, bAutoMount, bMountReadOnly;

WCHAR dstDir[MAX_PATH + 1];

WCHAR srcPath[1024 + MAX_PATH + 1];

WCHAR dstPath[2*MAX_PATH + 1];

WCHAR appDir[1024];

WCHAR volName[MAX_PATH + 2];

int drive;

WCHAR* ptr;

GetDlgItemTextW (hwndDlg, IDC_DIRECTORY, dstDir, array_capacity (dstDir));

volName[0] = 0;

GetDlgItemTextW (hwndDlg, IDC_VOLUME_NAME, volName + 1, (array_capacity (volName)) - 1);

drive = (int) SendDlgItemMessage (hwndDlg, IDC_DRIVELIST, CB_GETCURSEL, 0, 0);

drive = (int) SendDlgItemMessage (hwndDlg, IDC_DRIVELIST, CB_GETITEMDATA, drive, 0);

{

for (i = 0; i < 26; i++)

{

if ((prevMountList.ulMountedDrives & (1 << i)) && (!(mountList.ulMountedDrives & (1 << i))) && IsNullTerminateString (prevMountList.wszLabel[i], 33) && wcslen (prevMountList.wszLabel[i]))

{

UpdateDriveCustomLabel (i, prevMountList.wszLabel[i], FALSE);

}

}

}

}

BroadcastDeviceChange (DBT_DEVICEREMOVECOMPLETE, 0, prevMountList.ulMountedDrives & ~mountList.ulMountedDrives);

RefreshMainDlg (hwndDlg);

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;

}

{

{

{

}

}

}

return FALSE;

}

if (interact && !Silent)

MessageBoxW (hwndDlg, GetString ("UNMOUNT_FAILED"), lpszTitle, MB_ICONERROR);

}

else

{

if (bBeep)

MessageBeep (0xFFFFFFFF);

}

return status;

}

static BOOL MountAllDevicesThreadCode (HWND hwndDlg, BOOL bPasswordPrompt)

{

HWND driveList = GetDlgItem (MainDlg, IDC_DRIVELIST);

int selDrive = ListView_GetSelectionMark (driveList);

BOOL shared = FALSE, status = FALSE, bHeaderBakRetry = FALSE;

int mountedVolCount = 0;

vector <HostDevice> devices;

int EffectiveVolumePkcs5 = CmdVolumePkcs5;

/* Priority is given to command line parameters

* Default values used only when nothing specified in command line

BootEncStatus.HiddenSystemPartitionStart,

BootEncStatus.ConfiguredEncryptedAreaStart,

BootEncStatus.ConfiguredEncryptedAreaEnd,

BootEncStatus.EncryptedAreaStart,

BootEncStatus.EncryptedAreaEnd,

encryptedRatio);

}

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 (BOOL bDecrypt)

{

// 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, bDecrypt? L"/resumeinplacedec" : L"/zinplace", FALSE);

}

BOOL SelectContainer (HWND hwndDlg)

{

return FALSE;

AddComboItem (GetDlgItem (hwndDlg, IDC_VOLUME), szFileName, bHistory);

EnableDisableButtons (hwndDlg);

SetFocus (GetDlgItem (hwndDlg, IDC_DRIVELIST));

return TRUE;

}

BOOL SelectPartition (HWND hwndDlg)

{

RawDevicesDlgParam param;

param.pszFileName = szFileName;

INT_PTR nResult = DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_RAWDEVICES_DLG), hwndDlg,

(DLGPROC) RawDevicesDlgProc, (LPARAM) & param);

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;

StringCbCopyW (szRescueDiskExtension, sizeof (szRescueDiskExtension), L"zip");

else

StringCbCopyW (szRescueDiskExtension, sizeof (szRescueDiskExtension), L"iso");

StringCbCopyW (szDefaultRescueDiskName, sizeof (szDefaultRescueDiskName), L"VeraCrypt Rescue Disk.");

StringCbCatW (szDefaultRescueDiskName, sizeof (szDefaultRescueDiskName), szRescueDiskExtension);

if (UsePreferences)

{

// General preferences

LoadSettings (hwndDlg);

// Save language to XML configuration file if it has been selected in the setup

// so that other VeraCrypt programs will pick it up

if (bLanguageSetInSetup)

SaveSettings (hwndDlg);

// Keyfiles

LoadDefaultKeyFilesParam ();

RestoreDefaultKeyFilesParam ();

// if maximum password length is set to legacy value, abort if password in command line is longer

if (bUseLegacyMaxPasswordLength && CmdVolumePasswordValid && (CmdVolumePassword.Length > MAX_LEGACY_PASSWORD))

AbortProcess ("COMMAND_LINE_ERROR");

}

if (EnableMemoryProtection)

{

/* Protect this process memory from being accessed by non-admin users */

}

if (ComServerMode)

{

InitDialog (hwndDlg);

if (!ComServerMain ())

{

handleWin32Error (hwndDlg, SRC_POS);

exit (1);

}

exit (0);

}

if (CmdMountOptionsValid)

mountOptions = CmdMountOptions;

InitMainDialog (hwndDlg);

try

{

if (IsHiddenOSRunning())

{

uint32 driverConfig = ReadDriverConfigurationFlags();

if (BootEncObj->GetInstalledBootLoaderVersion() != VERSION_NUM)

Warning ("UPDATE_TC_IN_HIDDEN_OS_TOO", hwndDlg);

if ( !(driverConfig & TC_DRIVER_CONFIG_DISABLE_EVIL_MAID_ATTACK_DETECTION)

&& !BootEncObj->CheckBootloaderFingerprint ())

Warning ("BOOT_LOADER_FINGERPRINT_CHECK_FAILED", hwndDlg);

}

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);

SetTimer (hwndDlg, TIMER_ID_UPDATE_DEVICE_LIST, TIMER_INTERVAL_UPDATE_DEVICE_LIST, NULL);

taskBarCreatedMsg = RegisterWindowMessage (L"TaskbarCreated");

AllowMessageInUIPI (taskBarCreatedMsg);

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.

SystemDriveConfiguration config;

try

{

config = BootEncObj->GetSystemDriveConfiguration ();

}

catch (Exception &e)

{

e.Show (MainDlg);

}

LaunchVolCreationWizard (hwndDlg, L"/csysenc", FALSE);

}

}

}

if (bInPlaceEncNonSysPending && !NonSysInplaceEncInProgressElsewhere())

{

BOOL bDecrypt = FALSE;

if (AskNonSysInPlaceEncryptionResume(hwndDlg, &bDecrypt) == IDYES)

ResumeInterruptedNonSysInplaceEncProcess (bDecrypt);

}

}

if (TaskBarIconMutex != NULL)

RegisterWtsAndPowerNotification(hwndDlg);

DoPostInstallTasks (hwndDlg);

ResetCurrentDirectory ();

}

return 0;

case WM_MOUSEWHEEL:

return HandleDriveListMouseWheelEvent (uMsg, wParam, lParam, FALSE);

case WM_CONTEXTMENU:

{

HWND hList = GetDlgItem (hwndDlg, IDC_DRIVELIST);

// only handle if it is coming from keyboard and if the drive

// list has focus. The other cases are handled elsewhere

if ( (-1 == GET_X_LPARAM(lParam))

&& (-1 == GET_Y_LPARAM(lParam))

&& (GetFocus () == hList)

)

{

INT item = ListView_GetSelectionMark (hList);

if (item >= 0)

{

nSelectedDriveIndex = item;

DisplayDriveListContextMenu (hwndDlg, NULL);

}

}

{

wchar_t selectedVolume [TC_MAX_PATH + 1];

GetVolumePath (hwndDlg, selectedVolume, ARRAYSIZE (selectedVolume));

KeyFilesApply (hwndDlg, &mountOptions.ProtectedHidVolPassword, hidVolProtKeyFilesParam.FirstKeyFile, selectedVolume);

}

}

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. */

{

DisplayDriveListContextMenu (hwndDlg, lParam);

return 1;

}

}

}

else

{

LPNMHDR pnmh = (LPNMHDR)lParam;

if (pnmh->idFrom == IDOK && pnmh->code == BCN_DROPDOWN)

{

// Create a popup menu for the split button

HMENU hmenu = CreateMountNoCacheDropdownMenu();

HandleMountButtonDropdown(pnmh->hwndFrom, hwndDlg, hmenu);

DestroyMenu(hmenu);

}

}

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)

{

return NO_ERROR;

}

static LONG WINAPI SystemFavoritesServiceExceptionHandler (EXCEPTION_POINTERS *ep)

{

SetUnhandledExceptionFilter (NULL);

if (!(ReadDriverConfigurationFlags() & TC_DRIVER_CONFIG_CACHE_BOOT_PASSWORD))

WipeCache (NULL, TRUE);

UnhandledExceptionFilter (ep);

return EXCEPTION_EXECUTE_HANDLER;

}

static void SystemFavoritesServiceInvalidParameterHandler (const wchar_t *expression, const wchar_t *function, const wchar_t *file, unsigned int line, uintptr_t reserved)

{

TC_THROW_FATAL_EXCEPTION;

}

static VOID WINAPI SystemFavoritesServiceMain (DWORD argc, LPTSTR *argv)

{

BOOL status = FALSE;

DEV_BROADCAST_DEVICEINTERFACE hdr;

BOOL bSkipMount = FALSE;

BOOL bUpdateLoader = FALSE;

DWORD i;

memset (&SystemFavoritesServiceStatus, 0, sizeof (SystemFavoritesServiceStatus));

SystemFavoritesServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;

SystemFavoritesServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;

for (i = 1; i < argc; i++)

{

if (0 == _wcsicmp (argv[i], VC_SYSTEM_FAVORITES_SERVICE_ARG_SKIP_MOUNT))

bSkipMount = TRUE;

else if (0 == _wcsicmp (argv[i], VC_SYSTEM_FAVORITES_SERVICE_ARG_UPDATE_LOADER))

bUpdateLoader = TRUE;

}

ZeroMemory (&hdr, sizeof(hdr));

hdr.dbcc_size = sizeof (hdr);

hdr.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;

SystemFavoritesServiceStatusHandle = RegisterServiceCtrlHandlerEx (TC_SYSTEM_FAVORITES_SERVICE_NAME, SystemFavoritesServiceCtrlHandler, NULL);

if (!SystemFavoritesServiceStatusHandle)

return;

SystemFavoriteServiceStopEvent = CreateEvent (NULL, FALSE, FALSE, NULL);

if (!SystemFavoriteServiceStopEvent)

return;

SystemFavoriteServiceNotify = RegisterDeviceNotification (SystemFavoritesServiceStatusHandle, &hdr,DEVICE_NOTIFY_SERVICE_HANDLE | DEVICE_NOTIFY_ALL_INTERFACE_CLASSES);

SetUnhandledExceptionFilter (SystemFavoritesServiceExceptionHandler);

_set_invalid_parameter_handler (SystemFavoritesServiceInvalidParameterHandler);

if (bUpdateLoader)

{

SystemFavoritesServiceSetStatus (SERVICE_START_PENDING, 120000);

SystemFavoritesServiceUpdateLoaderProcessing (TRUE);

catch (Exception &e)

{

e.Show (NULL);

}

if (BootEncObj == NULL)

AbortProcess ("INIT_SYS_ENC");

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, SRC_POS);

else

handleError (NULL, status, SRC_POS);

AbortProcess ("NODRIVER");

}

/* Create the main dialog box */

DialogBoxParamW (hInstance, MAKEINTRESOURCEW (IDD_MOUNT_DLG), NULL, (DLGPROC) MainDialogProc,

(LPARAM) lpszCommandLine);

/* 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, L"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;

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 wchar_t *lpszVolume)

{

int nStatus = ERR_OS_ERROR;

wchar_t szTmp[4096];

int fBackup = -1;

OpenVolumeContext volume;

OpenVolumeContext hiddenVolume;

Password hiddenVolPassword;

int hiddenVolPkcs5 = 0, hiddenVolPim = 0;

int EffectiveVolumePkcs5 = CmdVolumePkcs5;

int EffectiveVolumePim = CmdVolumePim;

/* Priority is given to command line parameters

* Default values used only when nothing specified in command line

*/

if (EffectiveVolumePkcs5 == 0)

EffectiveVolumePkcs5 = DefaultVolumePkcs5;

if (!lpszVolume)

{

nStatus = ERR_OUTOFMEMORY;

handleError (hwndDlg, nStatus, SRC_POS);

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))

default:

nStatus = ERR_SUCCESS;

goto ret;

}

}

break;

}

if (nStatus != ERR_PASSWORD_WRONG)

goto error;

handleError (hwndDlg, nStatus, SRC_POS);

}

}

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 */

goto ret;

/* Conceive the backup file */

if ((fBackup = _wopen(szFileName, _O_CREAT|_O_TRUNC|_O_WRONLY|_O_BINARY, _S_IREAD|_S_IWRITE)) == -1)

{

nStatus = ERR_OS_ERROR;

goto error;

}

// Backup headers

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)

{

if (CryptoAPILastError == ERROR_SUCCESS)

nStatus = ERR_RAND_INIT_FAILED;

else

nStatus = ERR_CAPI_INIT_FAILED;

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 (nStatus == ERR_SUCCESS)

break;

if (nStatus != ERR_PASSWORD_WRONG)

goto error;

handleError (hwndDlg, nStatus, SRC_POS);

}

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, VolumePim, 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;

}

{

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 */

{

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)

StringCbCopyW (szCFDevice, sizeof(szCFDevice), szDiskFile);

else

{

nDosLinkCreated = FakeDosNameForDevice (szDiskFile, szDosDevice, sizeof(szDosDevice),szCFDevice, sizeof(szCFDevice),FALSE);

if (nDosLinkCreated != 0)

goto error;

VolumePkcs5 = GuiPkcs5;

VolumePim = GuiPim;

burn (&GuiPkcs5, sizeof (GuiPkcs5));

burn (&GuiPim, sizeof (GuiPim));

}

if (KeyFilesEnable && FirstKeyFile)

KeyFilesApply (hwndDlg, &VolumePassword, FirstKeyFile, bDevice? NULL : lpszVolume);

// 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, VolumePim, &restoredCryptoInfo, NULL);

if (nStatus == ERR_SUCCESS)

break;

}

if (nStatus == ERR_SUCCESS)

break;

if (nStatus != ERR_PASSWORD_WRONG)

goto error;

handleError (hwndDlg, nStatus, SRC_POS);

}

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, VolumePim, FALSE);

if (nStatus != ERR_SUCCESS)

goto error;

if (!SetFilePointerEx (dev, headerOffset, NULL, FILE_BEGIN))

{

nStatus = ERR_OS_ERROR;

goto error;

}

{

nStatus = ERR_OS_ERROR;

goto error;

}

if (!restoredCryptoInfo->LegacyVolume)

{

// Restore backup header encrypted with a new key

nStatus = ReEncryptVolumeHeader (hwndDlg, buffer, FALSE, restoredCryptoInfo, &VolumePassword, VolumePim, FALSE);

if (nStatus != ERR_SUCCESS)

goto error;

if (!SetFilePointerEx (dev, headerBackupOffset, NULL, FILE_BEGIN))

{

nStatus = ERR_OS_ERROR;

goto error;

}

{

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);

RemoveFakeDosName (szDiskFile, szDosDevice);

}

SetLastError (dwError);

if (nStatus != 0)

handleError (hwndDlg, nStatus, SRC_POS);

burn (&VolumePassword, sizeof (VolumePassword));

burn (&VolumePkcs5, sizeof (VolumePkcs5));

burn (&VolumePim, sizeof (VolumePim));

RestoreDefaultKeyFilesParam();

RandStop (FALSE);

NormalCursor();

return nStatus;

}

void SetDriverConfigurationFlag (uint32 flag, BOOL state)

{

if (BootEncObj)

BootEncObj->SetDriverConfigurationFlag (flag, state ? true : false);

}

void SetServiceConfigurationFlag (uint32 flag, BOOL state)

{

if (BootEncObj)

BootEncObj->SetServiceConfigurationFlag (flag, state ? true : false);

}

void NotifyService (DWORD dwNotifyCmd)

{

if (BootEncObj)

BootEncObj->NotifyService (dwNotifyCmd);

}

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);

CheckDlgButton (hwndDlg, IDC_ENABLE_EXTENDED_IOCTL_SUPPORT, (driverConfig & TC_DRIVER_CONFIG_ENABLE_EXTENDED_IOCTL) ? BST_CHECKED : BST_UNCHECKED);

CheckDlgButton (hwndDlg, IDC_ALLOW_TRIM_NONSYS_SSD, (driverConfig & VC_DRIVER_CONFIG_ALLOW_NONSYS_TRIM) ? BST_CHECKED : BST_UNCHECKED);

// checkbox for Windows Defragmenter only usuable starting from Windows 8.1

// on previous versions, we can not control Windows defragmenter so

// this settings is always checked.

if (IsOSAtLeast (WIN_8_1))

CheckDlgButton (hwndDlg, IDC_ALLOW_WINDOWS_DEFRAG, (driverConfig & VC_DRIVER_CONFIG_ALLOW_WINDOWS_DEFRAG) ? BST_CHECKED : BST_UNCHECKED);

else

{

CheckDlgButton (hwndDlg, IDC_ALLOW_WINDOWS_DEFRAG, BST_CHECKED);

EnableWindow (GetDlgItem (hwndDlg, IDC_ALLOW_WINDOWS_DEFRAG), FALSE);

}

if (IsCpuRngSupported())

{

CheckDlgButton (hwndDlg, IDC_ENABLE_CPU_RNG, (driverConfig & VC_DRIVER_CONFIG_ENABLE_CPU_RNG) ? BST_CHECKED : BST_UNCHECKED);

}

else

{

CheckDlgButton (hwndDlg, IDC_ENABLE_CPU_RNG, BST_UNCHECKED);

EnableWindow (GetDlgItem (hwndDlg, IDC_ENABLE_CPU_RNG), FALSE);

}

{

CheckDlgButton (hwndDlg, IDC_ENABLE_RAM_ENCRYPTION, (driverConfig & VC_DRIVER_CONFIG_ENABLE_RAM_ENCRYPTION) ? BST_CHECKED : BST_UNCHECKED);

}

else

{

CheckDlgButton (hwndDlg, IDC_ENABLE_RAM_ENCRYPTION, BST_UNCHECKED);

EnableWindow (GetDlgItem (hwndDlg, IDC_ENABLE_RAM_ENCRYPTION), FALSE);

}

size_t cpuCount = GetCpuCount(NULL);

HWND freeCpuCombo = GetDlgItem (hwndDlg, IDC_ENCRYPTION_FREE_CPU_COUNT);

uint32 encryptionFreeCpuCount = ReadEncryptionThreadPoolFreeCpuCountLimit();

if (encryptionFreeCpuCount > (uint32) (cpuCount - 1))

encryptionFreeCpuCount = (uint32) (cpuCount - 1);

for (uint32 i = 1; i < cpuCount; ++i)

{

wstringstream s;

s << i;

AddComboPair (freeCpuCombo, s.str().c_str(), i);

}

if (cpuCount < 2 || encryptionFreeCpuCount == 0)

EnableWindow (freeCpuCombo, FALSE);

if (cpuCount < 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 (HasAESNI() ? "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);

BOOL enableCpuRng = IsDlgButtonChecked (hwndDlg, IDC_ENABLE_CPU_RNG);

BOOL enableRamEncryption = IsDlgButtonChecked (hwndDlg, IDC_ENABLE_RAM_ENCRYPTION);

BOOL enableExtendedIOCTL = IsDlgButtonChecked (hwndDlg, IDC_ENABLE_EXTENDED_IOCTL_SUPPORT);

BOOL allowTrimCommand = IsDlgButtonChecked (hwndDlg, IDC_ALLOW_TRIM_NONSYS_SSD);

BOOL allowWindowsDefrag = IsDlgButtonChecked (hwndDlg, IDC_ALLOW_WINDOWS_DEFRAG);

try

{

VOLUME_PROPERTIES_STRUCT prop;

bool rebootRequired = false;

uint32 driverConfig = ReadDriverConfigurationFlags();

try

{

BootEncStatus = BootEncObj->GetStatus();

BootEncObj->GetVolumeProperties (&prop);

}

catch (...)

{

BootEncStatus.DriveMounted = false;

}

if (BootEncStatus.DriveMounted && !bSystemIsGPT)

{

string customUserMessage;

uint16 bootLoaderVersion;

if (!BootEncObj->ReadBootSectorConfig (nullptr, 0, &userConfig, &customUserMessage, &bootLoaderVersion))

return 1;

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, prop.volumePim, prop.pkcs5);

}

SetDriverConfigurationFlag (TC_DRIVER_CONFIG_DISABLE_HARDWARE_ENCRYPTION, disableHW);

SetDriverConfigurationFlag (TC_DRIVER_CONFIG_ENABLE_EXTENDED_IOCTL, enableExtendedIOCTL);

SetDriverConfigurationFlag (VC_DRIVER_CONFIG_ALLOW_NONSYS_TRIM, allowTrimCommand);

if (IsOSAtLeast (WIN_8_1))

SetDriverConfigurationFlag (VC_DRIVER_CONFIG_ALLOW_WINDOWS_DEFRAG, allowWindowsDefrag);

SetDriverConfigurationFlag (VC_DRIVER_CONFIG_ENABLE_CPU_RNG, enableCpuRng);

{

{

{

}

}

}

}

DWORD bytesReturned;

if (!DeviceIoControl (hDriver, TC_IOCTL_REREAD_DRIVER_CONFIG, NULL, 0, NULL, 0, &bytesReturned, NULL))

handleWin32Error (hwndDlg, SRC_POS);

EnableHwEncryption (!disableHW);

EnableCpuRng (enableCpuRng);

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 (L"SYSTEM\\CurrentControlSet\\Services\\veracrypt", TC_ENCRYPTION_FREE_CPU_COUNT_REG_VALUE_NAME, cpuFreeCount);

rebootRequired = true;

}

if (rebootRequired)

Warning ("SETTING_REQUIRES_REBOOT", hwndDlg);

EndDialog (hwndDlg, lw);

return 1;

}

catch (Exception &e)

{

case IDC_ENABLE_RAM_ENCRYPTION:

{

uint32 driverConfig = ReadDriverConfigurationFlags();

BOOL originalRamEncryptionEnabled = (driverConfig & VC_DRIVER_CONFIG_ENABLE_RAM_ENCRYPTION)? TRUE : FALSE;

BOOL enableRamEncryption = IsDlgButtonChecked (hwndDlg, IDC_ENABLE_RAM_ENCRYPTION);

if (originalRamEncryptionEnabled != enableRamEncryption)

{

if (enableRamEncryption)

{

// check if Hibernate or Fast Startup are enabled

BOOL bHibernateEnabled, bHiberbootEnabled;

if (GetHibernateStatus (bHibernateEnabled, bHiberbootEnabled))

{

if (bHibernateEnabled || bHiberbootEnabled)

{

if (AskWarnYesNo ("RAM_ENCRYPTION_DISABLE_HIBERNATE", hwndDlg) == IDNO)

{

CheckDlgButton (hwndDlg, IDC_ENABLE_RAM_ENCRYPTION, BST_UNCHECKED);

return 1;

}

}

}

}

Warning ("SETTING_REQUIRES_REBOOT", hwndDlg);

}

}

return 1;

case IDC_BENCHMARK:

Benchmark (hwndDlg);

return 1;

case IDC_MORE_INFO_ON_HW_ACCELERATION:

Applink ("hwacceleration");

return 1;

case IDC_MORE_INFO_ON_THREAD_BASED_PARALLELIZATION:

Applink ("parallelization");

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);

case IDOK:

{

int pkcs5 = (int) SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETITEMDATA, SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETCURSEL, 0, 0), 0);

WaitCursor ();

DefaultVolumePkcs5 = pkcs5;

SaveSettings (hwndDlg);

NormalCursor ();

EndDialog (hwndDlg, lw);

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);

static std::string platforminfo;

static string currentCustomUserMessage;

switch (msg)

{

case WM_INITDIALOG:

{

BootEncryptionStatus BootEncStatus = BootEncObj->GetStatus();

if (!BootEncStatus.DriveMounted)

{

Warning ("SYS_DRIVE_NOT_ENCRYPTED", hwndDlg);

EndDialog (hwndDlg, IDCANCEL);

return 1;

}

try

{

LocalizeDialog (hwndDlg, "IDD_SYSENC_SETTINGS");

uint32 driverConfig = ReadDriverConfigurationFlags();

uint32 serviceConfig = ReadServiceConfigurationFlags();

string customUserMessage;

uint16 bootLoaderVersion = 0;

BOOL bPasswordCacheEnabled = (driverConfig & TC_DRIVER_CONFIG_CACHE_BOOT_PASSWORD)? TRUE : FALSE;

BOOL bPimCacheEnabled = (driverConfig & TC_DRIVER_CONFIG_CACHE_BOOT_PIM)? TRUE : FALSE;

BOOL bBlockSysEncTrimEnabled = (driverConfig & VC_DRIVER_CONFIG_BLOCK_SYS_TRIM)? TRUE : FALSE;

BOOL bClearKeysEnabled = (driverConfig & VC_DRIVER_CONFIG_CLEAR_KEYS_ON_NEW_DEVICE_INSERTION)? TRUE : FALSE;

BOOL bAutoFixBootloader = (serviceConfig & VC_SYSTEM_FAVORITES_SERVICE_CONFIG_DONT_UPDATE_LOADER)? FALSE : TRUE;

BOOL bForceVeraCryptNextBoot = FALSE;

BOOL bForceSetVeraCryptBootEntry = TRUE;

BOOL bForceVeraCryptFirstEntry = TRUE;

if (bSystemIsGPT)

{

bForceVeraCryptNextBoot = (serviceConfig & VC_SYSTEM_FAVORITES_SERVICE_CONFIG_FORCE_SET_BOOTNEXT)? TRUE : FALSE;

bForceSetVeraCryptBootEntry = (serviceConfig & VC_SYSTEM_FAVORITES_SERVICE_CONFIG_DONT_SET_BOOTENTRY)? FALSE : TRUE;

bForceVeraCryptFirstEntry = (serviceConfig & VC_SYSTEM_FAVORITES_SERVICE_CONFIG_DONT_FORCE_FIRST_BOOTENTRY)? FALSE : TRUE;

}

BOOL bIsHiddenOS = IsHiddenOSRunning ();

if (bClearKeysEnabled)

{

// the clear keys option works only if the service is running

if (!BootEncObj->IsSystemFavoritesServiceRunning())

bClearKeysEnabled = false;

}

if (!BootEncObj->ReadBootSectorConfig (nullptr, 0, &userConfig, &customUserMessage, &bootLoaderVersion))

{

// operations canceled

}

catch (Exception &e) { e.Show(hwndDlg); }

}

return 0;

case IDOK:

{

VOLUME_PROPERTIES_STRUCT prop;

if (!BootEncObj->GetStatus().DriveMounted)

{

EndDialog (hwndDlg, IDCANCEL);

return 1;

}

try

{

BootEncObj->GetVolumeProperties (&prop);

}

catch (Exception &e)

{

e.Show (hwndDlg);

EndDialog (hwndDlg, IDCANCEL);

return 1;

}

char customUserMessage[TC_BOOT_SECTOR_USER_MESSAGE_MAX_LENGTH + 1] = {0};

if (!bSystemIsGPT)

GetDlgItemTextA (hwndDlg, IDC_CUSTOM_BOOT_LOADER_MESSAGE, customUserMessage, sizeof (customUserMessage));

if (IsDlgButtonChecked (hwndDlg, IDC_DISABLE_BOOT_LOADER_PIM_PROMPT))

userConfig |= TC_BOOT_USER_CFG_FLAG_DISABLE_PIM;

else

userConfig &= ~TC_BOOT_USER_CFG_FLAG_DISABLE_PIM;

if (bSystemIsGPT)

{

if (IsDlgButtonChecked (hwndDlg, IDC_DISABLE_BOOT_LOADER_HASH_PROMPT))

userConfig |= TC_BOOT_USER_CFG_FLAG_STORE_HASH;

else

userConfig &= ~TC_BOOT_USER_CFG_FLAG_STORE_HASH;

}

else

{

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

{

BOOL bPasswordCacheEnabled = IsDlgButtonChecked (hwndDlg, IDC_BOOT_LOADER_CACHE_PASSWORD);

BOOL bPimCacheEnabled = IsDlgButtonChecked (hwndDlg, IDC_BOOT_LOADER_CACHE_PIM);

<?xml version="1.0" encoding="utf-8" standalone="yes"?>

<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">

<trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">

<security>

<requestedPrivileges>

<requestedExecutionLevel level="asInvoker" uiAccess="false"/>

</requestedPrivileges>

</security>

</trustInfo>

<asmv3:application>

<asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">

<dpiAware>true</dpiAware>

</asmv3:windowsSettings>

</asmv3:application>

<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">

<application>

<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>

</application>

</compatibility>

<dependency>

<dependentAssembly>

<assemblyIdentity

type="win32"

name="Microsoft.Windows.Common-Controls"

version="6.0.0.0"

processorArchitecture="*"

publicKeyToken="6595b64144ccf1df"

language="*"

/>

</dependentAssembly>

</dependency>

</assembly> \ No newline at end of file

BEGIN

GROUPBOX "Boot Loader Screen Options",IDT_BOOT_LOADER_SCREEN_OPTIONS,8,7,355,45

CONTROL "Do not request PIM in the pre-boot authentication screen (PIM value is stored unencrypted on disk)",IDC_DISABLE_BOOT_LOADER_PIM_PROMPT,

"Button",BS_AUTOCHECKBOX | WS_TABSTOP,18,20,339,9

CONTROL "Do not request Hash algorithm in the pre-boot authentication screen",IDC_DISABLE_BOOT_LOADER_HASH_PROMPT,

"Button",BS_AUTOCHECKBOX | WS_TABSTOP,18,35,339,9

GROUPBOX "Security Options",IDT_SECURITY_OPTIONS,7,53,355,75

CONTROL "&Cache pre-boot authentication password in driver memory (for mounting of non-system volumes)",IDC_BOOT_LOADER_CACHE_PASSWORD,

"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,68,339,10

CONTROL "Include PIM when caching pre-boot authentication password",IDC_BOOT_LOADER_CACHE_PIM,

"Button",BS_AUTOCHECKBOX | WS_DISABLED | WS_TABSTOP,16,83,340,10

CONTROL "Block TRIM command on system partition/drive",IDC_BLOCK_SYSENC_TRIM,

"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,98,340,10

CONTROL "Clear encryption keys from memory if a new device is inserted",IDC_CLEAR_KEYS_ON_NEW_DEVICE_INSERTION,

"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,112,340,10

GROUPBOX "Advanced Options",IDT_ADVANCED_OPTIONS,7,131,355,91

CONTROL "Automatically fix boot configuration issues that may prevent Windows from starting",IDC_UPDATE_BOOTLOADER_ON_SHUTDOWN,

"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,144,340,10

CONTROL "Force machine to boot on VeraCrypt in the next startup",IDC_FORCE_NEXT_BOOT_VERACRYPT,

"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,158,340,10

CONTROL "Force the presence of VeraCrypt entry in the EFI firmware boot menu",IDC_FORCE_VERACRYPT_BOOT_ENTRY,

"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,172,340,10

CONTROL "Force VeraCrypt entry to be the first in the EFI firmware boot menu",IDC_FORCE_VERACRYPT_FIRST_BOOT_ENTRY,

"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,186,340,10

PUSHBUTTON "Edit Boot Loader Configuration",IDC_EDIT_DCSPROP,10,201,173,14

PUSHBUTTON "Display EFI Platform Information",IDC_SHOW_PLATFORMINFO,187,201,173,14

PUSHBUTTON "Cancel",IDCANCEL,313,226,50,14

DEFPUSHBUTTON "OK",IDOK,255,226,50,14

END

STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | DS_CENTER | WS_POPUP | WS_CAPTION | WS_SYSMENU

CAPTION "VeraCrypt - Performance Options"

FONT 8, "MS Shell Dlg", 400, 0, 0x1

BEGIN

CONTROL "",IDC_HW_AES_SUPPORTED_BY_CPU,"Static",SS_LEFTNOWORDWRAP | WS_GROUP,294,21,57,12,WS_EX_CLIENTEDGE

CONTROL "Accelerate AES encryption/decryption by using the AES instructions of the processor (if available)",IDC_ENABLE_HARDWARE_ENCRYPTION,

"Button",BS_AUTOCHECKBOX | BS_MULTILINE | WS_TABSTOP,18,41,340,17

LTEXT "More information",IDC_MORE_INFO_ON_HW_ACCELERATION,18,61,165,10,SS_NOTIFY

CONTROL "Do not use the following number of logical processors for encryption/decryption:",IDC_LIMIT_ENC_THREAD_POOL,

"Button",BS_AUTOCHECKBOX | BS_TOP | WS_TABSTOP,18,103,283,11

COMBOBOX IDC_ENCRYPTION_FREE_CPU_COUNT,304,101,48,51,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP

LTEXT "",IDT_LIMIT_ENC_THREAD_POOL_NOTE,18,126,334,33

LTEXT "More information",IDC_MORE_INFO_ON_THREAD_BASED_PARALLELIZATION,18,159,165,10,SS_NOTIFY

CONTROL "Enable extended disk control codes support",IDC_ENABLE_EXTENDED_IOCTL_SUPPORT,

"Button",BS_AUTOCHECKBOX | WS_TABSTOP,18,198,337,10

CONTROL "Allow TRIM command for non-system SSD partition/drive",IDC_ALLOW_TRIM_NONSYS_SSD,

CONTROL "Allow Windows Disk Defragmenter to defragment non-system partition/drive",IDC_ALLOW_WINDOWS_DEFRAG,

CONTROL "Use CPU hardware random generator as an additional source of entropy",IDC_ENABLE_CPU_RNG,

CONTROL "Activate encryption of keys and passwords stored in RAM",IDC_ENABLE_RAM_ENCRYPTION,

END

IDD_FAVORITE_VOLUMES DIALOGEX 0, 0, 380, 368

STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | DS_CENTER | WS_POPUP | WS_CAPTION | WS_SYSMENU

CAPTION "VeraCrypt - Favorite Volumes"

FONT 8, "MS Shell Dlg", 400, 0, 0x1

BEGIN

CONTROL "",IDC_FAVORITE_VOLUMES_LIST,"SysListView32",LVS_REPORT | LVS_SINGLESEL | LVS_SHOWSELALWAYS | LVS_ALIGNLEFT | LVS_NOSORTHEADER | WS_BORDER | WS_TABSTOP,7,7,366,92

PUSHBUTTON "Move &Up",IDC_FAVORITE_MOVE_UP,7,104,63,14

PUSHBUTTON "Move &Down",IDC_FAVORITE_MOVE_DOWN,74,104,63,14

PUSHBUTTON "&Remove",IDC_FAVORITE_REMOVE,310,104,63,14

EDITTEXT IDC_FAVORITE_LABEL,18,225,344,13,ES_AUTOHSCROLL

CONTROL "Mount selected volume as read-o&nly",IDC_FAVORITE_MOUNT_READONLY,

"Button",BS_AUTOCHECKBOX | WS_TABSTOP,18,255,349,10

CONTROL "Mount selected volume as remo&vable medium",IDC_FAVORITE_MOUNT_REMOVABLE,

"Button",BS_AUTOCHECKBOX | WS_TABSTOP,18,269,349,10

CONTROL "Mount selected volume upon log&on",IDC_FAVORITE_MOUNT_ON_LOGON,

"Button",BS_AUTOCHECKBOX | WS_TABSTOP,18,283,349,10

CONTROL "Mount selected volume when its host device gets &connected",IDC_FAVORITE_MOUNT_ON_ARRIVAL,

"Button",BS_AUTOCHECKBOX | WS_TABSTOP,18,297,349,10

CONTROL "Open &Explorer window for selected volume when successfully mounted",IDC_FAVORITE_OPEN_EXPLORER_WIN_ON_MOUNT,

"Button",BS_AUTOCHECKBOX | WS_TABSTOP,18,311,349,11

CONTROL "Do not mount selected volume when 'Mount Favorite Volumes' &hot key is pressed",IDC_FAVORITE_DISABLE_HOTKEY,

"Button",BS_AUTOCHECKBOX | WS_TABSTOP,18,326,349,11

LTEXT "Help on favorite volumes",IDC_FAVORITES_HELP_LINK,17,351,237,10,SS_NOTIFY

DEFPUSHBUTTON "OK",IDOK,269,347,50,14

PUSHBUTTON "Cancel",IDCANCEL,323,347,50,14

GROUPBOX "",IDC_FAV_VOL_OPTIONS_GROUP_BOX,7,123,366,219

LTEXT "Label of selected favorite volume:",IDT_FAVORITE_LABEL,18,215,202,8

GROUPBOX "Global Settings",IDC_FAV_VOL_OPTIONS_GLOBAL_SETTINGS_BOX,7,300,366,42

IDD_HOTKEYS_DLG, DIALOG

BEGIN

LEFTMARGIN, 7

RIGHTMARGIN, 382

TOPMARGIN, 7

BOTTOMMARGIN, 250

END

IDD_TOKEN_PREFERENCES, DIALOG

BEGIN

LEFTMARGIN, 7

RIGHTMARGIN, 309

TOPMARGIN, 7

BOTTOMMARGIN, 192

END

IDD_EFI_SYSENC_SETTINGS, DIALOG

BEGIN

LEFTMARGIN, 7

RIGHTMARGIN, 368

TOPMARGIN, 7

BOTTOMMARGIN, 240

END

IDD_PERFORMANCE_SETTINGS, DIALOG

BEGIN

LEFTMARGIN, 7

RIGHTMARGIN, 364

TOPMARGIN, 7

END

IDD_FAVORITE_VOLUMES, DIALOG

BEGIN

LEFTMARGIN, 7

RIGHTMARGIN, 373

TOPMARGIN, 7

BOTTOMMARGIN, 361

END

IDD_DEFAULT_MOUNT_PARAMETERS, DIALOG

BEGIN

LEFTMARGIN, 7

RIGHTMARGIN, 160

TOPMARGIN, 7

BOTTOMMARGIN, 58

END

IDD_SYSENC_SETTINGS, DIALOG

BEGIN

LEFTMARGIN, 7

RIGHTMARGIN, 364

TOPMARGIN, 7

BOTTOMMARGIN, 334

END

END

#endif // APSTUDIO_INVOKED

/////////////////////////////////////////////////////////////////////////////

//

// Version

//

VS_VERSION_INFO VERSIONINFO

FILEFLAGSMASK 0x17L

#ifdef _DEBUG

FILEFLAGS 0x1L

#else

FILEFLAGS 0x0L

#endif

FILEOS 0x4L

FILETYPE 0x1L

FILESUBTYPE 0x0L

BEGIN

BLOCK "StringFileInfo"

BEGIN

BLOCK "040904b0"

BEGIN

VALUE "CompanyName", "IDRIX"

VALUE "FileDescription", "VeraCrypt"

VALUE "LegalTrademarks", "VeraCrypt"

VALUE "OriginalFilename", "VeraCrypt.exe"

VALUE "ProductName", "VeraCrypt"

END

END

BLOCK "VarFileInfo"

BEGIN

VALUE "Translation", 0x409, 1200

END

END

#ifdef APSTUDIO_INVOKED

/////////////////////////////////////////////////////////////////////////////

//

// TEXTINCLUDE

//

1 TEXTINCLUDE

BEGIN

"resource.h\0"

END

2 TEXTINCLUDE

BEGIN

"#include ""afxres.h""\r\n"

"#include ""..\\\\common\\\\resource.h""\r\n"

"\0"

END

3 TEXTINCLUDE

BEGIN

"#include ""..\\\\common\\\\common.rc""\r\n"

<Midl>

<AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<TypeLibraryName>$(SolutionDir)/$(ProjectName)/$(ProjectName).tlb</TypeLibraryName>

<OutputDirectory>

</OutputDirectory>

</Midl>

<ClCompile>

<Optimization>Disabled</Optimization>

<AdditionalIncludeDirectories>..\Common;..\Crypto;..\;..\PKCS11;..\Common\zlib;..\Common\libzip;..\Common\lzma;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<PreprocessorDefinitions>TCMOUNT;WIN32;HAVE_CONFIG_H;ZIP_STATIC;DEBUG;_DEBUG;_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NON_CONFORMING_SWPRINTFS;%(PreprocessorDefinitions)</PreprocessorDefinitions>

<MinimalRebuild>true</MinimalRebuild>

<ExceptionHandling>Sync</ExceptionHandling>

<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>

<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>

<BufferSecurityCheck>true</BufferSecurityCheck>

<FunctionLevelLinking>false</FunctionLevelLinking>

<PrecompiledHeader>

</PrecompiledHeader>

<BrowseInformation>

</BrowseInformation>

<BrowseInformationFile>

</BrowseInformationFile>

<WarningLevel>Level4</WarningLevel>

<DebugInformationFormat>EditAndContinue</DebugInformationFormat>

<DisableSpecificWarnings>4057;4100;4127;4201;4701;4706;4131;%(DisableSpecificWarnings)</DisableSpecificWarnings>

</ClCompile>

<Link>

<AdditionalDependencies>..\Crypto\Debug\crypto.lib;..\Common\Debug\Zip.lib;..\Common\Debug\lzma.lib;mpr.lib;%(AdditionalDependencies)</AdditionalDependencies>

<OutputFile>$(OutDir)VeraCrypt.exe</OutputFile>

<IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>

<GenerateDebugInformation>true</GenerateDebugInformation>

<ProgramDatabaseFile>$(OutDir)Mount.pdb</ProgramDatabaseFile>

<SubSystem>Windows</SubSystem>

<RandomizedBaseAddress>false</RandomizedBaseAddress>

<DataExecutionPrevention>true</DataExecutionPrevention>

<TargetMachine>MachineX86</TargetMachine>

</Link>

<Manifest>

<AdditionalManifestFiles>Mount.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>

</Manifest>

<PostBuildEvent>

<Command>md "..\Debug\Setup Files" 2&gt;NUL:

copy Debug\VeraCrypt.exe "..\Debug\Setup Files" &gt;NUL:

</Command>

</PostBuildEvent>

</ItemDefinitionGroup>

<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">

<Midl>

<AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<TargetEnvironment>X64</TargetEnvironment>

<TypeLibraryName>$(SolutionDir)/$(ProjectName)/$(ProjectName).tlb</TypeLibraryName>

<OutputDirectory>

</OutputDirectory>

</Midl>

<ClCompile>

<Optimization>Disabled</Optimization>

<AdditionalIncludeDirectories>..\Common;..\Crypto;..\;..\PKCS11;..\Common\zlib;..\Common\libzip;..\Common\lzma;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<PreprocessorDefinitions>TCMOUNT;WIN32;HAVE_CONFIG_H;ZIP_STATIC;DEBUG;_DEBUG;_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NON_CONFORMING_SWPRINTFS;%(PreprocessorDefinitions)</PreprocessorDefinitions>

<MinimalRebuild>true</MinimalRebuild>

<ExceptionHandling>Sync</ExceptionHandling>

<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>

<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>

<BufferSecurityCheck>true</BufferSecurityCheck>

<FunctionLevelLinking>false</FunctionLevelLinking>

<PrecompiledHeader>

</PrecompiledHeader>

<BrowseInformation>

</BrowseInformation>

<BrowseInformationFile>

</BrowseInformationFile>

<WarningLevel>Level4</WarningLevel>

<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>

<DisableSpecificWarnings>4057;4100;4127;4201;4701;4706;4131;%(DisableSpecificWarnings)</DisableSpecificWarnings>

</ClCompile>

<Link>

<AdditionalDependencies>..\Crypto\x64\Debug\crypto.lib;..\Common\x64\Debug\Zip.lib;..\Common\x64\Debug\lzma.lib;mpr.lib;%(AdditionalDependencies)</AdditionalDependencies>

<OutputFile>$(OutDir)VeraCrypt.exe</OutputFile>

<IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>

<GenerateDebugInformation>true</GenerateDebugInformation>

<ProgramDatabaseFile>$(OutDir)Mount.pdb</ProgramDatabaseFile>

<SubSystem>Windows</SubSystem>

<RandomizedBaseAddress>false</RandomizedBaseAddress>

<DataExecutionPrevention>true</DataExecutionPrevention>

<TargetMachine>MachineX64</TargetMachine>

</Link>

<Manifest>

<AdditionalManifestFiles>Mount.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>

</Manifest>

<PostBuildEvent>

<Command>md "..\Debug\Setup Files" 2&gt;NUL:

copy $(TargetPath) "..\Debug\Setup Files\VeraCrypt-x64.exe" &gt;NUL:

</Command>

</PostBuildEvent>

<ResourceCompile>

<PreprocessorDefinitions>WIN64;%(PreprocessorDefinitions)</PreprocessorDefinitions>

</ResourceCompile>

</ItemDefinitionGroup>

<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

<Midl>

<AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<TypeLibraryName>$(SolutionDir)/$(ProjectName)/$(ProjectName).tlb</TypeLibraryName>

<OutputDirectory>

</OutputDirectory>

</Midl>

<ClCompile>

<AdditionalOptions>/w34189 %(AdditionalOptions)</AdditionalOptions>

<Optimization>MaxSpeed</Optimization>

<AdditionalIncludeDirectories>..\Common;..\Crypto;..\;..\PKCS11;..\Common\zlib;..\Common\libzip;..\Common\lzma;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<PreprocessorDefinitions>TCMOUNT;WIN32;HAVE_CONFIG_H;ZIP_STATIC;NDEBUG;_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NON_CONFORMING_SWPRINTFS;%(PreprocessorDefinitions)</PreprocessorDefinitions>

<RuntimeLibrary>MultiThreaded</RuntimeLibrary>

<BufferSecurityCheck>true</BufferSecurityCheck>

<PrecompiledHeader>

</PrecompiledHeader>

<AssemblerOutput>All</AssemblerOutput>

<AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>

<WarningLevel>Level4</WarningLevel>

<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>

<DisableSpecificWarnings>4057;4100;4127;4201;4701;4706;4131;%(DisableSpecificWarnings)</DisableSpecificWarnings>

</ClCompile>

<Link>

<AdditionalDependencies>..\Crypto\Release\crypto.lib;..\Common\Release\Zip.lib;..\Common\Release\lzma.lib;mpr.lib;%(AdditionalDependencies)</AdditionalDependencies>

<OutputFile>$(OutDir)VeraCrypt.exe</OutputFile>

<IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>

<GenerateDebugInformation>true</GenerateDebugInformation>

<GenerateMapFile>true</GenerateMapFile>

<SubSystem>Windows</SubSystem>

<OptimizeReferences>true</OptimizeReferences>

<EnableCOMDATFolding>true</EnableCOMDATFolding>

<RandomizedBaseAddress>true</RandomizedBaseAddress>

<DataExecutionPrevention>true</DataExecutionPrevention>

<TargetMachine>MachineX86</TargetMachine>

</Link>

<Manifest>

<AdditionalManifestFiles>Mount.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>

</Manifest>

<PostBuildEvent>

<Command>copy Release\VeraCrypt.exe "..\Release\Setup Files"</Command>

</PostBuildEvent>

</ItemDefinitionGroup>

<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release_SkipOsDriverReqCheck|Win32'">

<Midl>

<AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<TypeLibraryName>$(SolutionDir)/$(ProjectName)/$(ProjectName).tlb</TypeLibraryName>

<OutputDirectory>

</OutputDirectory>

</Midl>

<ClCompile>

<AdditionalOptions>/w34189 %(AdditionalOptions)</AdditionalOptions>

<Optimization>MaxSpeed</Optimization>

<AdditionalIncludeDirectories>..\Common;..\Crypto;..\;..\PKCS11;..\Common\zlib;..\Common\libzip;..\Common\lzma;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<PreprocessorDefinitions>TCMOUNT;VC_SKIP_OS_DRIVER_REQ_CHECK;WIN32;HAVE_CONFIG_H;ZIP_STATIC;NDEBUG;_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NON_CONFORMING_SWPRINTFS;%(PreprocessorDefinitions)</PreprocessorDefinitions>

<RuntimeLibrary>MultiThreaded</RuntimeLibrary>

<BufferSecurityCheck>true</BufferSecurityCheck>

<PrecompiledHeader>

</PrecompiledHeader>

<AssemblerOutput>All</AssemblerOutput>

<AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>

<WarningLevel>Level4</WarningLevel>

<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>

<DisableSpecificWarnings>4057;4100;4127;4201;4701;4706;4131;%(DisableSpecificWarnings)</DisableSpecificWarnings>

</ClCompile>

<Link>

<AdditionalDependencies>..\Crypto\Release\crypto.lib;..\Common\Release\Zip.lib;..\Common\Release\lzma.lib;mpr.lib;%(AdditionalDependencies)</AdditionalDependencies>

<OutputFile>$(OutDir)VeraCrypt.exe</OutputFile>

<IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>

<GenerateDebugInformation>true</GenerateDebugInformation>

<GenerateMapFile>true</GenerateMapFile>

<SubSystem>Windows</SubSystem>

<OptimizeReferences>true</OptimizeReferences>

<EnableCOMDATFolding>true</EnableCOMDATFolding>

<RandomizedBaseAddress>true</RandomizedBaseAddress>

<DataExecutionPrevention>true</DataExecutionPrevention>

<TargetMachine>MachineX86</TargetMachine>

</Link>

<Manifest>

<AdditionalManifestFiles>Mount.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>

</Manifest>

<PostBuildEvent>

<Command>copy Release\VeraCrypt.exe "..\Release\Setup Files"</Command>

</PostBuildEvent>

</ItemDefinitionGroup>

<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseCustomEFI|Win32'">

<Midl>

<AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<TypeLibraryName>$(SolutionDir)/$(ProjectName)/$(ProjectName).tlb</TypeLibraryName>

<OutputDirectory>

</OutputDirectory>

</Midl>

<ClCompile>

<AdditionalOptions>/w34189 %(AdditionalOptions)</AdditionalOptions>

<Optimization>MaxSpeed</Optimization>

<AdditionalIncludeDirectories>..\Common;..\Crypto;..\;..\PKCS11;..\Common\zlib;..\Common\libzip;..\Common\lzma;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<PreprocessorDefinitions>TCMOUNT;VC_EFI_CUSTOM_MODE;WIN32;HAVE_CONFIG_H;ZIP_STATIC;NDEBUG;_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NON_CONFORMING_SWPRINTFS;%(PreprocessorDefinitions)</PreprocessorDefinitions>

<RuntimeLibrary>MultiThreaded</RuntimeLibrary>

<BufferSecurityCheck>true</BufferSecurityCheck>

<PrecompiledHeader>

</PrecompiledHeader>

<AssemblerOutput>All</AssemblerOutput>

<AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>

<WarningLevel>Level4</WarningLevel>

<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>

<DisableSpecificWarnings>4057;4100;4127;4201;4701;4706;4131;%(DisableSpecificWarnings)</DisableSpecificWarnings>

</ClCompile>

<Link>

<AdditionalDependencies>..\Crypto\Release\crypto.lib;..\Common\Release\Zip.lib;..\Common\Release\lzma.lib;mpr.lib;%(AdditionalDependencies)</AdditionalDependencies>

<OutputFile>$(OutDir)VeraCrypt.exe</OutputFile>

<IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>

<GenerateDebugInformation>true</GenerateDebugInformation>

<GenerateMapFile>true</GenerateMapFile>

<SubSystem>Windows</SubSystem>

<OptimizeReferences>true</OptimizeReferences>

<EnableCOMDATFolding>true</EnableCOMDATFolding>

<RandomizedBaseAddress>true</RandomizedBaseAddress>

<DataExecutionPrevention>true</DataExecutionPrevention>

<TargetMachine>MachineX86</TargetMachine>

</Link>

<Manifest>

<AdditionalManifestFiles>Mount.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>

</Manifest>

<PostBuildEvent>

<Command>copy Release\VeraCrypt.exe "..\Release\Setup Files"</Command>

</PostBuildEvent>

<ResourceCompile>

<PreprocessorDefinitions>VC_EFI_CUSTOM_MODE;%(PreprocessorDefinitions)</PreprocessorDefinitions>

</ResourceCompile>

</ItemDefinitionGroup>

<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">

<Midl>

<AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<TargetEnvironment>X64</TargetEnvironment>

<TypeLibraryName>$(SolutionDir)/$(ProjectName)/$(ProjectName).tlb</TypeLibraryName>

<OutputDirectory>

</OutputDirectory>

</Midl>

<ClCompile>

<AdditionalOptions>/w34189 %(AdditionalOptions)</AdditionalOptions>

<Optimization>MaxSpeed</Optimization>

<AdditionalIncludeDirectories>..\Common;..\Crypto;..\;..\PKCS11;..\Common\zlib;..\Common\libzip;..\Common\lzma;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<PreprocessorDefinitions>TCMOUNT;WIN32;HAVE_CONFIG_H;ZIP_STATIC;NDEBUG;_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NON_CONFORMING_SWPRINTFS;%(PreprocessorDefinitions)</PreprocessorDefinitions>

<RuntimeLibrary>MultiThreaded</RuntimeLibrary>

<BufferSecurityCheck>true</BufferSecurityCheck>

<PrecompiledHeader>

</PrecompiledHeader>

<AssemblerOutput>All</AssemblerOutput>

<AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>

<WarningLevel>Level4</WarningLevel>

<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>

<DisableSpecificWarnings>4057;4100;4127;4201;4701;4706;4131;%(DisableSpecificWarnings)</DisableSpecificWarnings>

</ClCompile>

<Link>

<AdditionalDependencies>..\Crypto\x64\Release\crypto.lib;..\Common\x64\Release\Zip.lib;..\Common\x64\Release\lzma.lib;mpr.lib;%(AdditionalDependencies)</AdditionalDependencies>

<OutputFile>$(OutDir)VeraCrypt.exe</OutputFile>

<IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>

<GenerateDebugInformation>true</GenerateDebugInformation>

<GenerateMapFile>true</GenerateMapFile>

<SubSystem>Windows</SubSystem>

<OptimizeReferences>true</OptimizeReferences>

<EnableCOMDATFolding>true</EnableCOMDATFolding>

<RandomizedBaseAddress>true</RandomizedBaseAddress>

<DataExecutionPrevention>true</DataExecutionPrevention>

<TargetMachine>MachineX64</TargetMachine>

</Link>

<Manifest>

<AdditionalManifestFiles>Mount.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>

</Manifest>

<PostBuildEvent>

<Command>copy $(TargetPath) "..\Release\Setup Files\VeraCrypt-x64.exe"</Command>

</PostBuildEvent>

<ResourceCompile>

<PreprocessorDefinitions>WIN64;%(PreprocessorDefinitions)</PreprocessorDefinitions>

</ResourceCompile>

</ItemDefinitionGroup>

<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release_SkipOsDriverReqCheck|x64'">

<Midl>

<AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<TargetEnvironment>X64</TargetEnvironment>

<TypeLibraryName>$(SolutionDir)/$(ProjectName)/$(ProjectName).tlb</TypeLibraryName>

<OutputDirectory>

</OutputDirectory>

</Midl>

<ClCompile>

<AdditionalOptions>/w34189 %(AdditionalOptions)</AdditionalOptions>

<Optimization>MaxSpeed</Optimization>

<AdditionalIncludeDirectories>..\Common;..\Crypto;..\;..\PKCS11;..\Common\zlib;..\Common\libzip;..\Common\lzma;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<PreprocessorDefinitions>TCMOUNT;VC_SKIP_OS_DRIVER_REQ_CHECK;WIN32;HAVE_CONFIG_H;ZIP_STATIC;NDEBUG;_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NON_CONFORMING_SWPRINTFS;%(PreprocessorDefinitions)</PreprocessorDefinitions>

<RuntimeLibrary>MultiThreaded</RuntimeLibrary>

<BufferSecurityCheck>true</BufferSecurityCheck>

<PrecompiledHeader>

</PrecompiledHeader>

<AssemblerOutput>All</AssemblerOutput>

<AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>

<WarningLevel>Level4</WarningLevel>

<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>

<DisableSpecificWarnings>4057;4100;4127;4201;4701;4706;4131;%(DisableSpecificWarnings)</DisableSpecificWarnings>

</ClCompile>

<Link>

<AdditionalDependencies>..\Crypto\x64\Release\crypto.lib;..\Common\x64\Release\Zip.lib;..\Common\x64\Release\lzma.lib;mpr.lib;%(AdditionalDependencies)</AdditionalDependencies>

<OutputFile>$(OutDir)VeraCrypt.exe</OutputFile>

<IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>

<GenerateDebugInformation>true</GenerateDebugInformation>

<GenerateMapFile>true</GenerateMapFile>

<SubSystem>Windows</SubSystem>

<OptimizeReferences>true</OptimizeReferences>

<EnableCOMDATFolding>true</EnableCOMDATFolding>

<RandomizedBaseAddress>true</RandomizedBaseAddress>

<DataExecutionPrevention>true</DataExecutionPrevention>

<TargetMachine>MachineX64</TargetMachine>

</Link>

<Manifest>

<AdditionalManifestFiles>Mount.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>

</Manifest>

<PostBuildEvent>

<Command>copy $(TargetPath) "..\Release\Setup Files\VeraCrypt-x64.exe"</Command>

</PostBuildEvent>

<ResourceCompile>

<PreprocessorDefinitions>WIN64;%(PreprocessorDefinitions)</PreprocessorDefinitions>

</ResourceCompile>

</ItemDefinitionGroup>

<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseCustomEFI|x64'">

<Midl>

<AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<TargetEnvironment>X64</TargetEnvironment>

<TypeLibraryName>$(SolutionDir)/$(ProjectName)/$(ProjectName).tlb</TypeLibraryName>

<OutputDirectory>

</OutputDirectory>

</Midl>

<ClCompile>

<AdditionalOptions>/w34189 %(AdditionalOptions)</AdditionalOptions>

<Optimization>MaxSpeed</Optimization>

<AdditionalIncludeDirectories>..\Common;..\Crypto;..\;..\PKCS11;..\Common\zlib;..\Common\libzip;..\Common\lzma;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<PreprocessorDefinitions>TCMOUNT;VC_EFI_CUSTOM_MODE;WIN32;HAVE_CONFIG_H;ZIP_STATIC;NDEBUG;_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NON_CONFORMING_SWPRINTFS;%(PreprocessorDefinitions)</PreprocessorDefinitions>

<RuntimeLibrary>MultiThreaded</RuntimeLibrary>

<BufferSecurityCheck>true</BufferSecurityCheck>

<PrecompiledHeader>

</PrecompiledHeader>

<AssemblerOutput>All</AssemblerOutput>

<AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>

<WarningLevel>Level4</WarningLevel>

<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>

<DisableSpecificWarnings>4057;4100;4127;4201;4701;4706;4131;%(DisableSpecificWarnings)</DisableSpecificWarnings>

</ClCompile>

<Link>

<AdditionalDependencies>..\Crypto\x64\Release\crypto.lib;..\Common\x64\Release\Zip.lib;..\Common\x64\Release\lzma.lib;mpr.lib;%(AdditionalDependencies)</AdditionalDependencies>

<OutputFile>$(OutDir)VeraCrypt.exe</OutputFile>

<IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>

<GenerateDebugInformation>true</GenerateDebugInformation>

<GenerateMapFile>true</GenerateMapFile>

<SubSystem>Windows</SubSystem>

<OptimizeReferences>true</OptimizeReferences>

<EnableCOMDATFolding>true</EnableCOMDATFolding>

<RandomizedBaseAddress>true</RandomizedBaseAddress>

<DataExecutionPrevention>true</DataExecutionPrevention>

<TargetMachine>MachineX64</TargetMachine>

</Link>

<Manifest>

<AdditionalManifestFiles>Mount.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>

</Manifest>

<PostBuildEvent>

<Command>copy $(TargetPath) "..\Release\Setup Files\VeraCrypt-x64.exe"</Command>

</PostBuildEvent>

<ResourceCompile>

<PreprocessorDefinitions>VC_EFI_CUSTOM_MODE;WIN64;%(PreprocessorDefinitions)</PreprocessorDefinitions>

</ResourceCompile>

</ItemDefinitionGroup>

<ItemGroup>

<ClCompile Include="..\Common\CommandAPDU.cpp" />

<ClCompile Include="..\Common\EMVCard.cpp" />

<ClCompile Include="..\Common\EMVToken.cpp" />

<ClCompile Include="..\Common\PCSCException.cpp" />

<ClCompile Include="..\Common\ResponseAPDU.cpp" />

<ClCompile Include="..\Common\SCard.cpp" />

<ClCompile Include="..\Common\SCardLoader.cpp" />

<ClCompile Include="..\Common\SCardManager.cpp" />

<ClCompile Include="..\Common\SCardReader.cpp" />

<ClCompile Include="..\Common\TLVParser.cpp" />

</ProjectConfiguration>

<ProjectConfiguration Include="ReleaseCustomEFI|x64">

<Configuration>ReleaseCustomEFI</Configuration>

<Platform>x64</Platform>

</ProjectConfiguration>

<ProjectConfiguration Include="Release|ARM64">

<Configuration>Release</Configuration>

<Platform>ARM64</Platform>

</ProjectConfiguration>

<ProjectConfiguration Include="Release|Win32">

<Configuration>Release</Configuration>

<Platform>Win32</Platform>

</ProjectConfiguration>

<ProjectConfiguration Include="Release|x64">

<Configuration>Release</Configuration>

<Platform>x64</Platform>

</ProjectConfiguration>

</ItemGroup>

<PropertyGroup Label="Globals">

<ProjectGuid>{E4C40F94-E7F9-4981-86E4-186B46F993F3}</ProjectGuid>

<RootNamespace>Mount</RootNamespace>

<Keyword>Win32Proj</Keyword>

<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>

<ProjectName>Mount</ProjectName>

</PropertyGroup>

<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">

<ConfigurationType>Application</ConfigurationType>

<CharacterSet>Unicode</CharacterSet>

<PlatformToolset>v142</PlatformToolset>

</PropertyGroup>

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseCustomEFI|Win32'" Label="Configuration">

<ConfigurationType>Application</ConfigurationType>

<CharacterSet>Unicode</CharacterSet>

<PlatformToolset>v142</PlatformToolset>

</PropertyGroup>

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">

<ConfigurationType>Application</ConfigurationType>

<CharacterSet>Unicode</CharacterSet>

<PlatformToolset>v142</PlatformToolset>

</PropertyGroup>

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">

<ConfigurationType>Application</ConfigurationType>

<CharacterSet>Unicode</CharacterSet>

<PlatformToolset>v142</PlatformToolset>

</PropertyGroup>

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="Configuration">

<ConfigurationType>Application</ConfigurationType>

<CharacterSet>Unicode</CharacterSet>

<PlatformToolset>v142</PlatformToolset>

</PropertyGroup>

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseCustomEFI|x64'" Label="Configuration">

<ConfigurationType>Application</ConfigurationType>

<CharacterSet>Unicode</CharacterSet>

<PlatformToolset>v142</PlatformToolset>

</PropertyGroup>

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseCustomEFI|ARM64'" Label="Configuration">

<ConfigurationType>Application</ConfigurationType>

<CharacterSet>Unicode</CharacterSet>

<PlatformToolset>v142</PlatformToolset>

</PropertyGroup>

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">

<ConfigurationType>Application</ConfigurationType>

<CharacterSet>Unicode</CharacterSet>

<PlatformToolset>v142</PlatformToolset>

</PropertyGroup>

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="Configuration">

<ConfigurationType>Application</ConfigurationType>

<CharacterSet>Unicode</CharacterSet>

<PlatformToolset>v142</PlatformToolset>

</PropertyGroup>

<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />

<ImportGroup Label="ExtensionSettings">

</ImportGroup>

<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">

<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

<Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />

</ImportGroup>

<ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseCustomEFI|Win32'" Label="PropertySheets">

<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

<Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />

</ImportGroup>

<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">

<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

<Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />

</ImportGroup>

<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="PropertySheets">

<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

<Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />

</ImportGroup>

<ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseCustomEFI|x64'" Label="PropertySheets">

<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

<Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />

</ImportGroup>

<ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseCustomEFI|ARM64'" Label="PropertySheets">

<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

<Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />

</ImportGroup>

<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">

<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

<Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />

</ImportGroup>

<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="PropertySheets">

<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

<Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />

</ImportGroup>

<PropertyGroup Label="UserMacros" />

<PropertyGroup>

<_ProjectFileVersion>10.0.40219.1</_ProjectFileVersion>

<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>

<GenerateManifest Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</GenerateManifest>

<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</LinkIncremental>

<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">true</LinkIncremental>

<GenerateManifest Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</GenerateManifest>

<GenerateManifest Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">true</GenerateManifest>

<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>

<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='ReleaseCustomEFI|Win32'">false</LinkIncremental>

<GenerateManifest Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</GenerateManifest>

<GenerateManifest Condition="'$(Configuration)|$(Platform)'=='ReleaseCustomEFI|Win32'">true</GenerateManifest>

<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</LinkIncremental>

<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">false</LinkIncremental>

<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='ReleaseCustomEFI|x64'">false</LinkIncremental>

<LinkIncremental Condition="'$(Configuration)|$(Platform)'=='ReleaseCustomEFI|ARM64'">false</LinkIncremental>

<GenerateManifest Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</GenerateManifest>

<GenerateManifest Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">true</GenerateManifest>

<GenerateManifest Condition="'$(Configuration)|$(Platform)'=='ReleaseCustomEFI|x64'">true</GenerateManifest>

<GenerateManifest Condition="'$(Configuration)|$(Platform)'=='ReleaseCustomEFI|ARM64'">true</GenerateManifest>

<TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">VeraCrypt</TargetName>

<TargetName Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">VeraCrypt</TargetName>

<TargetName Condition="'$(Configuration)|$(Platform)'=='ReleaseCustomEFI|Win32'">VeraCrypt</TargetName>

<TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">VeraCrypt</TargetName>

<TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">VeraCrypt</TargetName>

<TargetName Condition="'$(Configuration)|$(Platform)'=='Release|x64'">VeraCrypt</TargetName>

<TargetName Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">VeraCrypt</TargetName>

<TargetName Condition="'$(Configuration)|$(Platform)'=='ReleaseCustomEFI|x64'">VeraCrypt</TargetName>

<TargetName Condition="'$(Configuration)|$(Platform)'=='ReleaseCustomEFI|ARM64'">VeraCrypt</TargetName>

</PropertyGroup>

<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

<Midl>

<AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<TypeLibraryName>$(SolutionDir)/$(ProjectName)/$(ProjectName).tlb</TypeLibraryName>

<OutputDirectory>

</OutputDirectory>

</Midl>

<ClCompile>

<Optimization>Disabled</Optimization>

<AdditionalIncludeDirectories>..\Common;..\Crypto;..\;..\PKCS11;..\Common\zlib;..\Common\libzip;..\Common\lzma;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<PreprocessorDefinitions>TCMOUNT;WIN32;HAVE_CONFIG_H;ZIP_STATIC;DEBUG;_DEBUG;_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NON_CONFORMING_SWPRINTFS;%(PreprocessorDefinitions)</PreprocessorDefinitions>

<MinimalRebuild>true</MinimalRebuild>

<ExceptionHandling>Sync</ExceptionHandling>

<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>

<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>

<BufferSecurityCheck>true</BufferSecurityCheck>

<PrecompiledHeader>

</PrecompiledHeader>

<BrowseInformation>

</BrowseInformation>

<BrowseInformationFile>

</BrowseInformationFile>

<WarningLevel>Level4</WarningLevel>

<DebugInformationFormat>EditAndContinue</DebugInformationFormat>

<DisableSpecificWarnings>4057;4100;4127;4201;4701;4706;4131;%(DisableSpecificWarnings)</DisableSpecificWarnings>

</ClCompile>

<Link>

<AdditionalDependencies>..\Crypto\Debug\crypto.lib;..\Common\Debug\Zip.lib;mpr.lib;%(AdditionalDependencies)</AdditionalDependencies>

<OutputFile>$(OutDir)VeraCrypt.exe</OutputFile>

<IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>

<GenerateDebugInformation>true</GenerateDebugInformation>

<ProgramDatabaseFile>$(OutDir)Mount.pdb</ProgramDatabaseFile>

<SubSystem>Windows</SubSystem>

<RandomizedBaseAddress>false</RandomizedBaseAddress>

<DataExecutionPrevention>true</DataExecutionPrevention>

<TargetMachine>MachineX86</TargetMachine>

</Link>

<Manifest>

<AdditionalManifestFiles>Mount.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>

</Manifest>

<PostBuildEvent>

<Command>md "..\Debug\Setup Files" 2&gt;NUL:

copy Debug\VeraCrypt.exe "..\Debug\Setup Files" &gt;NUL:

</Command>

</PostBuildEvent>

</ItemDefinitionGroup>

<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">

<Midl>

<AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<TargetEnvironment>X64</TargetEnvironment>

<TypeLibraryName>$(SolutionDir)/$(ProjectName)/$(ProjectName).tlb</TypeLibraryName>

<OutputDirectory>

</OutputDirectory>

</Midl>

<ClCompile>

<Optimization>Disabled</Optimization>

<AdditionalIncludeDirectories>..\Common;..\Crypto;..\;..\PKCS11;..\Common\zlib;..\Common\libzip;..\Common\lzma;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<PreprocessorDefinitions>TCMOUNT;WIN32;HAVE_CONFIG_H;ZIP_STATIC;DEBUG;_DEBUG;_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NON_CONFORMING_SWPRINTFS;%(PreprocessorDefinitions)</PreprocessorDefinitions>

<MinimalRebuild>true</MinimalRebuild>

<ExceptionHandling>Sync</ExceptionHandling>

<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>

<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>

<BufferSecurityCheck>true</BufferSecurityCheck>

<PrecompiledHeader>

</PrecompiledHeader>

<BrowseInformation>

</BrowseInformation>

<BrowseInformationFile>

</BrowseInformationFile>

<WarningLevel>Level4</WarningLevel>

<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>

<DisableSpecificWarnings>4057;4100;4127;4201;4701;4706;4131;%(DisableSpecificWarnings)</DisableSpecificWarnings>

</ClCompile>

<Link>

<AdditionalDependencies>..\Crypto\x64\Debug\crypto.lib;..\Common\x64\Debug\Zip.lib;mpr.lib;%(AdditionalDependencies)</AdditionalDependencies>

<OutputFile>$(OutDir)VeraCrypt.exe</OutputFile>

<IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>

<GenerateDebugInformation>true</GenerateDebugInformation>

<ProgramDatabaseFile>$(OutDir)Mount.pdb</ProgramDatabaseFile>

<SubSystem>Windows</SubSystem>

<RandomizedBaseAddress>false</RandomizedBaseAddress>

<DataExecutionPrevention>true</DataExecutionPrevention>

<TargetMachine>MachineX64</TargetMachine>

</Link>

<Manifest>

<AdditionalManifestFiles>Mount.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>

</Manifest>

<PostBuildEvent>

<Command>md "..\Debug\Setup Files" 2&gt;NUL:

copy $(TargetPath) "..\Debug\Setup Files\VeraCrypt-x64.exe" &gt;NUL:

</Command>

</PostBuildEvent>

<ResourceCompile>

<PreprocessorDefinitions>WIN64;%(PreprocessorDefinitions)</PreprocessorDefinitions>

</ResourceCompile>

</ItemDefinitionGroup>

<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">

<Midl>

<AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<TypeLibraryName>$(SolutionDir)/$(ProjectName)/$(ProjectName).tlb</TypeLibraryName>

<OutputDirectory>

</OutputDirectory>

</Midl>

<ClCompile>

<Optimization>Disabled</Optimization>

<AdditionalIncludeDirectories>..\Common;..\Crypto;..\;..\PKCS11;..\Common\zlib;..\Common\libzip;..\Common\lzma;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<PreprocessorDefinitions>TCMOUNT;WIN32;HAVE_CONFIG_H;ZIP_STATIC;DEBUG;_DEBUG;_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NON_CONFORMING_SWPRINTFS;%(PreprocessorDefinitions)</PreprocessorDefinitions>

<MinimalRebuild>true</MinimalRebuild>

<ExceptionHandling>Sync</ExceptionHandling>

<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>

<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>

<BufferSecurityCheck>true</BufferSecurityCheck>

<PrecompiledHeader>

</PrecompiledHeader>

<BrowseInformation>

</BrowseInformation>

<BrowseInformationFile>

</BrowseInformationFile>

<WarningLevel>Level4</WarningLevel>

<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>

<DisableSpecificWarnings>4057;4100;4127;4201;4701;4706;4131;%(DisableSpecificWarnings)</DisableSpecificWarnings>

</ClCompile>

<Link>

<AdditionalDependencies>..\Crypto\ARM64\Debug\crypto.lib;..\Common\ARM64\Debug\Zip.lib;mpr.lib;%(AdditionalDependencies)</AdditionalDependencies>

<OutputFile>$(OutDir)VeraCrypt.exe</OutputFile>

<IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>

<GenerateDebugInformation>true</GenerateDebugInformation>

<ProgramDatabaseFile>$(OutDir)Mount.pdb</ProgramDatabaseFile>

<SubSystem>Windows</SubSystem>

<DataExecutionPrevention>true</DataExecutionPrevention>

</Link>

<Manifest>

<AdditionalManifestFiles>Mount.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>

</Manifest>

<PostBuildEvent>

<Command>md "..\Debug\Setup Files" 2&gt;NUL:

copy $(TargetPath) "..\Debug\Setup Files\VeraCrypt-arm64.exe" &gt;NUL:

</Command>

</PostBuildEvent>

<ResourceCompile>

<PreprocessorDefinitions>WIN64;ARM64;%(PreprocessorDefinitions)</PreprocessorDefinitions>

</ResourceCompile>

</ItemDefinitionGroup>

<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

<Midl>

<AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<TypeLibraryName>$(SolutionDir)/$(ProjectName)/$(ProjectName).tlb</TypeLibraryName>

<OutputDirectory>

</OutputDirectory>

</Midl>

<ClCompile>

<AdditionalOptions>/w34189 %(AdditionalOptions)</AdditionalOptions>

<Optimization>MaxSpeed</Optimization>

<AdditionalIncludeDirectories>..\Common;..\Crypto;..\;..\PKCS11;..\Common\zlib;..\Common\libzip;..\Common\lzma;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<PreprocessorDefinitions>TCMOUNT;WIN32;HAVE_CONFIG_H;ZIP_STATIC;NDEBUG;_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NON_CONFORMING_SWPRINTFS;%(PreprocessorDefinitions)</PreprocessorDefinitions>

<RuntimeLibrary>MultiThreaded</RuntimeLibrary>

<BufferSecurityCheck>true</BufferSecurityCheck>

<PrecompiledHeader>

</PrecompiledHeader>

<AssemblerOutput>All</AssemblerOutput>

<AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>

<WarningLevel>Level4</WarningLevel>

<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>

<DisableSpecificWarnings>4057;4100;4127;4201;4701;4706;4131;%(DisableSpecificWarnings)</DisableSpecificWarnings>

</ClCompile>

<Link>

<AdditionalDependencies>..\Crypto\Release\crypto.lib;..\Common\Release\Zip.lib;mpr.lib;%(AdditionalDependencies)</AdditionalDependencies>

<OutputFile>$(OutDir)VeraCrypt.exe</OutputFile>

<IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>

<GenerateDebugInformation>true</GenerateDebugInformation>

<GenerateMapFile>true</GenerateMapFile>

<SubSystem>Windows</SubSystem>

<OptimizeReferences>true</OptimizeReferences>

<EnableCOMDATFolding>true</EnableCOMDATFolding>

<RandomizedBaseAddress>true</RandomizedBaseAddress>

<DataExecutionPrevention>true</DataExecutionPrevention>

<TargetMachine>MachineX86</TargetMachine>

</Link>

<Manifest>

<AdditionalManifestFiles>Mount.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>

</Manifest>

<PostBuildEvent>

<Command>copy Release\VeraCrypt.exe "..\Release\Setup Files"</Command>

</PostBuildEvent>

</ItemDefinitionGroup>

<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseCustomEFI|Win32'">

<Midl>

<AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<TypeLibraryName>$(SolutionDir)/$(ProjectName)/$(ProjectName).tlb</TypeLibraryName>

<OutputDirectory>

</OutputDirectory>

</Midl>

<ClCompile>

<AdditionalOptions>/w34189 %(AdditionalOptions)</AdditionalOptions>

<Optimization>MaxSpeed</Optimization>

<AdditionalIncludeDirectories>..\Common;..\Crypto;..\;..\PKCS11;..\Common\zlib;..\Common\libzip;..\Common\lzma;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<PreprocessorDefinitions>TCMOUNT;VC_EFI_CUSTOM_MODE;WIN32;HAVE_CONFIG_H;ZIP_STATIC;NDEBUG;_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NON_CONFORMING_SWPRINTFS;%(PreprocessorDefinitions)</PreprocessorDefinitions>

<RuntimeLibrary>MultiThreaded</RuntimeLibrary>

<BufferSecurityCheck>true</BufferSecurityCheck>

<PrecompiledHeader>

</PrecompiledHeader>

<AssemblerOutput>All</AssemblerOutput>

<AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>

<WarningLevel>Level4</WarningLevel>

<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>

<DisableSpecificWarnings>4057;4100;4127;4201;4701;4706;4131;%(DisableSpecificWarnings)</DisableSpecificWarnings>

</ClCompile>

<Link>

<AdditionalDependencies>..\Crypto\Release\crypto.lib;..\Common\Release\Zip.lib;mpr.lib;%(AdditionalDependencies)</AdditionalDependencies>

<OutputFile>$(OutDir)VeraCrypt.exe</OutputFile>

<IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>

<GenerateDebugInformation>true</GenerateDebugInformation>

<GenerateMapFile>true</GenerateMapFile>

<SubSystem>Windows</SubSystem>

<OptimizeReferences>true</OptimizeReferences>

<EnableCOMDATFolding>true</EnableCOMDATFolding>

<RandomizedBaseAddress>true</RandomizedBaseAddress>

<DataExecutionPrevention>true</DataExecutionPrevention>

<TargetMachine>MachineX86</TargetMachine>

</Link>

<Manifest>

<AdditionalManifestFiles>Mount.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>

</Manifest>

<PostBuildEvent>

<Command>copy Release\VeraCrypt.exe "..\Release\Setup Files"</Command>

</PostBuildEvent>

<ResourceCompile>

<PreprocessorDefinitions>VC_EFI_CUSTOM_MODE;%(PreprocessorDefinitions)</PreprocessorDefinitions>

</ResourceCompile>

</ItemDefinitionGroup>

<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">

<Midl>

<AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<TargetEnvironment>X64</TargetEnvironment>

<TypeLibraryName>$(SolutionDir)/$(ProjectName)/$(ProjectName).tlb</TypeLibraryName>

<OutputDirectory>

</OutputDirectory>

</Midl>

<ClCompile>

<AdditionalOptions>/w34189 %(AdditionalOptions)</AdditionalOptions>

<Optimization>MaxSpeed</Optimization>

<AdditionalIncludeDirectories>..\Common;..\Crypto;..\;..\PKCS11;..\Common\zlib;..\Common\libzip;..\Common\lzma;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<PreprocessorDefinitions>TCMOUNT;WIN32;HAVE_CONFIG_H;ZIP_STATIC;NDEBUG;_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NON_CONFORMING_SWPRINTFS;%(PreprocessorDefinitions)</PreprocessorDefinitions>

<RuntimeLibrary>MultiThreaded</RuntimeLibrary>

<BufferSecurityCheck>true</BufferSecurityCheck>

<PrecompiledHeader>

</PrecompiledHeader>

<AssemblerOutput>All</AssemblerOutput>

<AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>

<WarningLevel>Level4</WarningLevel>

<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>

<DisableSpecificWarnings>4057;4100;4127;4201;4701;4706;4131;%(DisableSpecificWarnings)</DisableSpecificWarnings>

</ClCompile>

<Link>

<AdditionalDependencies>..\Crypto\x64\Release\crypto.lib;..\Common\x64\Release\Zip.lib;mpr.lib;%(AdditionalDependencies)</AdditionalDependencies>

<OutputFile>$(OutDir)VeraCrypt.exe</OutputFile>

<IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>

<GenerateDebugInformation>true</GenerateDebugInformation>

<GenerateMapFile>true</GenerateMapFile>

<SubSystem>Windows</SubSystem>

<OptimizeReferences>true</OptimizeReferences>

<EnableCOMDATFolding>true</EnableCOMDATFolding>

<RandomizedBaseAddress>true</RandomizedBaseAddress>

<DataExecutionPrevention>true</DataExecutionPrevention>

<TargetMachine>MachineX64</TargetMachine>

</Link>

<Manifest>

<AdditionalManifestFiles>Mount.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>

</Manifest>

<PostBuildEvent>

<Command>copy $(TargetPath) "..\Release\Setup Files\VeraCrypt-x64.exe"</Command>

</PostBuildEvent>

<ResourceCompile>

<PreprocessorDefinitions>WIN64;%(PreprocessorDefinitions)</PreprocessorDefinitions>

</ResourceCompile>

</ItemDefinitionGroup>

<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">

<Midl>

<AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<TypeLibraryName>$(SolutionDir)/$(ProjectName)/$(ProjectName).tlb</TypeLibraryName>

<OutputDirectory>

</OutputDirectory>

</Midl>

<ClCompile>

<AdditionalOptions>/w34189 %(AdditionalOptions)</AdditionalOptions>

<Optimization>MaxSpeed</Optimization>

<AdditionalIncludeDirectories>..\Common;..\Crypto;..\;..\PKCS11;..\Common\zlib;..\Common\libzip;..\Common\lzma;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<PreprocessorDefinitions>TCMOUNT;WIN32;HAVE_CONFIG_H;ZIP_STATIC;NDEBUG;_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NON_CONFORMING_SWPRINTFS;%(PreprocessorDefinitions)</PreprocessorDefinitions>

<RuntimeLibrary>MultiThreaded</RuntimeLibrary>

<BufferSecurityCheck>true</BufferSecurityCheck>

<PrecompiledHeader>

</PrecompiledHeader>

<AssemblerOutput>All</AssemblerOutput>

<AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>

<WarningLevel>Level4</WarningLevel>

<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>

<DisableSpecificWarnings>4057;4100;4127;4201;4701;4706;4131;%(DisableSpecificWarnings)</DisableSpecificWarnings>

</ClCompile>

<Link>

<AdditionalDependencies>..\Crypto\ARM64\Release\crypto.lib;..\Common\ARM64\Release\Zip.lib;mpr.lib;%(AdditionalDependencies)</AdditionalDependencies>

<OutputFile>$(OutDir)VeraCrypt.exe</OutputFile>

<IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>

<GenerateDebugInformation>true</GenerateDebugInformation>

<GenerateMapFile>true</GenerateMapFile>

<SubSystem>Windows</SubSystem>

<OptimizeReferences>true</OptimizeReferences>

<EnableCOMDATFolding>true</EnableCOMDATFolding>

<RandomizedBaseAddress>true</RandomizedBaseAddress>

<DataExecutionPrevention>true</DataExecutionPrevention>

</Link>

<Manifest>

<AdditionalManifestFiles>Mount.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>

</Manifest>

<PostBuildEvent>

<Command>copy $(TargetPath) "..\Release\Setup Files\VeraCrypt-arm64.exe"</Command>

</PostBuildEvent>

<ResourceCompile>

<PreprocessorDefinitions>WIN64;ARM64;%(PreprocessorDefinitions)</PreprocessorDefinitions>

</ResourceCompile>

</ItemDefinitionGroup>

<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseCustomEFI|x64'">

<Midl>

<AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<TargetEnvironment>X64</TargetEnvironment>

<TypeLibraryName>$(SolutionDir)/$(ProjectName)/$(ProjectName).tlb</TypeLibraryName>

<OutputDirectory>

</OutputDirectory>

</Midl>

<ClCompile>

<AdditionalOptions>/w34189 %(AdditionalOptions)</AdditionalOptions>

<Optimization>MaxSpeed</Optimization>

<AdditionalIncludeDirectories>..\Common;..\Crypto;..\;..\PKCS11;..\Common\zlib;..\Common\libzip;..\Common\lzma;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<PreprocessorDefinitions>TCMOUNT;VC_EFI_CUSTOM_MODE;WIN32;HAVE_CONFIG_H;ZIP_STATIC;NDEBUG;_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NON_CONFORMING_SWPRINTFS;%(PreprocessorDefinitions)</PreprocessorDefinitions>

<RuntimeLibrary>MultiThreaded</RuntimeLibrary>

<BufferSecurityCheck>true</BufferSecurityCheck>

<PrecompiledHeader>

</PrecompiledHeader>

<AssemblerOutput>All</AssemblerOutput>

<AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>

<WarningLevel>Level4</WarningLevel>

<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>

<DisableSpecificWarnings>4057;4100;4127;4201;4701;4706;4131;%(DisableSpecificWarnings)</DisableSpecificWarnings>

</ClCompile>

<Link>

<AdditionalDependencies>..\Crypto\x64\Release\crypto.lib;..\Common\x64\Release\Zip.lib;mpr.lib;%(AdditionalDependencies)</AdditionalDependencies>

<OutputFile>$(OutDir)VeraCrypt.exe</OutputFile>

<IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>

<GenerateDebugInformation>true</GenerateDebugInformation>

<GenerateMapFile>true</GenerateMapFile>

<SubSystem>Windows</SubSystem>

<OptimizeReferences>true</OptimizeReferences>

<EnableCOMDATFolding>true</EnableCOMDATFolding>

<RandomizedBaseAddress>true</RandomizedBaseAddress>

<DataExecutionPrevention>true</DataExecutionPrevention>

<TargetMachine>MachineX64</TargetMachine>

</Link>

<Manifest>

<AdditionalManifestFiles>Mount.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>

</Manifest>

<PostBuildEvent>

<Command>copy $(TargetPath) "..\Release\Setup Files\VeraCrypt-x64.exe"</Command>

</PostBuildEvent>

<ResourceCompile>

<PreprocessorDefinitions>VC_EFI_CUSTOM_MODE;WIN64;%(PreprocessorDefinitions)</PreprocessorDefinitions>

</ResourceCompile>

</ItemDefinitionGroup>

<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseCustomEFI|ARM64'">

<Midl>

<AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<TypeLibraryName>$(SolutionDir)/$(ProjectName)/$(ProjectName).tlb</TypeLibraryName>

<OutputDirectory>

</OutputDirectory>

</Midl>

<ClCompile>

<AdditionalOptions>/w34189 %(AdditionalOptions)</AdditionalOptions>

<Optimization>MaxSpeed</Optimization>

<AdditionalIncludeDirectories>..\Common;..\Crypto;..\;..\PKCS11;..\Common\zlib;..\Common\libzip;..\Common\lzma;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

<PreprocessorDefinitions>TCMOUNT;VC_EFI_CUSTOM_MODE;WIN32;HAVE_CONFIG_H;ZIP_STATIC;NDEBUG;_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NON_CONFORMING_SWPRINTFS;%(PreprocessorDefinitions)</PreprocessorDefinitions>

<RuntimeLibrary>MultiThreaded</RuntimeLibrary>

<BufferSecurityCheck>true</BufferSecurityCheck>

<PrecompiledHeader>

</PrecompiledHeader>

<AssemblerOutput>All</AssemblerOutput>

<AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>

<WarningLevel>Level4</WarningLevel>

<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>

<DisableSpecificWarnings>4057;4100;4127;4201;4701;4706;4131;%(DisableSpecificWarnings)</DisableSpecificWarnings>

</ClCompile>

<Link>

<AdditionalDependencies>..\Crypto\x64\Release\crypto.lib;..\Common\x64\Release\Zip.lib;mpr.lib;%(AdditionalDependencies)</AdditionalDependencies>

<OutputFile>$(OutDir)VeraCrypt.exe</OutputFile>

<IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>

<GenerateDebugInformation>true</GenerateDebugInformation>

<GenerateMapFile>true</GenerateMapFile>

<SubSystem>Windows</SubSystem>

<OptimizeReferences>true</OptimizeReferences>

<EnableCOMDATFolding>true</EnableCOMDATFolding>

<RandomizedBaseAddress>true</RandomizedBaseAddress>

<DataExecutionPrevention>true</DataExecutionPrevention>

</Link>

<Manifest>

<AdditionalManifestFiles>Mount.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>

</Manifest>

<PostBuildEvent>

<Command>copy $(TargetPath) "..\Release\Setup Files\VeraCrypt-arm64.exe"</Command>

</PostBuildEvent>

<ResourceCompile>

<PreprocessorDefinitions>VC_EFI_CUSTOM_MODE;WIN64;ARM64;%(PreprocessorDefinitions)</PreprocessorDefinitions>

</ResourceCompile>

</ItemDefinitionGroup>

<ItemGroup>

<ClCompile Include="..\Common\CommandAPDU.cpp" />

<ClCompile Include="..\Common\EMVCard.cpp" />

<ClCompile Include="..\Common\EMVToken.cpp" />

<ClCompile Include="..\Common\PCSCException.cpp" />

<ClCompile Include="..\Common\ResponseAPDU.cpp" />

<ClCompile Include="..\Common\SCard.cpp" />

<ClCompile Include="..\Common\SCardLoader.cpp" />

<ClCompile Include="..\Common\SCardManager.cpp" />

<ClCompile Include="..\Common\SCardReader.cpp" />

<ClCompile Include="..\Common\TLVParser.cpp" />

<ClCompile Include="..\Common\Token.cpp" />

#define IDT_DRIVER_OPTIONS 1149

#define IDC_ENABLE_EXTENDED_IOCTL_SUPPORT 1150

#define IDC_DISABLE_EVIL_MAID_ATTACK_DETECTION 1151

#define IDC_WIPE_MODE 1152

#define IDT_WIPE_MODE 1153

#define IDC_PREF_CACHE_PIM 1154

#define IDC_BOOT_LOADER_CACHE_PIM 1155

#define IDC_SHOW_DISCONNECTED_NETWORK_DRIVES 1156

#define IDT_VOLUME_ID 1157

#define IDC_FAVORITE_VOLUME_ID 1158

#define IDC_FAVORITE_USE_VOLUME_ID 1159

#define IDC_DISABLE_BOOT_LOADER_PIM_PROMPT 1160

#define IDC_HIDE_WAITING_DIALOG 1161

#define IDC_DISABLE_BOOT_LOADER_HASH_PROMPT 1162

#define IDC_SECURE_DESKTOP_PASSWORD_ENTRY 1163

#define IDC_SHOW_PLATFORMINFO 1164

#define IDC_EDIT_DCSPROP 1165

#define IDT_ADVANCED_OPTIONS 1166

#define IDC_ALLOW_TRIM_NONSYS_SSD 1167

#define IDC_BLOCK_SYSENC_TRIM 1168

#define IDC_ALLOW_WINDOWS_DEFRAG 1169

#define IDC_LOWER_BOX 1170

#define IDC_CLEAR_KEYS_ON_NEW_DEVICE_INSERTION 1171

#define IDC_ENABLE_CPU_RNG 1172

#define IDC_ENABLE_RAM_ENCRYPTION 1173

#define IDC_USE_LEGACY_MAX_PASSWORD_LENGTH 1174

#define IDC_UPDATE_BOOTLOADER_ON_SHUTDOWN 1175

#define IDC_FORCE_NEXT_BOOT_VERACRYPT 1176

#define IDC_FORCE_VERACRYPT_BOOT_ENTRY 1177

#define IDC_FORCE_VERACRYPT_FIRST_BOOT_ENTRY 1178

#define IDM_HELP 40001

#define IDM_ABOUT 40002

#define IDM_UNMOUNT_VOLUME 40003

#define IDM_CLEAR_HISTORY 40004

#define IDM_BENCHMARK 40005

#define IDM_TRAVELER 40006

#define IDM_MOUNT_VOLUME_OPTIONS 40007

#define IDM_FAQ 40008

#define IDM_REFRESH_DRIVE_LETTERS 40009

#define IDM_DEFAULT_KEYFILES 40010

#define IDM_WEBSITE 40011

#define IDM_MOUNTALL 40012

#define IDM_UNMOUNTALL 40013

#define IDM_MOUNT_VOLUME 40014

#define IDM_CHANGE_PASSWORD 40015

#define IDM_VOLUME_WIZARD 40016

#define IDM_CREATE_VOLUME 40017

#define IDM_WIPE_CACHE 40018

#define IDM_PREFERENCES 40019

#define IDM_LICENSE 40020

#define IDM_SELECT_FILE 40021

#define IDM_SELECT_DEVICE 40022

#define IDM_VOLUME_PROPERTIES 40023

#define IDM_LANGUAGE 40024

#define IDM_MOUNT_FAVORITE_VOLUMES 40025

#define IDM_BACKUP_VOL_HEADER 40026

#define IDM_RESTORE_VOL_HEADER 40027

#define IDM_HOTKEY_SETTINGS 40028

#define IDM_TC_DOWNLOADS 40029

#define IDM_NEWS 40030

#define IDM_SYSENC_RESUME 40048

#define IDM_MOUNT_SYSENC_PART_WITHOUT_PBA 40049

#define IDM_CREATE_HIDDEN_OS 40050

#define IDM_TOKEN_PREFERENCES 40051

#define IDM_CLOSE_ALL_TOKEN_SESSIONS 40052

#define IDM_SYS_ENC_SETTINGS 40053

#define IDM_SYSENC_SETTINGS 40054

#define IDM_RESUME_INTERRUPTED_PROC 40055

#define IDM_MANAGE_TOKEN_KEYFILES 40056

#define IDM_SYS_FAVORITES_SETTINGS 40057

#define IDM_ORGANIZE_FAVORITES 40058

#define IDM_ORGANIZE_SYSTEM_FAVORITES 40059

#define IDM_ADD_VOLUME_TO_FAVORITES 40060

#define IDM_ADD_VOLUME_TO_SYSTEM_FAVORITES 40061

#define IDM_PERFORMANCE_SETTINGS 40062

#define IDM_ANALYZE_SYSTEM_CRASH 40063

#define IDM_DONATE 40064

#define IDM_VOLUME_EXPANDER 40065

#define IDM_DEFAULT_MOUNT_PARAMETERS 40066

#define IDM_DECRYPT_NONSYS_VOL 40067

#define IDM_VERIFY_RESCUE_DISK_ISO 40068

#define IDM_MOUNIT_NO_CACHE 40069

// Next default values for new objects

//

#ifdef APSTUDIO_INVOKED

#ifndef APSTUDIO_READONLY_SYMBOLS

#define _APS_NO_MFC 1

#define _APS_NEXT_RESOURCE_VALUE 120

#define _APS_NEXT_COMMAND_VALUE 40070

#define _APS_NEXT_SYMED_VALUE 101

#endif

#endif