governed by the TrueCrypt License 3.0, also from the source code of

Encryption for the Masses 2.02a, which is Copyright (c) 1998-2000 Paul Le Roux

and which is governed by the 'License Agreement for Encryption for the Masses'

Modifications and additions to the original source code (contained in this file)

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

code distribution packages. */

#include "Tcdefs.h"

#include <windowsx.h>

#include <dbghelp.h>

#include <dbt.h>

#include <Setupapi.h>

#include <fcntl.h>

#include <io.h>

#include <math.h>

#include <shlobj.h>

#include <sys/stat.h>

#include <stdlib.h>

#include <time.h>

#include <tchar.h>

#include <Richedit.h>

#include <process.h>

#include <Tlhelp32.h>

#endif

#include "Resource.h"

#include "Platform/Finally.h"

#include "Xml.h"

#include "Xts.h"

#include "Boot/Windows/BootCommon.h"

#include "Progress.h"

#ifdef TCMOUNT

#include "Mount/Mount.h"

#include "Mount/resource.h"

#ifdef SETUP

#include "Setup/Setup.h"

#endif

#include <strsafe.h>

using namespace VeraCrypt;

LONG DriverVersion;

BOOL bHideWaitingDialog = FALSE;

BOOL bCmdHideWaitingDialog = FALSE;

BOOL bCmdHideWaitingDialogValid = FALSE;

BOOL bUseSecureDesktop = FALSE;

BOOL bCmdUseSecureDesktop = FALSE;

BOOL bCmdUseSecureDesktopValid = FALSE;

BOOL bStartOnLogon = FALSE;

BOOL bMountDevicesOnLogon = FALSE;

BOOL bMountFavoritesOnLogon = FALSE;

BOOL bHistory = FALSE;

// Status of detection of hidden sectors (whole-system-drive encryption).

// 0 - Unknown/undetermined/completed, 1: Detection is or was in progress (but did not complete e.g. due to system crash).

int HiddenSectorDetectionStatus = 0;

OSVersionEnum nCurrentOS = WIN_UNKNOWN;

int CurrentOSMajor = 0;

int CurrentOSMinor = 0;

int CurrentOSServicePack = 0;

BOOL RemoteSession = FALSE;

BOOL UacElevated = FALSE;

BOOL bPortableModeConfirmed = FALSE; // TRUE if it is certain that the instance is running in portable mode

/* Globals used by Mount and Format (separately per instance) */

BOOL PimEnable = FALSE;

BOOL KeyFilesEnable = FALSE;

KeyFile *FirstKeyFile = NULL;

BOOL IgnoreWmDeviceChange = FALSE;

BOOL DeviceChangeBroadcastDisabled = FALSE;

BOOL LastMountedVolumeDirty;

BOOL MountVolumesAsSystemFavorite = FALSE;

BOOL FavoriteMountOnArrivalInProgress = FALSE;

BOOL MultipleMountOperationInProgress = FALSE;

BOOL WaitDialogDisplaying = FALSE;

/* Handle to the device driver */

/* Critical section used to protect access to global variables used in WNetGetConnection calls */

CRITICAL_SECTION csWNetCalls;

HINSTANCE hInst = NULL;

HCURSOR hCursor = NULL;

ATOM hDlgClass, hSplashClass;

#define RANDPOOL_DISPLAY_REFRESH_INTERVAL 30

#define RANDPOOL_DISPLAY_ROWS 16

#define RANDPOOL_DISPLAY_COLUMNS 20

#ifndef LOAD_LIBRARY_SEARCH_SYSTEM32

#define LOAD_LIBRARY_SEARCH_SYSTEM32 0x00000800

#endif

typedef BOOL (WINAPI *SetDefaultDllDirectoriesPtr)(DWORD DirectoryFlags);

/* Windows dialog class */

#define WINDOWS_DIALOG_CLASS L"#32770"

} MULTI_CHOICE_DLGPROC_PARAMS;

void cleanup ()

{

burn (&CmdTokenPin, sizeof (CmdTokenPin));

/* Cleanup the GDI fonts */

if (hFixedFont != NULL)

DeleteObject (hFixedFont);

EncryptionThreadPoolStop();

#endif

}

void LowerCaseCopy (wchar_t *lpszDest, const wchar_t *lpszSource)

}

void UpperCaseCopy (wchar_t *lpszDest, size_t cbDest, const wchar_t *lpszSource)

{

{

size_t i = wcslen (lpszSource);

lpszDest[i] = 0;

i++;

while (--i > 0)

return out_size;

}

// check the validity of a file name

BOOL IsValidFileName(const wchar_t* str)

{

static wchar_t invalidChars[9] = {L'<', L'>', L':', L'"', L'/', L'\\', L'|', L'?', L'*'};

return 0;

}

BOOL IsDiskReadError (DWORD error)

{

return (error == ERROR_CRC

|| error == ERROR_IO_DEVICE

{

return IsDiskReadError (error) || IsDiskWriteError (error);

}

BOOL translateWin32Error (wchar_t *lpszMsgBuf, int nWSizeOfBuf)

{

DWORD dwError = GetLastError ();

InvalidateRect (hwndCtrl, NULL, TRUE);

}

}

// Note that the user can still close the window by right-clicking its taskbar icon and selecting 'Close window', or by pressing Alt-F4, or using the Task Manager.

void DisableCloseButton (HWND hwndDlg)

{

EnableMenuItem (GetSystemMenu (hwndDlg, FALSE), SC_CLOSE, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);

{

EnableMenuItem (GetSystemMenu (hwndDlg, FALSE), SC_CLOSE, MF_BYCOMMAND | MF_ENABLED);

}

// Protects an input field from having its content updated by a Paste action (call ToBootPwdField() to use this).

static LRESULT CALLBACK BootPwdFieldProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

{

WNDPROC wp = (WNDPROC) GetWindowLongPtrW (hwnd, GWLP_USERDATA);

switch (message)

{

case WM_PASTE:

return 1;

}

return CallWindowProcW (wp, hwnd, message, wParam, lParam);

}

// user from pasting a password typed using a non-US keyboard layout).

void ToBootPwdField (HWND hwndDlg, UINT ctrlId)

{

HWND hwndCtrl = GetDlgItem (hwndDlg, ctrlId);

SetWindowLongPtrW (hwndCtrl, GWLP_WNDPROC, (LONG_PTR) BootPwdFieldProc);

}

// This function currently serves the following purposes:

// - Determines scaling factors for current screen DPI and GUI aspect ratio.

}

// Version

SendMessage (GetDlgItem (hwndDlg, IDT_ABOUT_VERSION), WM_SETFONT, (WPARAM) hUserBoldFont, 0);

#if (defined(_DEBUG) || defined(DEBUG))

StringCbCatW (szTmp, sizeof(szTmp), L" (debug)");

#endif

SetDlgItemText (hwndDlg, IDT_ABOUT_VERSION, szTmp);

SetWindowText (GetDlgItem (hwndDlg, IDC_ABOUT_CREDITS),

L"Based on TrueCrypt 7.1a, freely available at http://www.truecrypt.org/ .\r\n\r\n"

L"Portions of this software:\r\n"

L"Copyright \xA9 2003-2012 TrueCrypt Developers Association. All Rights Reserved.\r\n"

L"Copyright \xA9 1998-2000 Paul Le Roux. All Rights Reserved.\r\n"

L"Copyright \xA9 1998-2008 Brian Gladman. All Rights Reserved.\r\n"

L"Copyright \xA9 2016 Disk Cryptography Services for EFI (DCS), Alex Kolotnikov.\r\n"

L"Copyright \xA9 2013, Alexey Degtyarev. All rights reserved.\r\n"

L"This software as a whole:\r\n"

L"An IDRIX Release");

return 1;

}

if (lw == IDC_HOMEPAGE)

{

return 1;

}

// Disallow modification of credits

return 0;

}

static HWND StaticModelessWaitDlgHandle = NULL;

// Call DisplayStaticModelessWaitDlg() to open this dialog and CloseStaticModelessWaitDlg() to close it.

if (font && wcscmp (font->FaceName, L"default") != 0)

{

StringCbCopyW ((WCHAR *)metric.lfMessageFont.lfFaceName, sizeof (metric.lfMessageFont.lfFaceName), font->FaceName);

}

