/*

Legal Notice: Some portions of the source code contained in this file were

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 all other portions of this file are Copyright (c) 2013-2016 IDRIX

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

BOOL bHistory = FALSE;

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

OSVersionEnum nCurrentOS = WIN_UNKNOWN;

int CurrentOSMajor = 0;

BOOL bInPlaceEncNonSysPending = FALSE; // TRUE if the non-system in-place encryption config file indicates that one or more partitions are scheduled to be encrypted. This flag is set only when config files are loaded during app startup.

BOOL PimEnable = FALSE;

BOOL KeyFilesEnable = FALSE;

KeyFile *FirstKeyFile = NULL;

HANDLE hDriver = INVALID_HANDLE_VALUE;

/* This mutex is used to prevent multiple instances of the wizard or main app from dealing with system encryption */

/* This mutex is used for non-system in-place encryption but only for informative (non-blocking) purposes,

such as whether an app should prompt the user whether to resume scheduled process. */

/* This value may changed only by calling ChangeSystemEncryptionStatus(). Only the wizard can change it

(others may still read it though). */

/* Only the wizard can change this value (others may only read it). */

WipeAlgorithmId nWipeMode = TC_WIPE_NONE;

#error PKCS5_BENCHMARKS and HASH_FNC_BENCHMARKS are both TRUE (at least one of them should be FALSE).

#endif

{

BENCHMARK_SORT_BY_NAME = 0,

BENCHMARK_SORT_BY_SPEED

};

{

int id;

wchar_t name[100];

#endif // #ifndef SETUP

{

void *strings;

BOOL bold;

/* Close the device driver handle */

if (hDriver != INVALID_HANDLE_VALUE)

{

if (IsNonInstallMode ())

{

// If a dismount was forced in the lifetime of the driver, Windows may later prevent it to be loaded again from

DWORD handleWin32Error (HWND hwndDlg, const char* srcPos)

{

PWSTR lpMsgBuf;

wchar_t szErrorValue[32];

wchar_t* pszDesc;

{

SIZE sizes;

TEXTMETRIC textMetrics;

SelectObject(hdc, (HGDIOBJ) hFont);

GetTextMetrics(hdc, &textMetrics); // Necessary for non-TrueType raster fonts (tmOverhang)

return ((int) sizes.cx - (int) textMetrics.tmOverhang);

}

int GetTextGfxHeight (HWND hwndDlgItem, const wchar_t *text, HFONT hFont)

{

SIZE sizes;

SelectObject(hdc, (HGDIOBJ) hFont);

GetTextExtentPoint32W (hdc, text, (int) wcslen (text), &sizes);

return ((int) sizes.cy);

}

rect.right = width;

rect.bottom = LONG_MAX;

SelectObject (hdc, (HGDIOBJ) hFont);

wchar_t pathBuf[TC_MAX_PATH];

if (DrawText (hdc, pathBuf, (int) path.size(), &rect, DT_CALCRECT | DT_MODIFYSTRING | DT_PATH_ELLIPSIS | DT_SINGLELINE) != 0)

newPath = pathBuf;

return newPath;

}

width = GetTextGfxWidth (hwndCtrl, text, hFont);

height = GetTextGfxHeight (hwndCtrl, text, hFont);

origWidth = rec.right;

origHeight = rec.bottom;

if (width >= 0

{

horizSubOffset = origWidth - width;

vertSubOffset = origHeight - height;

alignPosDiff = horizSubOffset / 2;

else if (windowInfo.dwStyle & SS_RIGHT)

alignPosDiff = horizSubOffset;

// Resize/move

if (alignPosDiff > 0)

{

// Protects an input field from having its content updated by a Paste action. Used for pre-boot password

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

void ToBootPwdField (HWND hwndDlg, UINT ctrlId)

{

if (hDC)

{

ScreenDPI = GetDeviceCaps (hDC, LOGPIXELSY);

}

DPIScaleFactorX = 1;

if (ScreenDPI != USER_DEFAULT_SCREEN_DPI)

{

// actual screen DPI is redundant and leads to incorrect results. What really matters here is

// how Windows actually renders our GUI. This is determined by comparing the expected and current

// sizes of a hidden calibration text field.

GetClientRect (GetDlgItem (hwndDlg, IDC_ABOUT_LOGO_AREA), &rec);

SetWindowPos (GetDlgItem (hwndDlg, IDC_ABOUT_BKG), HWND_TOP, 0, 0, rec.right, rec.bottom, SWP_NOMOVE);

if (ScreenDPI != USER_DEFAULT_SCREEN_DPI)

{

// Logo (must recreate and keep the original aspect ratio as Windows distorts it)

void ProcessPaintMessages (HWND hwnd, int maxMessagesToProcess)

{

MSG paintMsg;

while (PeekMessageW (&paintMsg, hwnd, 0, 0, PM_REMOVE | PM_QS_PAINT) != 0 && msgCounter-- > 0)

{

}

If bDirectRender is FALSE and both nWidth and nHeight are zero, the width and height of hwndDest are

retrieved and adjusted according to screen DPI (the width and height of the resultant image are adjusted the

same way); furthermore, if bKeepAspectRatio is TRUE, the smaller DPI factor of the two (i.e. horiz. or vert.)

is used both for horiz. and vert. scaling (note that the overall GUI aspect ratio changes irregularly in

This function returns a handle to the scaled bitmap. When the bitmap is no longer needed, it should be

- Windows 2000 may produce slightly inaccurate colors even when source, buffer, and target are 24-bit true color. */

HBITMAP RenderBitmap (wchar_t *resource, HWND hwndDest, int x, int y, int nWidth, int nHeight, BOOL bDirectRender, BOOL bKeepAspectRatio)

{

GetObject (picture, sizeof (BITMAP), &bitmap);

if (hdcRescaled)

{

SelectObject (hdcRescaled, hbmpRescaled);

hdcSrc,

0,

0,

bitmap.bmHeight,

SRCCOPY);

wc.hCursor = NULL;

wc.hbrBackground = (HBRUSH) GetStockObject (LTGRAY_BRUSH);

wc.lpszClassName = L"VCREDTICK";

rc = (ULONG) RegisterClassW (&wc);

return rc == 0 ? FALSE : TRUE;

{

if (!bHeaderWipe)

{

}

AddComboPair (hComboBox, GetString ("WIPE_MODE_1_RAND"), TC_WIPE_1_RAND);

else

lpack[0] = 0;

sprintf (url, TC_APPLINK_SECURE "&dest=err-report%s&os=%s&osver=%d.%d.%d&arch=%s&cpus=%d&app=%s&cksum=%x&dlg=%s&err=%x&addr=%x"

, lpack

, GetWindowsEdition().c_str()

// Mutex handling to prevent multiple instances of the wizard or main app from dealing with system encryption.

BOOL CreateSysEncMutex (void)

{

return TCCreateMutex (&hSysEncMutex, TC_MUTEX_NAME_SYSENC);

}

BOOL CreateNonSysInplaceEncMutex (void)

{

return TCCreateMutex (&hNonSysInplaceEncMutex, TC_MUTEX_NAME_NONSYS_INPLACE_ENC);

// Returns TRUE if another instance of the wizard is preparing, resuming or performing non-system in-place encryption

BOOL NonSysInplaceEncInProgressElsewhere (void)

{

&& MutexExistsOnSystem (TC_MUTEX_NAME_NONSYS_INPLACE_ENC));

}

// Mutex handling to prevent multiple instances of the wizard or main app from trying to install

// or register the driver or from trying to launch it in portable mode at the same time.

BOOL CreateDriverSetupMutex (void)

{

return TCCreateMutex (&hDriverSetupMutex, TC_MUTEX_NAME_DRIVER_SETUP);

}

BOOL TCCreateMutex (volatile HANDLE *hMutex, wchar_t *name)

{

if (*hMutex != NULL)

}

BOOL MutexExistsOnSystem (wchar_t *name)

{

if (name[0] == 0)

return FALSE;

if (GetLastError () == ERROR_ACCESS_DENIED) // On Vista, this is returned if the owner of the mutex is elevated while we are not

// The call failed and it is not certain whether the mutex exists or not

return FALSE;

void InitApp (HINSTANCE hInstance, wchar_t *lpszCommandLine)

{

WNDCLASSW wc;

InitOSVersionInfo();

LoadSystemDll (L"Usp10.DLL", &hUsp10Dll, TRUE, SRC_POS);

LoadSystemDll (L"UXTheme.dll", &hUXThemeDll, TRUE, SRC_POS);

LoadSystemDll (L"SETUPAPI.DLL", &hSetupDll, FALSE, SRC_POS);

LoadSystemDll (L"userenv.dll", &hUserenvDll, TRUE, SRC_POS);

LoadSystemDll (L"rsaenh.dll", &hRsaenhDll, TRUE, SRC_POS);

}

if (IsOSAtLeast (WIN_VISTA))

LoadSystemDll (L"netapi32.dll", &hnetapi32dll, TRUE, SRC_POS);

LoadSystemDll (L"authz.dll", &hauthzdll, TRUE, SRC_POS);

LoadSystemDll (L"xmllite.dll", &hxmllitedll, TRUE, SRC_POS);

}

if (IsOSAtLeast (WIN_VISTA))

LoadSystemDll (L"spp.dll", &hsppdll, TRUE, SRC_POS);

LoadSystemDll (L"vssapi.dll", &vssapidll, TRUE, SRC_POS);

LoadSystemDll (L"vsstrace.dll", &hvsstracedll, TRUE, SRC_POS);

LoadSystemDll (L"cfgmgr32.dll", &hcfgmgr32dll, TRUE, SRC_POS);

LoadSystemDll (L"devobj.dll", &hdevobjdll, TRUE, SRC_POS);

LoadSystemDll (L"powrprof.dll", &hpowrprofdll, TRUE, SRC_POS);

LoadSystemDll (L"dwmapi.dll", &hdwmapidll, TRUE, SRC_POS);

LoadSystemDll (L"crypt32.dll", &hcrypt32dll, TRUE, SRC_POS);

LoadSystemDll (L"bcrypt.dll", &hbcryptdll, TRUE, SRC_POS);

}

#else

LoadSystemDll (L"WINSCARD.DLL", &hwinscarddll, TRUE, SRC_POS);

#endif

LoadSystemDll (L"COMCTL32.DLL", &hComctl32Dll, FALSE, SRC_POS);

// call InitCommonControls function

InitCommonControlsFn = (InitCommonControlsPtr) GetProcAddress (hComctl32Dll, "InitCommonControls");

ImageList_AddFn = (ImageList_AddPtr) GetProcAddress (hComctl32Dll, "ImageList_Add");

// Language

langId[0] = 0;

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

if (langId[0] == 0)

{

if (IsNonInstallMode ())

}

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

wcex.lpfnWndProc = (WNDPROC) NonInstallUacWndProc;

wcex.hInstance = hInstance;

wcex.lpszClassName = L"VeraCrypt";

break;

}

}

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

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

{

&dwResult, NULL);

// check variable driver

&& ( (driver->bDetectTCBootLoader != TRUE && driver->bDetectTCBootLoader != FALSE) ||

(driver->TCBootLoaderDetected != TRUE && driver->TCBootLoaderDetected != FALSE) ||

(driver->DetectFilesystem != TRUE && driver->DetectFilesystem != FALSE) ||

else

return FALSE;

}

return TRUE;

}

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

in SysDriveDevicePath.

return code, you can use the global flags bSysPartitionSelected and bSysDriveSelected to see if the user

selected the system partition/device.

After this function completes successfully, the results are cached for the rest of the session and repeated

BOOL GetSysDevicePaths (HWND hwndDlg)

{

if (!bCachedSysDevicePathsValid

|| wcslen (SysDriveDevicePath) <= 1)

{

foreach (const HostDevice &device, GetAvailableHostDevices (false, true))

{

if (device.ContainsSystem)

}

if (IsOSAtLeast (WIN_7))

bCachedSysDevicePathsValid = 1;

}

&& wcslen (SysDriveDevicePath) > 1);

}

If it's FALSE and the function is called for the first time, execution may take up to one minute but the

results are reliable.

IMPORTANT: As the execution may take a very long time if called for the first time with bReliableRequired set

to TRUE, it should be called with bReliableRequired set to TRUE only before performing a dangerous

return code, you can use the global flags bSysPartitionSelected and bSysDriveSelected to see if the

user selected the system partition/device).

After this function completes successfully, the results are cached for the rest of the session, bReliableRequired

Return codes:

1 - it is the system partition path (e.g. \Device\Harddisk0\Partition1)

2 - it is the system drive path (e.g. \Device\Harddisk0\Partition0)

/* Determines whether the path points to a non-system partition on the system drive.

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

Return codes:

-1 - the result can't be determined, isn't reliable, or there was an error. */

int IsNonSysPartitionOnSysDrive (const wchar_t *path)

{

if (wcsncmp (tmpPath, SysDriveDevicePath, max (wcslen(tmpPath), wcslen(SysDriveDevicePath))) == 0)

{

return 1;

}

{

return 0;

}

}

LocalizeDialog (hwndDlg, "IDD_RAWDEVICES_DLG");

SendMessage (hList,LVM_SETEXTENDEDLISTVIEWSTYLE,0,

LvCol.pszText = GetString ("DEVICE");

LvCol.cx = CompensateXDPI (186);

LvCol.fmt = LVCFMT_LEFT;

SendMessage (hList,LVM_INSERTCOLUMNW,0,(LPARAM)&LvCol);

LvCol.cx = CompensateXDPI (38);

LvCol.fmt = LVCFMT_LEFT;

SendMessage (hList,LVM_INSERTCOLUMNW,1,(LPARAM)&LvCol);

// Path

if (!device.IsPartition || device.DynamicVolume)

{

&& (device.IsPartition || device.Partitions.empty() || device.Partitions[0].Size == 0)

)

continue;

if (line > 1)

{

ListItemAdd (hList, item.iItem, L"");

}

if (device.Floppy || device.DynamicVolume)

}

#endif

}

SendMessageW(hList, LVM_SETCOLUMNWIDTH, 0, MAKELPARAM(LVSCW_AUTOSIZE_USEHEADER, 0));

{

BOOL bEnableOkButton = FALSE;

LVITEM LvItem;

LvItem.iItem = ((LPNMLISTVIEW) lParam)->iItem;

LvItem.pszText = lpszFileName;

LvItem.cchTextMax = TC_MAX_PATH;

int selectedItem = ListView_GetSelectionMark (GetDlgItem (hwndDlg, IDC_DEVICELIST));

if (selectedItem == -1 || itemToDeviceMap.find (selectedItem) == itemToDeviceMap.end())

const HostDevice selectedDevice = itemToDeviceMap[selectedItem];

StringCchCopyW (lpszFileName, TC_MAX_PATH, selectedDevice.Path.c_str());

}

}

if (!selectedDevice.IsVirtualPartition

&& !bHiddenVolDirect)

{

#endif // #ifdef VOLFORMAT

}

bSysDriveSelected = FALSE;

#ifdef VOLFORMAT

if (hDriver == INVALID_HANDLE_VALUE)

return TRUE;

try

{

if (BootEncryption (NULL).GetStatus().DeviceFilterActive)

}

// Try to open a handle to the driver again (keep the mutex in case the other instance failed)

}

else

{

if (SystemEncryptionStatus != SYSENC_STATUS_NONE)

{

// This is an inconsistent state. The config file indicates system encryption should be

// the user selects "Last Known Good Configuration" from the Windows boot menu.

// To fix this, we're going to reinstall the driver, start it, and register it for boot.

return res;

bPortableModeConfirmed = TRUE;

if (hDriver != INVALID_HANDLE_VALUE)

CloseHandle (hDriver);

hDriver = CreateFile (WIN32_ROOT_PREFIX, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);

| OFN_PATHMUSTEXIST

| OFN_ALLOWMULTISELECT

| (keepHistory ? 0 : OFN_DONTADDTORECENT);

if (!keepHistory)

CleanLastVisitedMRU ();

CleanLastVisitedMRU ();

status = TRUE;

ret:

SystemFileSelectorCallPending = FALSE;

ResetCurrentDirectory();

}

{

switch(uMsg) {

{

/* WParam is TRUE since we are passing a path.

It would be FALSE if we were passing a pidl. */

break;

}

{

wchar_t szDir[TC_MAX_PATH];

/* Set the status window to the currently selected path. */

{

SendMessage (hwnd,BFFM_SETSTATUSTEXT,0,(LPARAM)szDir);

}

CoInitialize (NULL);

{

ZeroMemory (&bi, sizeof(bi));

bi.hwndOwner = hwndDlg;

bi.lParam = (LPARAM)dirName;

pidl = SHBrowseForFolderW (&bi);

{

{

bOK = TRUE;

}

// Font

SendMessageW (hwnd, WM_SETFONT, (WPARAM) font, 0);

return TRUE;

}

SetWindowTextW (hwnd, L"VeraCrypt");

else

SetWindowTextW (hwnd, GetString (stringId));

if (hUserFont != 0)

EnumChildWindows (hwnd, LocalizeDialogEnum, (LPARAM) hUserFont);

}

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

BOOL bToBeDeleted = FALSE;

if (bSetValue)

KEY_READ | KEY_WRITE | KEY_SET_VALUE, NULL, &hKey, NULL);

else

lStatus = RegOpenKeyExW (HKEY_CURRENT_USER, wszRegPath, 0, KEY_READ | KEY_WRITE | KEY_SET_VALUE, &hKey);

if (bToBeDeleted)

{

lStatus = RegOpenKeyExW (HKEY_CURRENT_USER, wszRegPath, 0, KEY_READ | KEY_WRITE | KEY_SET_VALUE, &hKey);

if (ERROR_SUCCESS == lStatus)

{

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

if (versionString[versionString.length()-1] == L'0')

return (versionString);

}

arr.clear();

if (len %2)

return false;

for (i = 0; i < len/2; i++)

{

if (!HexToByte (*hexStr++, b1) || !HexToByte (*hexStr++, b2))

{

static wchar_t *b, *kb, *mb, *gb, *tb, *pb;

static int serNo;

if (b == NULL || serNo != LocalizationSerialNo)

{

serNo = LocalizationSerialNo;

}

break;

}

/* Render the results */

SendMessage (hList,LVM_DELETEALLITEMS,0,(LPARAM)&LvItem);

LvItem.iItem = i;

LvItem.iSubItem = 0;

LvItem.pszText = (LPWSTR) benchmarkTable[i].name;

#if PKCS5_BENCHMARKS

wcscpy (item1, L"-");

LvItem.iSubItem = 1;

LvItem.pszText = item1;

#if PKCS5_BENCHMARKS

wcscpy (item1, L"-");

LvItem.iSubItem = 2;

LvItem.pszText = item1;

#if PKCS5_BENCHMARKS

swprintf (item1, L"%d t", benchmarkTable[i].encSpeed);

LvItem.iSubItem = 3;

LvItem.pszText = item1;

}

SendMessageW(hList, LVM_SETCOLUMNWIDTH, 0, MAKELPARAM(LVSCW_AUTOSIZE_USEHEADER, 0));

typedef struct

{

HWND hBenchDlg;

} BenchmarkThreadParam;

static BOOL PerformBenchmark(HWND hBenchDlg, HWND hwndDlg);

#if HASH_FNC_BENCHMARKS

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

them when building a public release (the benchmark GUI strings wouldn't make sense). */

{

sha256_ctx s256ctx;

int hid;

{

if (QueryPerformanceCounter (&performanceCountStart) == 0)

goto counter_error;

#elif PKCS5_BENCHMARKS // #if HASH_FNC_BENCHMARKS

/* Measures the time that it takes for the PKCS-5 routine to derive a header key using

them when building a public release (the benchmark GUI strings wouldn't make sense). */

{

int thid, i;

char dk[MASTER_KEYDATA_SIZE];

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"};

{

if (QueryPerformanceCounter (&performanceCountStart) == 0)

goto counter_error;

{

switch (thid)

{

#else // #elif PKCS5_BENCHMARKS

/* Encryption algorithm benchmarks */

for (ci->ea = EAGetFirst(); ci->ea != 0; ci->ea = EAGetNext(ci->ea))

{

if (!EAIsFormatEnabled (ci->ea))

return TRUE;

counter_error:

if (ci)

crypto_close (ci);

benchmarkSortMethod = BENCHMARK_SORT_BY_SPEED;

SendMessage (hList,LVM_SETEXTENDEDLISTVIEWSTYLE,0,

LvCol.pszText = GetString ("ALGORITHM");

LvCol.cx = CompensateXDPI (114);

LvCol.fmt = LVCFMT_LEFT;

SetTimer (hwndDlg, 0xfd, RANDPOOL_DISPLAY_REFRESH_INTERVAL, NULL);

SendMessage (GetDlgItem (hwndDlg, IDC_POOL_CONTENTS), WM_SETFONT, (WPARAM) hFixedDigitFont, (LPARAM) TRUE);

hEntropyBar = GetDlgItem (hwndDlg, IDC_ENTROPY_BAR);

SendMessage (hEntropyBar, PBM_SETRANGE32, 0, maxEntropyLevel);

SendMessage (hEntropyBar, PBM_SETSTEP, 1, 0);

else if (bUseMask)

{

/* use mask to compute a randomized ascii representation */

lastRandPool[row * RANDPOOL_DISPLAY_COLUMNS + col]) ^ maskRandPool [row * RANDPOOL_DISPLAY_COLUMNS + col];

tmp[0] = (wchar_t) (((tmpByte >> 4) % 6) + L'*');

tmp[1] = (wchar_t) (((tmpByte & 0x0F) % 6) + L'*');

SendMessage (hEntropyBar, PBM_SETSTEP, 1, 0);

SendMessage (hEntropyBar, PBM_SETSTATE, PBST_ERROR, 0);

{

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

EndDialog (hwndDlg, IDCLOSE);

else if (bUseMask)

{

/* use mask to compute a randomized ASCII representation */

lastRandPool[row * RANDPOOL_DISPLAY_COLUMNS + col]) ^ maskRandPool [row * RANDPOOL_DISPLAY_COLUMNS + col];

tmp[0] = (wchar_t) (((tmpByte >> 4) % 6) + L'*');

tmp[1] = (wchar_t) (((tmpByte & 0x0F) % 6) + L'*');

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

{

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

if (i > 0)

{

StringCbPrintfW(szSuffix, sizeof(szSuffix), L"_%d", i);

NormalCursor();

return 1;

}

/* since keyfilesSize < 1024 * 1024, we mask with 0x000FFFFF */

keyfilesSize = (long) (((unsigned long) keyfilesSize) & 0x000FFFFF);

keyfilesSize += 64;

}

if (!RandgetBytesFull (hwndDlg, keyfile, keyfilesSize, TRUE, TRUE))

{

_close (fhKeyfile);

TCfree(keyfile);

NormalCursor();

return 1;

/* Write the keyfile */

status = _write (fhKeyfile, keyfile, keyfilesSize);

NormalCursor();

handleWin32Error (hwndDlg, SRC_POS);

return 1;

}

TCfree(keyfile);

WaitCursor();

KillTimer (hwndDlg, 0xfd);

RandStop (FALSE);

#endif

/* Cleanup */

{

ShowWindow(GetDlgItem(hwndDlg, IDC_TESTS_MESSAGE), SW_SHOWNORMAL);

SetWindowTextW(GetDlgItem(hwndDlg, IDC_TESTS_MESSAGE), GetString ("TESTS_FAILED"));

else

{

ShowWindow(GetDlgItem(hwndDlg, IDC_TESTS_MESSAGE), SW_SHOWNORMAL);

inputtext[n] = (char) x;

}

// XTS

if (bXTSTestEnabled)

{

blockNo = (int) SendMessage (GetDlgItem (hwndDlg, IDC_TEST_BLOCK_NUMBER), CB_GETITEMDATA, SendMessage (GetDlgItem (hwndDlg, IDC_TEST_BLOCK_NUMBER), CB_GETCURSEL, 0, 0), 0);

} // if (bXTSTestEnabled)

/* Perform the actual tests */

{

char tmp[128];

int tmpRetVal;

return 0;

}

ResetCipherTest(HWND hwndDlg, int idTestCipher)

{

int ndx;

SetWindowText(GetDlgItem(hwndDlg, IDC_SECONDARY_KEY), L"0000000000000000000000000000000000000000000000000000000000000000");

SetWindowText(GetDlgItem(hwndDlg, IDC_TEST_DATA_UNIT_NUMBER), L"0");

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

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

pStr++;

pwStr++;

{

if (*pStr != 0)

{

hUserFont),

nLongestButtonCaptionWidth);

(int) wcslen ((const wchar_t *) (bResolve ? GetString(*pStr) : *pwStr)));

}

// Length of main message in characters (not bytes)

nMainTextLenInChars = (int) wcslen ((const wchar_t *) (bResolve ? GetString(*(pStrOrig+1)) : *(pwStrOrig+1)));

&& nMainTextLenInChars / nLongestButtonCaptionCharLen >= 10)

{

// Otherwise, it would look too tall (dialog boxes look better when they are more wide than tall).

nLongestButtonCaptionWidth = CompensateXDPI (max (

min (350, nMainTextLenInChars)));

}

do

{

(char *) L"\n",

offset + 1);

newLineSeqCount++;

// Reduction in height according to the number of shown buttons

vertSubOffset = ((MAX_MULTI_CHOICES - nActiveChoices) * nBaseButtonHeight);

|| vertOffset > 0)

{

// Resize/move each button if necessary

trec.right + 2 + horizSubOffset,

trec.bottom + 2,

TRUE);

GetWindowRect(GetDlgItem(hwndDlg, IDC_MC_DLG_HR2), &rec);

GetClientRect(GetDlgItem(hwndDlg, IDC_MC_DLG_HR2), &trec);

MoveWindow (GetDlgItem(hwndDlg, IDC_MC_DLG_HR2),

BOOL CheckCapsLock (HWND hwnd, BOOL quiet)

{

{

if (!quiet)

{

L".vb", L".vbe", L".vbs", L".vsmacros", L".vss", L".vst", L".vsw", L".ws", L".wsc", L".wsf", L".wsh", L".xsd", L".xsl",

// These additional file extensions are usually watched by antivirus programs

L".386", L".acm", L".ade", L".adp", L".ani", L".app", L".asd", L".asf", L".asx", L".awx", L".ax", L".boo", L".bz2", L".cdf",

L".j2k", L".jar", L".jff", L".jif", L".jmh", L".jng", L".jp2", L".jpe", L".jpeg", L".jpg", L".lsp", L".mod", L".nws",

L".obj", L".olb", L".osd", L".ov1", L".ov2", L".ov3", L".ovl", L".ovl", L".ovr", L".pdr", L".pgm", L".php", L".pkg",

L".pl", L".png", L".pot", L".pps", L".ppt", L".ps1", L".ps1xml", L".psc1", L".rar", L".rpl", L".rtf", L".sbf", L".script", L".sh", L".sha", L".shtm",

memcpy (wszLabel, prop.wszLabel, sizeof (wszLabel));

bDriverSetLabel = prop.bDriverSetLabel;

}

unmount.nDosDriveNo = nDosDriveNo;

unmount.ignoreOpenFiles = forced;

}

}

dbv.dbcv_reserved = 0;

dbv.dbcv_unitmask = driveMap;

UINT timeOut = 1000;

SetWindowLongPtrW (hProgress, GWL_STYLE, PBS_MARQUEE | GetWindowLongPtrW (hProgress, GWL_STYLE));

::SendMessageW(hProgress, PBM_SETMARQUEE, (WPARAM) TRUE, (LPARAM) 0);

}

// For now, we don't have system menu is the resources but we leave this code

// if it is enabled in the future

HICON hIcon = (HICON)::LoadImage(hInst, MAKEINTRESOURCE(IDI_TRUECRYPT_ICON), IMAGE_ICON, ::GetSystemMetrics(SM_CXICON), ::GetSystemMetrics(SM_CYICON), LR_DEFAULTCOLOR);

::SendMessage(hwndDlg, WM_SETICON, TRUE, (LPARAM)hIcon);

HICON hIconSmall = (HICON)::LoadImage(hInst, MAKEINTRESOURCE(IDI_TRUECRYPT_ICON), IMAGE_ICON, ::GetSystemMetrics(SM_CXSMICON), ::GetSystemMetrics(SM_CYSMICON), LR_DEFAULTCOLOR);

LocalizeDialog (hwndDlg, NULL);

_beginthread(WaitThread, 0, thParam);

void BringToForeground(HWND hWnd)

{

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

DWORD lockTimeOut = 0;

HWND hCurrWnd = ::GetForegroundWindow();

DWORD dwThisTID = ::GetCurrentThreadId(),

dwCurrTID = ::GetWindowThreadProcessId(hCurrWnd,0);

if (hCurrWnd != hWnd)

{

if(dwThisTID != dwCurrTID)

{

::AttachThreadInput(dwThisTID, dwCurrTID, TRUE);

::SystemParametersInfo(SPI_GETFOREGROUNDLOCKTIMEOUT,0,&lockTimeOut,0);

::SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT,0,0,SPIF_SENDWININICHANGE | SPIF_UPDATEINIFILE);

::AllowSetForegroundWindow(ASFW_ANY);

}

::SetForegroundWindow(hWnd);

if(dwThisTID != dwCurrTID)

{

::SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT,0,(PVOID)lockTimeOut,SPIF_SENDWININICHANGE | SPIF_UPDATEINIFILE);

CreateFullVolumePath (pmount->wszVolume, sizeof(pmount->wszVolume), devicePath.c_str(), &bDevice);

}

}

return DeviceIoControl (hDriver, TC_IOCTL_MOUNT_VOLUME, pmount,

sizeof (MOUNT_STRUCT), pmount, sizeof (MOUNT_STRUCT), pdwResult, NULL);

}

// in wait dialog mechanism

typedef struct

path = path.substr (4);

StringCchCopyW (volumePath, TC_MAX_PATH, path.c_str());

}

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

{

wstring resolvedPath = VolumeGuidPathToDevicePath (path);

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

{

std::vector<byte> arr;

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

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

)

mount.BytesPerSector = bps;

mount.BytesPerPhysicalSector = bps;

}

if (IsOSAtLeast (WIN_VISTA))

{

if ( (wcslen(root) >= 2)

goto retry;

}

if (IDYES == AskWarnNoYes ("FILE_IN_USE", hwndDlg))

{

mount.bExclusiveAccess = FALSE;

{

if (mount.nReturnCode == ERR_PASSWORD_WRONG)

{

if (bReportWrongPassword)

{

IncreaseWrongPwdRetryCount (1); // We increase the count here only if bReportWrongPassword is TRUE, because "Auto-Mount All Devices" and other callers do it separately

&& !mount.UseBackupHeader)

{

// Retry using embedded header backup (if any)

if (bReportWrongPassword && !Silent)

Warning ("HEADER_DAMAGED_AUTO_USED_HEADER_BAK", hwndDlg);

}

LastMountedVolumeDirty = mount.FilesystemDirty;

if (mount.FilesystemDirty)

}

else

{

}

SetLastError (param.dwLastError);

Error ("UNMOUNT_FAILED", hwndDlg);

return FALSE;

BroadcastDeviceChange (DBT_DEVICEREMOVECOMPLETE, nDosDriveNo, 0);

return TRUE;

ZeroMemory (diskGeometry, sizeof (DISK_GEOMETRY));

if ( DeviceIoControl (hDev, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, diskGeometry, sizeof (DISK_GEOMETRY), &bytesRead, NULL)

&& diskGeometry->BytesPerSector)

{

bResult = TRUE;

// Returns the free space on the specified partition (volume) in bytes. If the 'occupiedBytes' pointer

// is not NULL, size of occupied space (in bytes) is written to the pointed location. In addition, if the

// returns -1.

__int64 GetStatsFreeSpaceOnPartition (const wchar_t *devicePath, float *percentFree, __int64 *occupiedBytes, BOOL silent)

{

return INVALID_HANDLE_VALUE;

// If we fail, we will dismount anyway even if it needs to be forced.

CloseVolumeExplorerWindows (MainDlg, driveLetterNo);

&& attempt > 0)

{

Sleep (UNMOUNT_AUTO_RETRY_DELAY);

attempt = UNMOUNT_MAX_AUTO_RETRIES;

&& attempt > 0)

{

Sleep (UNMOUNT_AUTO_RETRY_DELAY);

}

// Returns -1 if the specified string is not found in the buffer. Otherwise, returns the

// which do NOT terminate them.

int64 FindString (const char *buf, const char *str, int64 bufLen, int64 strLen, int64 startOffset)

{

|| strLen > bufLen

|| bufLen < 1

|| strLen < 1

// Searches the file from its end for the LAST occurrence of the string str.

// The string may contain zeroes, which do NOT terminate the string.

// If the string isn't found or if any error occurs, -1 is returned.

__int64 FindStringInFile (const wchar_t *filePath, const char* str, int strLen)

{

int filePosStep;

__int64 retVal = -1;

|| strLen > bufSize

|| strLen < 1)

{

if (SetFilePointerEx (src, seekOffset, &seekOffsetNew, FILE_BEGIN) == 0)

goto fsif_end;

|| bytesRead == 0)

goto fsif_end;

return TCCopyFileBase (src, dst);

}

// is replaced. If an error occurs, the incomplete file is deleted (provided that bAppend is FALSE).

BOOL SaveBufferToFile (const char *inputBuffer, const wchar_t *destinationFile, DWORD inputLength, BOOL bAppend, BOOL bRenameIfFailed)

{

}

}

}

if (dst == INVALID_HANDLE_VALUE)

{

SetLastError (dwLastError);

{

// If CREATE_ALWAYS is used, ERROR_ALREADY_EXISTS is returned after successful overwrite

// of an existing file (it's not an error)

handleWin32Error (MainDlg, SRC_POS);

}

// Prints a UTF-16 text (note that this involves a real printer, not a screen).

// textByteLen - length of the text in bytes

BOOL PrintHardCopyTextUTF16 (wchar_t *text, wchar_t *title, size_t textByteLen)

{

wchar_t cl [MAX_PATH*3] = {L"/p \""};

else

{

// This is also returned if we fail to determine the status (it does not mean that portable mode is disproved).

}

}

else

if (FileExists (path))

{

// To maintain consistency and safety, if the system encryption config file exits, we cannot

// "Last Known Good Configuration" from the Windows boot menu.)

// However, if UAC elevation is needed, we have to confirm portable mode first (after we are elevated, we won't).

}

// As the driver was not found in the system path, we can predict that we will run in portable mode

}

else

CloseHandle (hDriverTmp);

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

{

{

char buf[65536], bufout[sizeof (buf)];

li.mask = LVIF_TEXT;

li.pszText = (wchar_t*) string;

li.iSubItem = 0;

return ListView_InsertItem (list, &li);

}

li.mask = LVIF_TEXT;

li.pszText = (wchar_t*) string;

li.iSubItem = subIndex;

return ListView_SetItem (list, &li);

}

if (SetFilePointerEx (src, seekOffset, &seekOffsetNew, FILE_BEGIN) == 0)

goto fsif_end;

|| bytesRead != bufSize)

goto fsif_end;

if (SetFilePointerEx (src, seekOffset, &seekOffsetNew, FILE_BEGIN) == 0)

goto fsif_end;

|| bytesRead != bufSize)

goto fsif_end;

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

{

wchar_t sysPath[TC_MAX_PATH];

if (Is64BitOs() && useLegacy)

{

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

return;

}

ZeroMemory (&tnid, sizeof (tnid));

//tnid.uVersion = (IsOSAtLeast (WIN_VISTA) ? NOTIFYICON_VERSION_4 : NOTIFYICON_VERSION);

//Shell_NotifyIconW (NIM_SETVERSION, &tnid);

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

tnid.uTimeout = (IsOSAtLeast (WIN_VISTA) ? 1000 : 5000); // in ms

// Either of the pointers may be NULL

void InfoBalloon (char *headingStringId, char *textStringId, HWND hwnd)

{

return;

TaskBarIconDisplayBalloonTooltip (hwnd,

FALSE);

}

// Either of the pointers may be NULL

void InfoBalloonDirect (wchar_t *headingString, wchar_t *textString, HWND hwnd)

{

return;

TaskBarIconDisplayBalloonTooltip (hwnd,

FALSE);

}

// Either of the pointers may be NULL

void WarningBalloon (char *headingStringId, char *textStringId, HWND hwnd)

{

return;

TaskBarIconDisplayBalloonTooltip (hwnd,

TRUE);

}

// Either of the pointers may be NULL

void WarningBalloonDirect (wchar_t *headingString, wchar_t *textString, HWND hwnd)

{

return;

TaskBarIconDisplayBalloonTooltip (hwnd,

TRUE);

}

params.strings = &strings[0];

params.bold = bBold;

MAKEINTRESOURCEW (IDD_MULTI_CHOICE_DLG), hwnd,

(DLGPROC) MultiChoiceDialogProc, (LPARAM) &params);

}

BOOL ConfigWriteBegin ()

{

DWORD size;

return FALSE;

if (ConfigBuffer == NULL)

*pbModified = TRUE;

if (!bOnlyCheckModified)

ConfigReadString (configKey, defaultValue, str, maxLen);

}

}

char *xml = defaultKeyfilesFile;

KeyFile *kf;

return FALSE;

KeyFileRemoveAll (&defaultKeyFilesParam.FirstKeyFile);

}

// there's an error, returns FALSE.

BOOL IsHiddenOSRunning (void)

{

BOOL RestartComputer (void)

{

if (!OpenProcessToken (GetCurrentProcess (), TOKEN_QUERY|TOKEN_ADJUST_PRIVILEGES, &hTkn))

{

}

{

CloseHandle(hTkn);

}

if (!ExitWindowsEx (EWX_REBOOT,

{

CloseHandle(hTkn);

}

CloseHandle(hTkn);

osname += L"-server";

if (IsOSAtLeast (WIN_VISTA))

if (home)

osname += L"-home";

else if (wcsstr (productName, L"Standard") != 0)

0, KEY_READ, &hkey) != ERROR_SUCCESS)

return;

&& value != 0)

{

Warning ("SYS_AUTOMOUNT_DISABLED", hwnd);

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

{

HRSRC hRes;

hRes = FindResource (NULL, MAKEINTRESOURCE(resourceId), resourceType);

if (size != NULL)

*size = SizeofResource (NULL, hRes);

return (BYTE *) LockResource (hResL);

}

if (context->IsDevice)

{

// accidentally quick-formats a dismounted partition-hosted TrueCrypt volume as NTFS, etc.)

DeviceIoControl (context->HostFileHandle, FSCTL_ALLOW_EXTENDED_DASD_IO, NULL, 0, NULL, 0, &dwResult, NULL);

&& context->IsDevice)

{

// If FSCTL_ALLOW_EXTENDED_DASD_IO failed and there is a live filesystem on the partition, then the

// shorter than the partition). This can happen for example after the user quick-formats a dismounted

// partition-hosted TrueCrypt volume and then tries to read the embedded backup header.

int ReEncryptVolumeHeader (HWND hwndDlg, char *buffer, BOOL bBoot, CRYPTO_INFO *cryptoInfo, Password *password, int pim, BOOL wipeMode)

{

CRYPTO_INFO *newCryptoInfo = NULL;

RandSetHashFunction (cryptoInfo->pkcs5);

if (Randinit() != ERR_SUCCESS)

wchar_t data[65536];

DWORD size = sizeof (data);

if (IsPagingFileWildcardActive())

return TRUE;

}

HANDLE handle = CreateFile (drivePath.c_str(), GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);

if (handle == INVALID_HANDLE_VALUE)

continue;

path[0] = drive;

handle = CreateFile (path.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);

if (handle != INVALID_HANDLE_VALUE)

CloseHandle (handle);

else if (GetLastError() == ERROR_SHARING_VIOLATION)

WCHAR wbuf[65536];

int wideLen = MultiByteToWideChar (CP_ACP, 0, singleString.c_str(), -1, wbuf, array_capacity (wbuf) - 1);

// We don't throw exception here and only return empty string.

// All calls to this function use valid strings.

// throw_sys_if (wideLen == 0);

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

{

WORD lw = LOWORD (wParam);

switch (msg)

{

wchar_t tmp[SecurityToken::MaxPasswordLength+1];

wmemset (tmp, 'X', SecurityToken::MaxPasswordLength);

tmp[SecurityToken::MaxPasswordLength] = 0;

EndDialog (hwndDlg, lw);

}

foreach (const SecurityTokenKeyfile &keyfile, keyfiles)

{

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

wstringstream s;

s << keyfile.SlotId;

LocalizeDialog (hwndDlg, selectedTokenKeyfiles ? "SELECT_TOKEN_KEYFILES" : "IDD_TOKEN_KEYFILES");

SendMessage (tokenListControl,LVM_SETEXTENDEDLISTVIEWSTYLE, 0,

LvCol.pszText = GetString ("TOKEN_SLOT_ID");

LvCol.cx = CompensateXDPI (40);

LvCol.fmt = LVCFMT_CENTER;

return 1;

}

}

SecurityTokenKeyfileDlgFillList (hwndDlg, keyfiles);

return 1;

}

foreach (const SecurityTokenKeyfile &keyfile, SecurityTokenKeyfileDlgGetSelected (hwndDlg, keyfiles))

{

selectedTokenKeyfiles->push_back (SecurityTokenKeyfilePath (keyfile));

}

EndDialog (hwndDlg, IDOK);

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

)

{

* (LONGLONG) deviceGeometry.SectorsPerTrack * (LONGLONG) deviceGeometry.TracksPerCylinder;

}

}

return IDYES;

default:

break;

}

char *multiChoiceStr[] = { 0, "ASK_NONSYS_INPLACE_ENC_NOTIFICATION_REMOVAL", "DO_NOT_PROMPT_ME", "KEEP_PROMPTING_ME", 0 };

HWND hWnd;

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

winClass.lpfnWndProc = (WNDPROC) EnableElevatedCursorChangeWndProc;

winClass.hInstance = hInst;

winClass.lpszClassName = className;

return TRUE;

format = COMPRESSION_FORMAT_NONE;

}

}

else

{

&& (dwCounter - *pdwInitialValue) <= dwMaxLevel)

*pdwEntropy = dwCounter - *pdwInitialValue;

else

SendMessage (hProgress, PBM_SETSTATE, state, 0);

}

(WPARAM) (*pdwEntropy),

0);

}

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

{

std::vector<byte> arr;

&& HexWideStringToArray (pathValue + 3, arr)

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

)

bRet = FALSE;

}

}

return bRet;

}