{

// Vista's new default font (size and spacing) breaks compatibility with Windows 2k/XP applications.

// Force use of Tahoma (as Microsoft does in many dialogs) until a native Vista look is implemented.

StringCbCopyW ((WCHAR *)metric.lfMessageFont.lfFaceName, sizeof (metric.lfMessageFont.lfFaceName), L"Tahoma");

void

WaitCursor ()

{

if (hcWait == NULL)

hcWait = LoadCursor (NULL, IDC_WAIT);

if ((g_waitCursorCounter == 0) || (hCursor != hcWait))

{

hCursor = hcWait;

}

g_waitCursorCounter++;

}

void

NormalCursor ()

{

if (hcArrow == NULL)

hcArrow = LoadCursor (NULL, IDC_ARROW);

if (g_waitCursorCounter > 0)

g_waitCursorCounter--;

if (g_waitCursorCounter == 0)

{

hCursor = NULL;

}

}

void

ArrowWaitCursor ()

{

if (hcArrowWait == NULL)

hcArrowWait = LoadCursor (NULL, IDC_APPSTARTING);

if ((g_waitCursorCounter == 0) || (hCursor != hcArrowWait))

{

hCursor = hcArrowWait;

}

g_waitCursorCounter++;

}

void HandCursor ()

{

if (hcHand == NULL)

hcHand = LoadCursor (NULL, IDC_HAND);

SetCursor (hcHand);

hCursor = hcHand;

/*

static BOOL IsReturnAddress (DWORD64 address)

{

static size_t codeEnd = 0;

if (codeEnd == 0)

{

MEMORY_BASIC_INFORMATION mi;

retAddrs.push_back (0);

MEMORY_BASIC_INFORMATION mi;

VirtualQuery (sp, &mi, sizeof (mi));

int i = 0;

while (retAddrs.size() < 16 && &sp[i] < stackTop)

{

StringCbCopyW (newCmdLine, sizeof(newCmdLine), L"/q UAC ");

StringCbCatW (newCmdLine, sizeof (newCmdLine), args);

{

if (hwndDlg)

handleWin32Error (hwndDlg, SRC_POS);

return FALSE;

return configMap;

}

uint32 ReadEncryptionThreadPoolFreeCpuCountLimit ()

{

DWORD count;

return count;

}

BOOL LoadSysEncSettings ()

{

BOOL status = TRUE;

{

case TC_POST_INSTALL_CFG_REMOVE_ALL:

_wremove (GetConfigPath (TC_APPD_FILENAME_POST_INSTALL_TASK_TUTORIAL));

_wremove (GetConfigPath (TC_APPD_FILENAME_POST_INSTALL_TASK_RELEASE_NOTES));

break;

case TC_POST_INSTALL_CFG_TUTORIAL:

f = _wfopen (GetConfigPath (TC_APPD_FILENAME_POST_INSTALL_TASK_TUTORIAL), L"w");

case TC_POST_INSTALL_CFG_RELEASE_NOTES:

f = _wfopen (GetConfigPath (TC_APPD_FILENAME_POST_INSTALL_TASK_RELEASE_NOTES), L"w");

break;

default:

return;

}

if (FileExists (GetConfigPath (TC_APPD_FILENAME_POST_INSTALL_TASK_TUTORIAL)))

{

if (AskYesNo ("AFTER_INSTALL_TUTORIAL", hwndDlg) == IDYES)

bDone = TRUE;

}

if (FileExists (GetConfigPath (TC_APPD_FILENAME_POST_INSTALL_TASK_RELEASE_NOTES)))

{

if (AskYesNo ("AFTER_UPGRADE_RELEASE_NOTES", hwndDlg) == IDYES)

bDone = TRUE;

}

if (bDone)

SavePostInstallTasksSettings (TC_POST_INSTALL_CFG_REMOVE_ALL);

}

{

}

}

/* InitApp - initialize the application, this function is called once in the

applications WinMain function, but before the main dialog has been created */

void InitApp (HINSTANCE hInstance, wchar_t *lpszCommandLine)

{

WNDCLASSW wc;

char langId[6];

{

}

{

}

{

}

#ifndef SETUP

#endif

/* Save the instance handle for later */

hInst = hInstance;

SetErrorMode (SetErrorMode (0) | SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX);

#ifndef SETUP

// Application ID

#endif

// Language

langId[0] = 0;

SetPreferredLangId (ConfigReadString ("Language", "", langId, sizeof (langId)));

if (langId[0] == 0)

{

if (IsNonInstallMode ())

// UAC elevation moniker cannot be used in portable mode.

// A new instance of the application must be created with elevated privileges.

if (IsNonInstallMode () && !IsAdmin () && IsUacSupported ())

{

if (wcsstr (lpszCommandLine, L"/q UAC ") == lpszCommandLine)

{

Error ("UAC_INIT_ERROR", NULL);

exit (1);

}

if (LaunchElevatedProcess (NULL, modPath, lpszCommandLine))

exit (0);

else

_set_invalid_parameter_handler (InvalidParameterHandler);

RemoteSession = GetSystemMetrics (SM_REMOTESESSION) != 0;

{

MessageBoxW (NULL, GetString ("UNSUPPORTED_OS"), lpszTitle, MB_ICONSTOP);

exit (1);

}

{

}

/* Get the attributes for the standard dialog class */

if ((GetClassInfoW (hInst, WINDOWS_DIALOG_CLASS, &wc)) == 0)

{

InitHelpFileName ();

#ifndef SETUP

if (!EncryptionThreadPoolStart (ReadEncryptionThreadPoolFreeCpuCountLimit()))

{

handleWin32Error (NULL, SRC_POS);

exit (1);

}

#endif

}

void InitHelpFileName (void)

{

wchar_t *lpszTmp;

// Primary file name

if (strcmp (GetPreferredLangId(), "en") == 0

|| strlen(GetPreferredLangId()) == 0)

{

}

else

{

StringCbCatW (szHelpFile, sizeof(szHelpFile), szTemp);

}

// Secondary file name (used when localized documentation is not found).

if (lpszTmp)

{

++lpszTmp;

*lpszTmp = 0;

}

}

}

{

DWORD dwResult;

BOOL bResult;

wchar_t wszFileName[TC_MAX_PATH];

memcpy (driver->wszFileName, wszFileName, sizeof (wszFileName));

driver->bDetectTCBootLoader = FALSE;

driver->DetectFilesystem = detectFilesystem;

bResult = DeviceIoControl (hDriver, TC_IOCTL_OPEN_TEST,

driver, sizeof (OPEN_TEST_STRUCT),

driver, sizeof (OPEN_TEST_STRUCT),

if (dwResult == ERROR_SHARING_VIOLATION || dwResult == ERROR_NOT_READY)

{

driver->TCBootLoaderDetected = FALSE;

driver->FilesystemDetected = FALSE;

return TRUE;

}

else

return FALSE;

return TRUE;

}

// Tells the driver that it's running in portable mode

void NotifyDriverOfPortableMode (void)

{

BOOL GetDriveLabel (int driveNo, wchar_t *label, int labelSize)

{

DWORD fileSystemFlags;

return GetVolumeInformationW (root, label, labelSize / 2, NULL, NULL, &fileSystemFlags, NULL, 0);

}

/* Stores the device path of the system partition in SysPartitionDevicePath and the device path of the system drive

in SysDriveDevicePath.

IMPORTANT: As this may take a very long time if called for the first time, it should be called only before performing

if (device.ContainsSystem)

StringCchCopyW (device.IsPartition ? SysPartitionDevicePath : SysDriveDevicePath, TC_MAX_PATH, device.Path.c_str());

}

{

{

{

{

}

}

}

}

bCachedSysDevicePathsValid = 1;

return 0;

}

}

wstring GetSysEncryptionPretestInfo2String (void)

{

// This huge string is divided into smaller portions to make it easier for translators to

+ GetString ("DECOY_OS_INSTRUCTIONS_PORTION_17")

+ GetString ("DECOY_OS_INSTRUCTIONS_PORTION_18"));

}

INT_PTR TextInfoDialogBox (int nID)

{

return DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_TEXT_INFO_DIALOG_BOX_DLG), MainDlg, (DLGPROC) TextInfoDialogBoxDlgProc, (LPARAM) nID);

return buf;

}

BOOL CALLBACK RawDevicesDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)

{

static wchar_t *lpszFileName; // This is actually a pointer to a GLOBAL array

}

return 0;

}

BOOL DoDriverInstall (HWND hwndDlg)

{

#ifdef SETUP

}

else

*tmp = 0;

file = FindFirstFile (driverPath, &find);

if (file == INVALID_HANDLE_VALUE)

BOOL DriverUnload ()

{

int refCount;

int volumesMounted;

DWORD dwResult;

BOOL bResult;

// Test for mounted volumes

bResult = DeviceIoControl (hDriver, TC_IOCTL_IS_ANY_VOLUME_MOUNTED, NULL, 0, &volumesMounted, sizeof (volumesMounted), &dwResult, NULL);

if (bResult)

{

if (volumesMounted != 0)

return FALSE;

DWORD dwResult;

BOOL bResult = DeviceIoControl (hDriver, TC_IOCTL_GET_DRIVER_VERSION, NULL, 0, &DriverVersion, sizeof (DriverVersion), &dwResult, NULL);

#ifndef SETUP // Don't check version during setup to allow removal of another version

if (bResult == FALSE)

{

return ERR_OS_ERROR;

// Unload an incompatbile version of the driver loaded in non-install mode and load the required version

if (IsNonInstallMode () && CreateDriverSetupMutex () && DriverUnload () && nLoadRetryCount++ < 3)

goto load;

}

#else

if (!bResult)

DriverVersion = 0;

}

}

{

}

{

wchar_t filter[1024];

BOOL status = FALSE;

{

}

{

}

else

{

}

SystemFileSelectorCallPending = FALSE;

ResetCurrentDirectory();

CoUninitialize();

return status;

}

{

return FALSE;

}

}

{

{

{

{

}

}

}

CoUninitialize();

return bOK;

}

std::wstring GetWrongPasswordErrorMessage (HWND hwndDlg)

{

WCHAR szTmp[8192];

case ERR_DONT_REPORT:

// A non-error

break;

#ifndef SETUP

case ERR_RAND_INIT_FAILED:

StringCbPrintfW (szTmp, sizeof(szTmp), GetString ("INIT_RAND"), SRC_POS, GetLastError ());

MessageBoxW (hwndDlg, AppendSrcPos (szTmp, srcPos).c_str(), lpszTitle, MB_ICONERROR);

MessageBoxW (hwndDlg, AppendSrcPos (szTmp, srcPos).c_str(), lpszTitle, MB_ICONERROR);

break;

#endif

default:

StringCbPrintfW (szTmp, sizeof(szTmp), GetString ("ERR_UNKNOWN"), code);

MessageBoxW (hwndDlg, AppendSrcPos (szTmp, srcPos).c_str(), lpszTitle, ICON_HAND);

}

// Force explorer to discover the drive

SHGetFileInfo (dosName, 0, &fInfo, sizeof (fInfo), 0);

}

static BOOL explorerCloseSent;

static HWND explorerTopLevelWindow;

BOOL UpdateDriveCustomLabel (int driveNo, wchar_t* effectiveLabel, BOOL bSetValue)

{

wchar_t wszRegPath[MAX_PATH];

HKEY hKey;

LSTATUS lStatus;

DWORD cbLabelLen = (DWORD) ((wcslen (effectiveLabel) + 1) * sizeof (wchar_t));

BOOL bToBeDeleted = FALSE;

wstring versionString (szTmp);

versionString.insert (version > 0xfff ? 2 : 1,L".");

return (versionString);

}

wstring IntToWideString (int val)

return result;

}

{

bool bRet = true;

if (c >= L'0' && c <= L'9')

else if (c >= L'a' && c <= L'z')

else if (c >= L'A' && c <= L'Z')

else

bRet = false;

return bRet;

}

{

size_t i, len = wcslen (hexStr);

arr.clear();

if (len %2)

LvItem.pszText = item1;

SendMessageW (hList, LVM_SETITEMW, 0, (LPARAM)&LvItem);

break;

case BENCHMARK_TYPE_PRF:

LvItem.iSubItem = 1;

LvItem.pszText = item1;

SendMessageW (hList, LVM_SETITEMW, 0, (LPARAM)&LvItem);

LvItem.iSubItem = 2;

LvItem.pszText = item1;

SendMessageW (hList, LVM_SETITEMW, 0, (LPARAM)&LvItem);

break;

LARGE_INTEGER performanceCountStart, performanceCountEnd;

BYTE *lpTestBuffer = NULL;

PCRYPTO_INFO ci = NULL;

UINT64_STRUCT startDataUnitNo;

startDataUnitNo.Value = 0;

/* set priority to critical only when there are 2 or more CPUs on the system */

SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);

ci = crypto_open ();

if (!ci)

/* Measures the speed at which each of the hash algorithms processes the message to produce

a single digest.

*/

{

sha512_ctx s2ctx;

sha256_ctx s256ctx;

int hid, i;

for (hid = FIRST_PRF_ID; hid <= LAST_PRF_ID; hid++)

sha256_begin (&s256ctx);

sha256_hash (lpTestBuffer, benchmarkBufferSize, &s256ctx);

sha256_end ((unsigned char *) digest, &s256ctx);

break;

break;

case WHIRLPOOL:

WHIRLPOOL_init (&wctx);

STREEBOG_finalize(&stctx, (unsigned char *)digest);

break;

}

if (QueryPerformanceCounter (&performanceCountEnd) == 0)

goto counter_error;

each of the implemented PRF algorithms.

*/

{

int thid, i;

char *tmp_salt = {"\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF\x01\x23\x45\x67\x89\xAB\xCD\xEF\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF\x01\x23\x45\x67\x89\xAB\xCD\xEF\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF"};

for (thid = FIRST_PRF_ID; thid <= LAST_PRF_ID; thid++)

{

{

case SHA512:

/* PKCS-5 test with HMAC-SHA-512 used as the PRF */

break;

case SHA256:

/* PKCS-5 test with HMAC-SHA-256 used as the PRF */

break;

break;

case WHIRLPOOL:

/* PKCS-5 test with HMAC-Whirlpool used as the PRF */

break;

case STREEBOG:

/* PKCS-5 test with HMAC-STREEBOG used as the PRF */

break;

}

if (QueryPerformanceCounter (&performanceCountEnd) == 0)

goto counter_error;

benchmarkTable[benchmarkTotalItems].encSpeed = performanceCountEnd.QuadPart - performanceCountStart.QuadPart;

benchmarkTable[benchmarkTotalItems].id = thid;

benchmarkTable[benchmarkTotalItems].meanBytesPerSec = (unsigned __int64) (1000 * ((float) benchmarkTable[benchmarkTotalItems].encSpeed / benchmarkPerformanceFrequency.QuadPart / 2));

if (benchmarkPreBoot)

{

/* heuristics for boot times */

else

{

if (thid == SHA256)

{

benchmarkTable[benchmarkTotalItems].meanBytesPerSec = (benchmarkTable[benchmarkTotalItems].meanBytesPerSec * 26);

}

else

{

benchmarkTable[benchmarkTotalItems].meanBytesPerSec = (benchmarkTable[benchmarkTotalItems].meanBytesPerSec * 21) / 5;

}

}

}

StringCbPrintfW (benchmarkTable[benchmarkTotalItems].name, sizeof(benchmarkTable[benchmarkTotalItems].name),L"%s", get_pkcs5_prf_name (thid));

ci->ea = EAGetFirst();

if (!EAInit (ci->ea, ci->master_keydata, ci->ks))

{

ci->mode = FIRST_MODE_OF_OPERATION_ID;

{

int i;

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

{

EncryptDataUnits (lpTestBuffer, &startDataUnitNo, (TC_LARGEST_COMPILER_UINT) benchmarkBufferSize / ENCRYPTION_DATA_UNIT_SIZE, ci);

if (ERR_CIPHER_INIT_FAILURE == EAInit (ci->ea, ci->master_keydata, ci->ks))

goto counter_error;

ci->mode = FIRST_MODE_OF_OPERATION_ID;

goto counter_error;

if (QueryPerformanceCounter (&performanceCountStart) == 0)

goto counter_error;

EncryptDataUnits (lpTestBuffer, &startDataUnitNo, (TC_LARGEST_COMPILER_UINT) benchmarkBufferSize / ENCRYPTION_DATA_UNIT_SIZE, ci);

benchmarkTable[benchmarkTotalItems].decSpeed = performanceCountEnd.QuadPart - performanceCountStart.QuadPart;

benchmarkTable[benchmarkTotalItems].id = ci->ea;

benchmarkTable[benchmarkTotalItems].meanBytesPerSec = ((unsigned __int64) (benchmarkBufferSize / ((float) benchmarkTable[benchmarkTotalItems].encSpeed / benchmarkPerformanceFrequency.QuadPart)) + (unsigned __int64) (benchmarkBufferSize / ((float) benchmarkTable[benchmarkTotalItems].decSpeed / benchmarkPerformanceFrequency.QuadPart))) / 2;

benchmarkTotalItems++;

}

}

SendMessage (hCboxBufferSize, CB_SETCURSEL, 5, 0); // Default buffer size

uint32 driverConfig = ReadDriverConfigurationFlags();

SetDlgItemTextW (hwndDlg, IDC_HW_AES, (wstring (L" ") + (GetString (isAesHwSupported ? ((driverConfig & TC_DRIVER_CONFIG_DISABLE_HARDWARE_ENCRYPTION) ? "UISTR_DISABLED" : "UISTR_YES") : "NOT_APPLICABLE_OR_NOT_AVAILABLE"))).c_str());

ToHyperlink (hwndDlg, IDC_HW_AES_LABEL_LINK);

{

Warning ("DISABLED_HW_AES_AFFECTS_PERFORMANCE", hwndDlg);

}

size_t nbrThreads = GetEncryptionThreadCount();

wchar_t nbrThreadsStr [300];

{

StringCbCopyW (nbrThreadsStr, sizeof(nbrThreadsStr), GetString ("NOT_APPLICABLE_OR_NOT_AVAILABLE"));

}

else if (nbrThreads < 2)

SetDlgItemTextW (hwndDlg, IDC_PARALLELIZATION, (wstring (L" ") + nbrThreadsStr).c_str());

ToHyperlink (hwndDlg, IDC_PARALLELIZATION_LABEL_LINK);

{

Warning ("LIMITED_THREAD_COUNT_AFFECTS_PERFORMANCE", hwndDlg);

}

case IDC_PERFORM_BENCHMARK:

if (benchmarkType == BENCHMARK_TYPE_PRF)

{

benchmarkPreBoot = GetCheckBox (hwndDlg, IDC_BENCHMARK_PREBOOT);

}

else

{

return 1;

case IDC_HW_AES_LABEL_LINK:

return 1;

case IDC_PARALLELIZATION_LABEL_LINK:

return 1;

case IDCLOSE:

case IDCANCEL:

{

case WM_INITDIALOG:

{

HWND hComboBox = GetDlgItem (hwndDlg, IDC_PRF_ID);

HCRYPTPROV hRngProv = NULL;

VirtualLock (randPool, sizeof(randPool));

VirtualLock (lastRandPool, sizeof(lastRandPool));

AddComboPair (hComboBox, HashGetName(hid), hid);

}

SelectAlgo (hComboBox, &hash_algo);

SetCheckBox (hwndDlg, IDC_DISPLAY_POOL_CONTENTS, bDisplayPoolContents);

hEntropyBar = GetDlgItem (hwndDlg, IDC_ENTROPY_BAR);

SendMessage (hEntropyBar, PBM_SETRANGE32, 0, maxEntropyLevel);

SendMessage (hEntropyBar, PBM_SETSTEP, 1, 0);

SendMessage (GetDlgItem (hwndDlg, IDC_KEYFILES_SIZE), EM_SETLIMITTEXT, (WPARAM) 7, 0);

SetWindowText(GetDlgItem (hwndDlg, IDC_KEYFILES_SIZE), L"64");

// set the maximum length of the keyfile base name to (TC_MAX_PATH - 1)

SendMessage (GetDlgItem (hwndDlg, IDC_KEYFILES_BASE_NAME), EM_SETLIMITTEXT, (WPARAM) (TC_MAX_PATH - 1), 0);

return 1;

}

case WM_TIMER:

if (lw == IDC_KEYFILES_RANDOM_SIZE)

{

EnableWindow(GetDlgItem (hwndDlg, IDC_KEYFILES_SIZE), !GetCheckBox (hwndDlg, IDC_KEYFILES_RANDOM_SIZE));

}

if (lw == IDC_GENERATE_AND_SAVE_KEYFILE)

{

wchar_t szDirName[TC_MAX_PATH];

wchar_t szFileName [2*TC_MAX_PATH + 16];

unsigned char *keyfile = NULL;

int fhKeyfile = -1, status;

wchar_t* fileExtensionPtr = 0;

wchar_t szSuffix[32];

BOOL bRandomSize = GetCheckBox (hwndDlg, IDC_KEYFILES_RANDOM_SIZE);

if (!GetWindowText(GetDlgItem (hwndDlg, IDC_KEYFILES_SIZE), szNumber, ARRAYSIZE(szNumber)))

szNumber[0] = 0;

keyfilesSize = wcstoul(szNumber, NULL, 0);

{

Warning("KEYFILE_INCORRECT_SIZE", hwndDlg);

SendMessage(hwndDlg, WM_NEXTDLGCTL, (WPARAM) GetDlgItem (hwndDlg, IDC_KEYFILES_SIZE), TRUE);

return 1;

fileExtensionPtr = wcsrchr(szFileBaseName, L'.');

/* Select directory */

return 1;

if (szDirName[wcslen(szDirName) - 1] != L'\\' && szDirName[wcslen(szDirName) - 1] != L'/')

StringCbCat(szDirName, sizeof(szDirName), L"\\");

WaitCursor();

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

{

StringCbCopyW(szFileName, sizeof(szFileName), szDirName);

NormalCursor();

return 1;

}

keyfilesSize %= ((KEYFILE_MAX_READ_LEN - 64) + 1);

keyfilesSize += 64;

}

_close (fhKeyfile);

if (status == -1)

{

TCfree(keyfile);

NormalCursor();

handleWin32Error (hwndDlg, SRC_POS);

return 1;

}

}

SendMessage (GetDlgItem (hwndDlg, IDC_CIPHER), CB_RESETCONTENT, 0, 0);

for (ea = EAGetFirst (); ea != 0; ea = EAGetNext (ea))

{

if (EAGetCipherCount (ea) == 1 && EAIsFormatEnabled (ea))

}

ResetCipherTest(hwndDlg, idTestCipher);

return 1;

}

memcpy (&ci->k2, secondaryKey, sizeof (secondaryKey));

{

crypto_close (ci);

return 1;

}

}

else

{

if (bEncrypt)

{

EncipherBlock(idTestCipher, tmp, ks_tmp);

SetWindowText(GetDlgItem(hwndDlg, IDC_PLAINTEXT), L"0000000000000000");

SetWindowText(GetDlgItem(hwndDlg, IDC_CIPHERTEXT), L"0000000000000000");

if (idTestCipher == AES || idTestCipher == SERPENT || idTestCipher == TWOFISH || idTestCipher == CAMELLIA

|| idTestCipher == KUZNYECHIK

)

{

ndx = (int) SendMessage (GetDlgItem(hwndDlg, IDC_KEY_SIZE), CB_ADDSTRING, 0,(LPARAM) L"256");

fileName [i] = L'\\';

}

}

void IncreaseWrongPwdRetryCount (int count)

{

WrongPwdRetryCounter += count;

}

EnterCriticalSection (&csWNetCalls);

finally_do ({ LeaveCriticalSection (&csWNetCalls); });

{

/* detect disconnected mapped network shares and removed

* their associated drives from the list

*/

BOOL IsDriveAvailable (int driveNo)

{

}

BOOL IsDeviceMounted (wchar_t *deviceName)

if (message == DBT_DEVICEARRIVAL)

eventId = SHCNE_DRIVEADD;

else if (message == DBT_DEVICEREMOVECOMPLETE)

eventId = SHCNE_DRIVEREMOVED;

eventId = SHCNE_DRIVEREMOVED;

if (driveMap == 0)

driveMap = (1 << nDosDriveNo);

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

{

if (driveMap & (1 << i))

{

SHChangeNotify (eventId, SHCNF_PATH, root, NULL);

}

IgnoreWmDeviceChange = FALSE;

}

{

DWORD dwRet = NO_ERROR;

if (!pDesc)

return FALSE;

// Set the input data structure

STORAGE_PROPERTY_QUERY storagePropertyQuery;

ZeroMemory(&storagePropertyQuery, sizeof(STORAGE_PROPERTY_QUERY));

storagePropertyQuery.QueryType = PropertyStandardQuery;

// Get the necessary output buffer size

DWORD dwBytesReturned = 0;

BOOL bRet = ::DeviceIoControl(hDevice, IOCTL_STORAGE_QUERY_PROPERTY,

&storagePropertyQuery, sizeof(STORAGE_PROPERTY_QUERY),

&dwBytesReturned, NULL);

dwRet = ::GetLastError();

::CloseHandle(hDevice);

if (!bRet)

else

return TRUE;

}

/************************************************************/

// implementation of the generic wait dialog mechanism

}

}

{

if(!::IsWindow(hWnd)) return;

HWND hCurrWnd = ::GetForegroundWindow();

DWORD dwThisTID = ::GetCurrentThreadId(),

dwCurrTID = ::GetWindowThreadProcessId(hCurrWnd,0);

if (hCurrWnd != hWnd)

{

if(dwThisTID != dwCurrTID)

{

}

::SetForegroundWindow(hWnd);

if(dwThisTID != dwCurrTID)

{

}

}

#ifdef TCMOUNT

}

#endif

}

void ShowWaitDialog(HWND hwnd, BOOL bUseHwndAsParent, WaitThreadProc callback, void* pArg)

{

BOOL bEffectiveHideWaitingDialog = bCmdHideWaitingDialogValid? bCmdHideWaitingDialog : bHideWaitingDialog;

WaitThreadParam threadParam;

threadParam.callback = callback;

threadParam.pArg = pArg;

if (!WaitDialogDisplaying) NormalCursor ();

}

else

{

BOOL bIsForeground = FALSE;

HWND creatorWnd = hwnd? hwnd : MainDlg;

WaitDialogDisplaying = TRUE;

if (creatorWnd)

{

if (GetForegroundWindow () == creatorWnd)

bIsForeground = TRUE;

EnableWindow (creatorWnd, FALSE);

}

finally_do_arg2 (HWND, creatorWnd, BOOL, bIsForeground, { if (finally_arg) { EnableWindow(finally_arg, TRUE); if (finally_arg2) BringToForeground (finally_arg);}});

DialogBoxParamW (hInst,

MAKEINTRESOURCEW (IDD_STATIC_MODAL_WAIT_DLG), hParent,

(DLGPROC) WaitDlgProc, (LPARAM) &threadParam);

WaitDialogDisplaying = FALSE;

}

}

/************************************************************************/

static BOOL PerformMountIoctl (MOUNT_STRUCT* pmount, LPDWORD pdwResult, BOOL useVolumeID, BYTE volumeID[VOLUME_ID_SIZE])

{

if (useVolumeID)

{

if (devicePath == L"")

{

if (pdwResult)

*pdwResult = 0;

wchar_t *volumePath,

Password *password,

int pkcs5,

int pim,

BOOL cachePassword,

BOOL cachePim,

BOOL sharedAccess,

const MountOptions* const mountOptions,

return -1;

}

// If using cached passwords, check cache status first

return 0;

ZeroMemory (&mount, sizeof (mount));

mount.bExclusiveAccess = sharedAccess ? FALSE : TRUE;

mount.bMountReadOnly = mountOptions->ReadOnly;

mount.bMountRemovable = mountOptions->Removable;

mount.bPreserveTimestamp = mountOptions->PreserveTimestamp;

mount.pkcs5_prf = pkcs5;

mount.VolumePim = pim;

wstring path = volumePath;

if (path.find (L"\\\\?\\") == 0)

{

// Remove \\?\ prefix

}

if ((path.length () >= 3) && (_wcsnicmp (path.c_str(), L"ID:", 3) == 0))

{

if ( (path.length() == (3 + 2*VOLUME_ID_SIZE))

&& HexWideStringToArray (path.c_str() + 3, arr)

&& (arr.size() == VOLUME_ID_SIZE)

)

CreateFullVolumePath (mount.wszVolume, sizeof(mount.wszVolume), volumePath, &bDevice);

if (!bDevice)

{

// UNC path

if (path.find (L"\\\\") == 0)

{

StringCbCopyW (mount.wszVolume, sizeof (mount.wszVolume), (L"UNC" + path.substr (1)).c_str());

mount.BytesPerSector = bps;

mount.BytesPerPhysicalSector = bps;

}

{

{

{

{

{

}

}

}

}

}

}

// Read-only host filesystem

if (mountOptions->PartitionInInactiveSysEncScope)

{

if (mount.wszVolume == NULL || swscanf_s ((const wchar_t *) mount.wszVolume,

WIDE("\\Device\\Harddisk%d\\Partition"),

{

if (!quiet)

Warning ("NO_SYSENC_PARTITION_SELECTED", hwndDlg);

return -1;

burn (&mount.VolumePassword, sizeof (mount.VolumePassword));

burn (&mount.ProtectedHidVolPassword, sizeof (mount.ProtectedHidVolPassword));

burn (&mount.pkcs5_prf, sizeof (mount.pkcs5_prf));

burn (&mount.ProtectedHidVolPkcs5Prf, sizeof (mount.ProtectedHidVolPkcs5Prf));

SetLastError (dwLastError);

if (bResult == FALSE)

}

if (bDevice && mount.bProtectHiddenVolume)

{

{

OPEN_TEST_STRUCT openTestStruct;

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

openTestStruct.bDetectTCBootLoader = TRUE;

WarningDirect ((GetWrongPasswordErrorMessage (hwndDlg) + L"\n\n" + GetString ("HIDDEN_VOL_PROT_PASSWORD_US_KEYB_LAYOUT")).c_str(), hwndDlg);

else

handleError (hwndDlg, mount.nReturnCode, SRC_POS);

}

}

LastMountedVolumeDirty = mount.FilesystemDirty;

if (mount.FilesystemDirty)

{

wchar_t msg[1024];

StringCbPrintfW (msg, sizeof(msg), GetString ("MOUNTED_VOLUME_DIRTY"), mountPoint);

if (AskWarnYesNoStringTopmost (msg, hwndDlg) == IDYES)

CheckFilesystem (hwndDlg, driveNo, TRUE);

&& !FileHasReadOnlyAttribute (volumePath)

&& !IsFileOnReadOnlyFilesystem (volumePath))

{

wchar_t msg[1024];

StringCbPrintfW (msg, sizeof(msg), GetString ("MOUNTED_CONTAINER_FORCED_READ_ONLY"), mountPoint);

WarningDirect (msg, hwndDlg);

}

&& !Silent

&& bDevice)

{

wchar_t msg[1024];

StringCbPrintfW (msg, sizeof(msg), GetString ("MOUNTED_DEVICE_FORCED_READ_ONLY"), mountPoint);

WarningDirect (msg, hwndDlg);

}

&& !Silent

&& wcsstr (volumePath, L"\\Device\\Harddisk") == volumePath)

{

wchar_t msg[1024];

StringCbPrintfW (msg, sizeof(msg), GetString ("MOUNTED_DEVICE_FORCED_READ_ONLY_WRITE_PROTECTION"), mountPoint);

WarningDirect (msg, hwndDlg);

RemoveDeviceWriteProtection (hwndDlg, volumePath);

}

}

if (mount.wszLabel[0] && !mount.bDriverSetLabel)

{

// try setting the drive label on user-mode using registry

UpdateDriveCustomLabel (driveNo, mount.wszLabel, TRUE);

return 1;

}

typedef struct

{

int nDosDriveNo;

BOOL forced;

forced = TRUE;

goto retry;

}

return FALSE;

}

{

return UnmountVolumeBase (hwndDlg, nDosDriveNo, FALSE, TRUE);

}

BOOL IsPasswordCacheEmpty (void)

{

DWORD dw;

return !DeviceIoControl (hDriver, TC_IOCTL_GET_PASSWORD_CACHE_STATUS, 0, 0, 0, 0, &dw, 0);

DWORD dwResult;

int i;

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

return FALSE;

}

{

if ((wcslen (volname) == (3 + 2*VOLUME_ID_SIZE)) && _wcsnicmp (volname, L"ID:", 3) == 0)

{

/* Volume ID specified. Use it for matching mounted volumes. */

if (HexWideStringToArray (&volname[3], arr) && (arr.size() == VOLUME_ID_SIZE))

{

return IsMountedVolumeID (&arr[0]);

}

if (!resolvedPath.empty())

StringCbCopyW (volume, sizeof (volume), resolvedPath.c_str());

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

}

return FALSE;

}

if (!resolvedPath.empty())

StringCbCopyW (volume, sizeof (volume), resolvedPath.c_str());

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

return -1;

}

BOOL IsAdmin (void)

{

return IsUserAnAdmin ();

{

HKEY hkey;

DWORD value = 1, size = sizeof (DWORD);

if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\System", 0, KEY_READ, &hkey) == ERROR_SUCCESS)

{

if (RegQueryValueEx (hkey, L"EnableLUA", 0, 0, (LPBYTE) &value, &size) != ERROR_SUCCESS)

value = 1;

return DeviceIoControl (hDriver, TC_IOCTL_GET_DRIVE_PARTITION_INFO, info, sizeof (*info), info, sizeof (*info), &dwResult, NULL);

}

{

BOOL bResult;

DWORD dwResult;

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

StringCbCopyW ((PWSTR) &dg.deviceName, sizeof(dg.deviceName), deviceName);

sizeof (dg), &dg, sizeof (dg), &dwResult, NULL);

if (bResult && (dwResult == sizeof (dg)) && dg.diskGeometry.BytesPerSector)

{

return TRUE;

}

else

return FALSE;

}

{

HANDLE hDev;

BOOL bResult = FALSE;

TCHAR devicePath[MAX_PATH];

if ((hDev = CreateFileW (devicePath, 0, 0, NULL, OPEN_EXISTING, 0, NULL)) != INVALID_HANDLE_VALUE)

{

DWORD bytesRead = 0;

{

bResult = TRUE;

}

CloseHandle (hDev);

}

return bResult;

}

// Returns drive letter number assigned to device (-1 if none)

int GetDiskDeviceDriveLetter (PWSTR deviceName)

{

StringCchCopyW (device, MAX_PATH, deviceName);

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

{

StringCchCopyW (link, MAX_PATH, L"\\DosDevices\\");

StringCchCatW (link, MAX_PATH, drive);

return (bResult ? hVolume : INVALID_HANDLE_VALUE);

}

{

return FALSE;

{

return FALSE;

}

{

{

{

}

}

return res;

}

// Proper flush for Windows systems. Returns TRUE if successful.

BOOL TCFlushFile (FILE *f)

{

HANDLE hf = (HANDLE) _get_osfhandle (_fileno (f));

BOOL IsNonInstallMode ()

{

DWORD dw;

if (bPortableModeConfirmed)

return TRUE;

else

CloseHandle (hDriverTmp);

}

// The following test may be unreliable in some cases (e.g. after the user selects restore "Last Known Good

// Configuration" from the Windows boot menu).

if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\VeraCrypt", 0, KEY_READ | KEY_WOW64_32KEY, &hkey) == ERROR_SUCCESS)

{

GetModuleFileNameW (NULL, exeFilename, sizeof (exeFilename) / sizeof(exeFilename[0]));

strToMatch = wcsrchr (exeFilename, L'\\') + 1;

{

*strTmp = 0;

if ((len = ReadRegistryBytes (regPath, key, (char *) strTmp, sizeof (strTmp))) > 0)

{

if (_wcsicmp (strTmp, strToMatch) == 0)

DeleteRegistryValue (regPath, key);

// Remove ID from MRUList

{

{

}

}

break;

}

}

}

BOOL GetMountList (MOUNT_LIST_STRUCT *list)

{

DWORD dwResult;

}

int GetDriverRefCount ()

else

return -1;

}

wchar_t *GetModPath (wchar_t *path, int maxSize)

{

GetModuleFileName (NULL, path, maxSize);

std::wstring GetServiceConfigPath (const wchar_t *fileName, bool useLegacy)

{

wchar_t sysPath[TC_MAX_PATH];

{

typedef UINT (WINAPI *GetSystemWow64Directory_t) (LPWSTR lpBuffer, UINT uSize);

GetSystemWow64Directory_t getSystemWow64Directory = (GetSystemWow64Directory_t) GetProcAddress (GetModuleHandle (L"kernel32"), "GetSystemWow64DirectoryW");

void TaskBarIconDisplayBalloonTooltip (HWND hwnd, wchar_t *headline, wchar_t *text, BOOL warning)

{

NOTIFYICONDATAW tnid;

ZeroMemory (&tnid, sizeof (tnid));

//Shell_NotifyIconW (NIM_SETVERSION, &tnid);

tnid.uFlags = NIF_INFO;

tnid.dwInfoFlags = (warning ? NIIF_WARNING : NIIF_INFO);

StringCbCopyW (tnid.szInfoTitle, sizeof(tnid.szInfoTitle), headline);

StringCbCopyW (tnid.szInfo, sizeof(tnid.szInfo),text);

if (Silent) return 0;

return MessageBoxW (hwnd, warnMsg, lpszTitle, MB_ICONWARNING);

}

int ErrorRetryCancel (char *stringId, HWND hwnd)

{

if (Silent) return 0;

return MessageBoxW (hwnd, GetString (stringId), lpszTitle, MB_ICONERROR | MB_RETRYCANCEL);

}

void OpenPageHelp (HWND hwndDlg, int nPage)

{

{

if (r == ERROR_FILE_NOT_FOUND)

{

}

}

}

void OpenOnlineHelp ()

{

}

#ifndef SETUP

MessageBoxA (MainDlg, buf, "VeraCrypt debug", 0);

}

{

{

}

}

{

#ifdef _WIN64

return TRUE;

#else

static BOOL valid = FALSE;

LPFN_ISWOW64PROCESS fnIsWow64Process;

if (valid)

return isWow64;

isWow64 = FALSE;

valid = TRUE;

#endif

}

BOOL IsServerOS ()

{

}

// Returns TRUE, if the currently running operating system is installed in a hidden volume. If it's not, or if

// there's an error, returns FALSE.

BOOL IsHiddenOSRunning (void)

{

std::wstring GetWindowsEdition ()

{

wstring osname = L"win";

osVer.dwOSVersionInfoSize = sizeof (OSVERSIONINFOEXW);

{

}

}

{

ArrowWaitCursor ();

if (strcmp(dest, "donate") == 0)

{

}

else if (strcmp(dest, "main") == 0)

{

}

else if (strcmp(dest,"localizations") == 0)

{

}

else if (strcmp(dest, "beginnerstutorial") == 0 || strcmp(dest,"tutorial") == 0)

{

}

else if (strcmp(dest, "releasenotes") == 0 || strcmp(dest, "history") == 0)

{

}

else if (strcmp(dest, "hwacceleration") == 0)

{

}

else if (strcmp(dest, "parallelization") == 0)

{

}

else if (strcmp(dest, "help") == 0)

{

}

else if (strcmp(dest, "keyfiles") == 0)

{

}

else if (strcmp(dest, "introcontainer") == 0)

{

}

else if (strcmp(dest, "introsysenc") == 0)

{

}

else if (strcmp(dest, "hiddensysenc") == 0)

{

}

else if (strcmp(dest, "sysencprogressinfo") == 0)

{

}

else if (strcmp(dest, "hiddenvolume") == 0)

{

}

else if (strcmp(dest, "aes") == 0)

{

}

else if (strcmp(dest, "serpent") == 0)

{

}

else if (strcmp(dest, "twofish") == 0)

{

}

else if (strcmp(dest, "kuznyechik") == 0)

{

}

else if (strcmp(dest, "camellia") == 0)

{

}

else if (strcmp(dest, "cascades") == 0)

{

}

else if (strcmp(dest, "hashalgorithms") == 0)

{

}

else if (strcmp(dest, "isoburning") == 0)

{

}

else if (strcmp(dest, "sysfavorites") == 0)

{

}

else if (strcmp(dest, "favorites") == 0)

{

}

else if (strcmp(dest, "hiddenvolprotection") == 0)

{

}

else if (strcmp(dest, "faq") == 0)

{

}

else if (strcmp(dest, "downloads") == 0)

{

}

else if (strcmp(dest, "news") == 0)

{

}

else if (strcmp(dest, "contact") == 0)

{

}

else if (strcmp(dest, "pim") == 0)

{

}

else

{

}

Sleep (200);

NormalCursor ();

}

&& value != 0)

{

Warning ("SYS_AUTOMOUNT_DISABLED", hwnd);

}

else

Warning ("DEVICE_NOT_READY_ERROR", hwnd);

RegCloseKey (hkey);

if ((userDataVal == (LONG_PTR) 'VERA') || (userDataVal == (LONG_PTR) 'TRUE')) // Prior to 1.0e, 'TRUE' was used for VeraCrypt dialogs

{

wchar_t name[1024] = { 0 };

GetWindowText (hwnd, name, ARRAYSIZE (name) - 1);

{

PostMessage (hwnd, TC_APPMSG_CLOSE_BKG_TASK, 0, 0);

PostMessage (hwnd, WM_CLOSE, 0, 0);

BYTE *MapResource (wchar_t *resourceType, int resourceId, PDWORD size)

{

HGLOBAL hResL;

HRSRC hRes;

if (size != NULL)

return (BYTE *) LockResource (hResL);

}

MessageBoxW (MainDlg, finalMsg, lpszTitle, MB_ICONWARNING | MB_SETFOREGROUND | MB_TOPMOST);

}

{

wchar_t finalMsg[8024];

StringCbPrintfW (finalMsg, sizeof(finalMsg), GetString ("UNEXPECTED_STATE"), techInfo);

#ifndef SETUP

{

int status = ERR_PARAMETER_INCORRECT;

int volumeType;

wchar_t szDiskFile[TC_MAX_PATH], szCFDevice[TC_MAX_PATH];

wchar_t szDosDevice[TC_MAX_PATH];

LARGE_INTEGER headerOffset;

DWORD dwResult;

context->VolumeIsOpen = FALSE;

context->CryptoInfo = NULL;

context->HostFileHandle = INVALID_HANDLE_VALUE;

}

else

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

if (context->HostFileHandle == INVALID_HANDLE_VALUE)

{

status = ERR_OS_ERROR;

// Remember the container modification/creation date and time

if (!context->IsDevice && preserveTimestamps)

{

if (GetFileTime (context->HostFileHandle, &context->CreationTime, &context->LastAccessTime, &context->LastWriteTime) == 0)

context->TimestampsValid = FALSE;

else

context->TimestampsValid = TRUE;

context->HostSize = diskInfo.PartitionLength.QuadPart;

}

else

{

{

}

}

if (context->HostSize == 0)

{

}

// Read volume header

DWORD bytesRead;

{

status = ERR_OS_ERROR;

goto error;

}

memset (buffer, 0, sizeof (buffer));

}

// Decrypt volume header

if (status == ERR_PASSWORD_WRONG)

continue; // Try next volume type

context->VolumeIsOpen = FALSE;

}

{

CRYPTO_INFO *newCryptoInfo = NULL;

RandSetHashFunction (cryptoInfo->pkcs5);

if (handle == INVALID_HANDLE_VALUE)

continue;

DWORD dwResult;

{

CloseHandle (handle);

continue;

}

SendMessage (GetDlgItem (hwndDlg, IDC_TOKEN_PASSWORD), EM_LIMITTEXT, SecurityToken::MaxPasswordLength, 0);

SetForegroundWindow (hwndDlg);

SetFocus (GetDlgItem (hwndDlg, IDC_TOKEN_PASSWORD));

}

return 0;

case WM_COMMAND:

EndDialog (hwndDlg, lw);

}

return 1;

}

return 0;

}

WaitCursor();

finally_do ({ NormalCursor(); });

try

{

}

catch (Exception &e)

{

e.Show (hwndDlg);

EndDialog (hwndDlg, IDCANCEL);

return 1;

}

{

wstringstream tokenLabel;

}

ComboBox_SetCurSel (GetDlgItem (hwndDlg, IDC_SELECTED_TOKEN), 0);

return 0;

}

{

HWND tokenListControl = GetDlgItem (hwndDlg, IDC_TOKEN_FILE_LIST);

LVITEMW lvItem;

int line = 0;

ListView_DeleteAllItems (tokenListControl);

{

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

lvItem.mask = LVIF_TEXT;

lvItem.iItem = line++;

wstringstream s;

ListItemAdd (tokenListControl, lvItem.iItem, (wchar_t *) s.str().c_str());

}

BOOL selected = (ListView_GetNextItem (GetDlgItem (hwndDlg, IDC_TOKEN_FILE_LIST), -1, LVIS_SELECTED) != -1);

EnableWindow (GetDlgItem (hwndDlg, IDC_EXPORT), selected);

EnableWindow (GetDlgItem (hwndDlg, IDC_DELETE), selected);

}

{

HWND tokenListControl = GetDlgItem (hwndDlg, IDC_TOKEN_FILE_LIST);

int itemId = -1;

while ((itemId = ListView_GetNextItem (tokenListControl, itemId, LVIS_SELECTED)) != -1)

{

BOOL CALLBACK SecurityTokenKeyfileDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)

{

WORD lw = LOWORD (wParam);

switch (msg)

{

case WM_INITDIALOG:

{

LVCOLUMNW LvCol;

HWND tokenListControl = GetDlgItem (hwndDlg, IDC_TOKEN_FILE_LIST);

{

WaitCursor();

finally_do ({ NormalCursor(); });

}

catch (UserAbort&)

{

EndDialog (hwndDlg, IDCANCEL);

if (msg == WM_COMMAND && lw == IDOK || msg == WM_NOTIFY && ((NMHDR *)lParam)->code == LVN_ITEMACTIVATE)

{

if (selectedTokenKeyfiles)

{

{

}

}

EndDialog (hwndDlg, IDOK);

if (msg == WM_NOTIFY && ((LPNMHDR) lParam)->code == LVN_ITEMCHANGED)

{

BOOL selected = (ListView_GetNextItem (GetDlgItem (hwndDlg, IDC_TOKEN_FILE_LIST), -1, LVIS_SELECTED) != -1);

EnableWindow (GetDlgItem (hwndDlg, IDC_EXPORT), selected);

return 1;

}

if (msg == WM_COMMAND)

case IDC_IMPORT_KEYFILE:

{

wchar_t keyfilePath[TC_MAX_PATH];

{

DWORD keyfileSize;

if (!keyfileData)

{

handleWin32Error (hwndDlg, SRC_POS);

return 1;

newParams.Name = newParams.Name.substr (lastBackSlash + 1);

if (DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_NEW_TOKEN_KEYFILE), hwndDlg, (DLGPROC) NewSecurityTokenKeyfileDlgProc, (LPARAM) &newParams) == IDOK)

{

memcpy (&keyfileDataVector.front(), keyfileData, keyfileSize);

try

{

finally_do ({ NormalCursor(); });

SecurityToken::CreateKeyfile (newParams.SlotId, keyfileDataVector, newParams.Name);

SecurityTokenKeyfileDlgFillList (hwndDlg, keyfiles);

}

catch (Exception &e)

{

case IDC_EXPORT:

{

try

{

{

wchar_t keyfilePath[TC_MAX_PATH];

break;

{

WaitCursor();

finally_do ({ NormalCursor(); });

if (keyfileData.empty())

{

SetLastError (ERROR_HANDLE_EOF);

handleWin32Error (hwndDlg, SRC_POS);

return 1;

}

if (!SaveBufferToFile ((char *) &keyfileData.front(), keyfilePath, (DWORD) keyfileData.size(), FALSE, FALSE))

throw SystemException (SRC_POS);

}

{

WaitCursor();

finally_do ({ NormalCursor(); });

{

}

SecurityTokenKeyfileDlgFillList (hwndDlg, keyfiles);

}

catch (Exception &e)

{

}

return 0;

}

BOOL InitSecurityTokenLibrary (HWND hwndDlg)

{

if (SecurityTokenLibraryPath[0] == 0)

{

HWND hParent = IsWindow (m_hwnd)? m_hwnd : GetActiveWindow();

if (!hParent)

hParent = GetForegroundWindow ();

throw UserAbort (SRC_POS);

}

if (hCursor != NULL)

SetCursor (hCursor);

};

try

{

}

catch (Exception &e)

{

e.Show (hwndDlg);

return TRUE;

}

std::vector <HostDevice> GetAvailableHostDevices (bool noDeviceProperties, bool singleList, bool noFloppy, bool detectUnencryptedFilesystems)

{

vector <HostDevice> devices;

size_t dev0;

for (int devNumber = 0; devNumber < MAX_HOST_DRIVE_NUMBER; devNumber++)

{

for (int partNumber = 0; partNumber < MAX_HOST_PARTITION_NUMBER; partNumber++)

{

OPEN_TEST_STRUCT openTest = {0};

{

if (partNumber == 0)

break;

device.Size = partInfo.PartitionLength.QuadPart;

}

else

{

if ( GetDriveGeometry (devPath, &deviceGeometry)

|| ((partNumber == 0) && GetPhysicalDriveGeometry (devNumber, &deviceGeometry))

)

{

}

}

device.HasUnencryptedFilesystem = (detectUnencryptedFilesystems && openTest.FilesystemDetected) ? true : false;

if (!noDeviceProperties)

{

if (driveNumber >= 0)

{

device.MountPoint += (wchar_t) (driveNumber + L'A');

device.ContainsSystem = true;

}

if (partNumber == 0 && GetDriveGeometry (devPath, &geometry))

}

if (partNumber == 0)

{

if (CurrentOSMajor >= 6)

{

for (int devNumber = 0; devNumber < 256; devNumber++)

{

OPEN_TEST_STRUCT openTest = {0};

continue;

DISK_PARTITION_INFO_STRUCT info;

if (GetDeviceInfo (devPath, &info) && info.IsDynamic)

device.HasUnencryptedFilesystem = (detectUnencryptedFilesystems && openTest.FilesystemDetected) ? true : false;

if (!noDeviceProperties)

{

if (driveNumber >= 0)

{

device.MountPoint += (wchar_t) (driveNumber + L'A');

return devices;

}

{

/* if it is already mounted, get the real path name used for mounting */

MOUNT_LIST_STRUCT mlist;

DWORD dwResult;

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

{

}

/* not mounted. Look for it in the local drives*/

{

{

{

}

}

}

return L"";

}

BOOL FileHasReadOnlyAttribute (const wchar_t *path)

{

DWORD attributes = GetFileAttributes (path);

return attributes != INVALID_FILE_ATTRIBUTES && (attributes & FILE_ATTRIBUTE_READONLY) != 0;

void CheckFilesystem (HWND hwndDlg, int driveNo, BOOL fixErrors)

{

wchar_t msg[1024], param[1024], cmdPath[MAX_PATH];

if (fixErrors && AskWarnYesNo ("FILESYS_REPAIR_CONFIRM_BACKUP", hwndDlg) == IDNO)

return;

ShellExecuteW (NULL, (!IsAdmin() && IsUacSupported()) ? L"runas" : L"open", cmdPath, param, NULL, SW_SHOW);

}

{

return FALSE;

for (size_t i = 0; i < bufferSize; ++i)

{

return TRUE;

}

return FALSE;

}

#ifndef SETUP

int AskNonSysInPlaceEncryptionResume (HWND hwndDlg, BOOL *pbDecrypt)

{

format = COMPRESSION_FORMAT_NONE;

return DeviceIoControl (file, FSCTL_SET_COMPRESSION, &format, sizeof (format), NULL, 0, &bytesOut, NULL);

}

BOOL VolumePathExists (const wchar_t *volumePath)

{

OPEN_TEST_STRUCT openTest = {0};

wchar_t upperCasePath[TC_MAX_PATH + 1];

UpperCaseCopy (upperCasePath, sizeof(upperCasePath), volumePath);

if (wcsstr (upperCasePath, L"\\DEVICE\\") == upperCasePath)

wstring path = volumePath;

if (path.find (L"\\\\?\\Volume{") == 0 && path.rfind (L"}\\") == path.size() - 2)

{

BOOL IsWindowsIsoBurnerAvailable ()

{

wchar_t path[MAX_PATH*2] = { 0 };

if (SUCCEEDED(SHGetFolderPath (NULL, CSIDL_SYSTEM, NULL, 0, path)))

{

StringCbCatW (path, MAX_PATH*2, L"\\" ISO_BURNER_TOOL);

BOOL LaunchWindowsIsoBurner (HWND hwnd, const wchar_t *isoPath)

{

wchar_t path[MAX_PATH*2] = { 0 };

if (SUCCEEDED(SHGetFolderPath (NULL, CSIDL_SYSTEM, NULL, 0, path)))

StringCbCatW (path, MAX_PATH*2, L"\\" ISO_BURNER_TOOL);

else

StringCbCopyW (path, MAX_PATH*2, L"C:\\Windows\\System32\\" ISO_BURNER_TOOL);

if (r <= 32)

{

handleWin32Error (hwnd, SRC_POS);

return FALSE;

}

return wstring();

}

BOOL IsApplicationInstalled (const wchar_t *appName, BOOL b32bitApp)

{

const wchar_t *uninstallRegName = L"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall";

return FALSE;

}

wchar_t regName[1024];

DWORD index = 0;

while (RegEnumKeyEx (unistallKey, index++, regName, &regNameSize, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)

{

if (wcsstr (regName, L"{") == regName)

return wstring (directory) + L"\\" + name;

}

{

HWND hCtrl = GetDlgItem (hwndDlg, ctrlId);

if (IsWindowEnabled (hCtrl) && IsWindowVisible (hCtrl))

{

wchar_t szTmp[MAX_PIM + 1] = {0};

{

wchar_t* endPtr = NULL;

pim = wcstol(szTmp, &endPtr, 10);

if (pim < 0 || endPtr == szTmp || !endPtr || *endPtr != L'\0')

}

}

return pim;

}

else

SetDlgItemText (hwndDlg, ctrlId, L"");

}

{

wchar_t tmp [MAX_PASSWORD + 1];

int utf8Len;

BOOL bRet = FALSE;

GetWindowText (GetDlgItem (hwndDlg, ctrlID), tmp, ARRAYSIZE (tmp));

utf8Len = WideCharToMultiByte (CP_UTF8, 0, tmp, -1, passValue, bufSize, NULL, NULL);

burn (tmp, sizeof (tmp));

if (utf8Len > 0)

{

{

passValue [0] = 0;

if (bShowError)

{

if (GetLastError () == ERROR_INSUFFICIENT_BUFFER)

else

Error ("PASSWORD_UTF8_INVALID", hwndDlg);

}

}

return bRet;

+ string (registerFilter ? "Add" : "Del") + "Reg=veracrypt_reg\r\n\r\n"

"[veracrypt_reg]\r\n"

"HKR,,\"" + filterReg + "\",0x0001" + string (registerFilter ? "0008" : "8002") + ",\"" + filter + "\"\r\n";

infFile.Close();

throw_sys_if (hInf == INVALID_HANDLE_VALUE);

}

HKEY OpenDeviceClassRegKey (const GUID *deviceClassGuid)

{

}

LSTATUS DeleteRegistryKey (HKEY hKey, LPCTSTR keyName)

{

}

HIMAGELIST CreateImageList(int cx, int cy, UINT flags, int cInitial, int cGrow)

{

}

int AddBitmapToImageList(HIMAGELIST himl, HBITMAP hbmImage, HBITMAP hbmMask)

{

}

HRESULT VCStrDupW(LPCWSTR psz, LPWSTR *ppwsz)

{

}

void ProcessEntropyEstimate (HWND hProgress, DWORD* pdwInitialValue, DWORD dwCounter, DWORD dwMaxLevel, DWORD* pdwEntropy)

*pdwEntropy = dwCounter - *pdwInitialValue;

else

*pdwEntropy = dwMaxLevel;

SendMessage (hProgress, PBM_SETPOS,

(WPARAM) (*pdwEntropy),

0);

}

void AllowMessageInUIPI (UINT msg)

{

}

{

if (buffer && bufferSize)

{

size_t i;

else

return FALSE;

}

BOOL TranslateVolumeID (HWND hwndDlg, wchar_t* pathValue, size_t cchPathValue)

{

BOOL bRet = TRUE;

size_t pathLen = pathValue? wcslen (pathValue) : 0;

if ((pathLen >= 3) && (_wcsnicmp (pathValue, L"ID:", 3) == 0))

{

if ( (pathLen == (3 + 2*VOLUME_ID_SIZE))

&& HexWideStringToArray (pathValue + 3, arr)

&& (arr.size() == VOLUME_ID_SIZE)

)

{

if (devicePath.length() > 0)

StringCchCopyW (pathValue, cchPathValue, devicePath.c_str());

else

{

return bRet;

}

BOOL CopyTextToClipboard (LPCWSTR txtValue)

{

size_t txtLen = wcslen(txtValue);

HGLOBAL hdst;

}

return FALSE;

}

{

HANDLE hToken;

TOKEN_PRIVILEGES tkp;

BOOL bRet = FALSE;

if (OpenProcessToken(GetCurrentProcess(),

TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,

&hToken))

{

&tkp.Privileges[0].Luid))

{

tkp.PrivilegeCount = 1;

dwLastError = GetLastError ();

}

else

dwLastError = GetLastError ();

}

return bStatus;

}

/*********************************************************************/

static BOOL GenerateRandomString (HWND hwndDlg, LPTSTR szName, DWORD maxCharsCount)

{

BOOL bRet = FALSE;

{

handleError (hwndDlg, (CryptoAPILastError == ERROR_SUCCESS)? ERR_RAND_INIT_FAILED : ERR_CAPI_INIT_FAILED, SRC_POS);

}

else

BYTE* indexes = (BYTE*) malloc (maxCharsCount + 1);

bRet = RandgetBytesFull (hwndDlg, indexes, maxCharsCount + 1, TRUE, TRUE);

if (bRet)

{

DWORD i, charsLen = (DWORD) _tcslen (chars);

DWORD effectiveLen = (indexes[0] % (64 - 16)) + 16; // random length between 16 to 64

effectiveLen = (effectiveLen > maxCharsCount)? maxCharsCount : effectiveLen;

szName[effectiveLen] = 0;

}

burn (indexes, maxCharsCount + 1);

free (indexes);

}

return bRet;

}

typedef struct

{

HDESK hDesk;

HINSTANCE hInstance;

LPCWSTR lpTemplateName;

DLGPROC lpDialogFunc;

LPARAM dwInitParam;

INT_PTR retValue;

} SecureDesktopThreadParam;