/*

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

derived from the source code of TrueCrypt 7.1a, which is

Copyright (c) 2003-2012 TrueCrypt Developers Association and which is

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

code distribution packages. */

#include "Tcdefs.h"

#include <windowsx.h>

#include <dbghelp.h>

#include <dbt.h>

#include <Setupapi.h>

#include <aclapi.h>

#include <fcntl.h>

#include <io.h>

#include <math.h>

#include <shlobj.h>

#include <shlwapi.h>

#include <sys/stat.h>

#include <stdlib.h>

#include <time.h>

#include <tchar.h>

#include <Richedit.h>

#if defined (TCMOUNT) || defined (VOLFORMAT)

#include <process.h>

#include <Tlhelp32.h>

#endif

#include "Resource.h"

#include "Platform/Finally.h"

#include "Platform/ForEach.h"

#include "Apidrvr.h"

#include "BootEncryption.h"

#include "Combo.h"

#include "Crc.h"

#include "Crypto.h"

#include "Dictionary.h"

#include "Dlgcode.h"

#include "EncryptionThreadPool.h"

#include "Endian.h"

#include "Format/Inplace.h"

#include "Language.h"

#include "Keyfiles.h"

#include "Pkcs5.h"

#include "Random.h"

#include "Registry.h"

#include "SecurityToken.h"

#include "Tests.h"

#include "Volumes.h"

#include "Wipe.h"

#include "Xml.h"

#include "Xts.h"

#include "Boot/Windows/BootCommon.h"

#include "Progress.h"

#include "zip.h"

#include "rdrand.h"

#include "jitterentropy.h"

#ifdef TCMOUNT

#include "Mount/Mount.h"

#include "Mount/resource.h"

#endif

#ifdef VOLFORMAT

#include "Format/Tcformat.h"

#endif

#ifdef SETUP

#include "Setup/Setup.h"

#endif

#include <Setupapi.h>

#include <Softpub.h>

#include <WinTrust.h>

#include <strsafe.h>

#define _WIN32_DCOM

#include <comdef.h>

#include <Wbemidl.h>

#pragma comment(lib, "wbemuuid.lib")

#pragma comment( lib, "setupapi.lib" )

#ifndef TTI_INFO_LARGE

#define TTI_INFO_LARGE 4

#endif

#ifndef TTI_WARNING_LARGE

#define TTI_WARNING_LARGE 5

#endif

#ifndef TTI_ERROR_LARGE

#define TTI_ERROR_LARGE 6

#endif

/* GPT Partition Type GUIDs */

#define LOCAL_DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) const GUID name = {l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8}

LOCAL_DEFINE_GUID(PARTITION_ENTRY_UNUSED_GUID, 0x00000000L, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00); // Entry unused

LOCAL_DEFINE_GUID(PARTITION_SYSTEM_GUID, 0xC12A7328L, 0xF81F, 0x11D2, 0xBA, 0x4B, 0x00, 0xA0, 0xC9, 0x3E, 0xC9, 0x3B); // EFI system partition

LOCAL_DEFINE_GUID(PARTITION_MSFT_RESERVED_GUID, 0xE3C9E316L, 0x0B5C, 0x4DB8, 0x81, 0x7D, 0xF9, 0x2D, 0xF0, 0x02, 0x15, 0xAE); // Microsoft reserved space

LOCAL_DEFINE_GUID(PARTITION_BASIC_DATA_GUID, 0xEBD0A0A2L, 0xB9E5, 0x4433, 0x87, 0xC0, 0x68, 0xB6, 0xB7, 0x26, 0x99, 0xC7); // Basic data partition

LOCAL_DEFINE_GUID(PARTITION_LDM_METADATA_GUID, 0x5808C8AAL, 0x7E8F, 0x42E0, 0x85, 0xD2, 0xE1, 0xE9, 0x04, 0x34, 0xCF, 0xB3); // Logical Disk Manager metadata partition

LOCAL_DEFINE_GUID(PARTITION_LDM_DATA_GUID, 0xAF9B60A0L, 0x1431, 0x4F62, 0xBC, 0x68, 0x33, 0x11, 0x71, 0x4A, 0x69, 0xAD); // Logical Disk Manager data partition

LOCAL_DEFINE_GUID(PARTITION_MSFT_RECOVERY_GUID, 0xDE94BBA4L, 0x06D1, 0x4D40, 0xA1, 0x6A, 0xBF, 0xD5, 0x01, 0x79, 0xD6, 0xAC); // Microsoft recovery partition

LOCAL_DEFINE_GUID(PARTITION_CLUSTER_GUID, 0xdb97dba9L, 0x0840, 0x4bae, 0x97, 0xf0, 0xff, 0xb9, 0xa3, 0x27, 0xc7, 0xe1); // Cluster metadata partition

#ifndef PROCESSOR_ARCHITECTURE_ARM64

#define PROCESSOR_ARCHITECTURE_ARM64 12

#endif

#ifndef IMAGE_FILE_MACHINE_ARM64

#define IMAGE_FILE_MACHINE_ARM64 0xAA64

#endif

using namespace VeraCrypt;

LONG DriverVersion;

char *LastDialogId;

wchar_t szHelpFile[TC_MAX_PATH];

wchar_t szHelpFile2[TC_MAX_PATH];

wchar_t SecurityTokenLibraryPath[TC_MAX_PATH];

char CmdTokenPin [TC_MAX_PATH] = {0};

HFONT hFixedDigitFont = NULL;

HFONT hBoldFont = NULL;

HFONT hTitleFont = NULL;

HFONT hFixedFont = NULL;

HFONT hUserFont = NULL;

HFONT hUserUnderlineFont = NULL;

HFONT hUserBoldFont = NULL;

HFONT hUserUnderlineBoldFont = NULL;

HFONT WindowTitleBarFont;

WCHAR EditPasswordChar = 0;

int ScreenDPI = USER_DEFAULT_SCREEN_DPI;

double DPIScaleFactorX = 1;

double DPIScaleFactorY = 1;

double DlgAspectRatio = 1;

HWND MainDlg = NULL;

wchar_t *lpszTitle = NULL;

BOOL Silent = FALSE;

BOOL bPreserveTimestamp = TRUE;

BOOL bShowDisconnectedNetworkDrives = FALSE;

BOOL bHideWaitingDialog = FALSE;

BOOL bCmdHideWaitingDialog = FALSE;

BOOL bCmdHideWaitingDialogValid = FALSE;

BOOL bUseSecureDesktop = FALSE;

BOOL bUseLegacyMaxPasswordLength = FALSE;

BOOL bCmdUseSecureDesktop = FALSE;

BOOL bCmdUseSecureDesktopValid = FALSE;

BOOL bStartOnLogon = FALSE;

BOOL bMountDevicesOnLogon = FALSE;

BOOL bMountFavoritesOnLogon = FALSE;

BOOL bHistory = FALSE;

#ifndef SETUP

BOOL bLanguageSetInSetup = FALSE;

#else

extern BOOL bMakePackage;

#endif

#ifdef TCMOUNT

extern BOOL ServiceMode;

#endif

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

int CurrentOSBuildNumber = 0;

BOOL RemoteSession = FALSE;

BOOL UacElevated = FALSE;

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

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.

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

BOOL PimEnable = FALSE;

BOOL KeyFilesEnable = FALSE;

KeyFile *FirstKeyFile = NULL;

KeyFilesDlgParam defaultKeyFilesParam = {0};

BOOL IgnoreWmDeviceChange = FALSE;

BOOL DeviceChangeBroadcastDisabled = FALSE;

BOOL LastMountedVolumeDirty;

BOOL MountVolumesAsSystemFavorite = FALSE;

BOOL FavoriteMountOnArrivalInProgress = FALSE;

BOOL MultipleMountOperationInProgress = FALSE;

volatile BOOL NeedPeriodicDeviceListUpdate = FALSE;

BOOL DisablePeriodicDeviceListUpdate = FALSE;

BOOL EnableMemoryProtection = FALSE;

BOOL WaitDialogDisplaying = FALSE;

/* Handle to the device driver */

HANDLE hDriver = INVALID_HANDLE_VALUE;

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

volatile HANDLE hSysEncMutex = NULL;

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

volatile HANDLE hNonSysInplaceEncMutex = NULL;

/* This mutex is used 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. */

volatile HANDLE hDriverSetupMutex = NULL;

/* This mutex is used to prevent users from running the main TrueCrypt app or the wizard while an instance

of the TrueCrypt installer is running (which is also useful for enforcing restart before the apps can be used). */

volatile HANDLE hAppSetupMutex = NULL;

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

CRITICAL_SECTION csWNetCalls;

/* Critical section used to protect access to global list of physical drives */

CRITICAL_SECTION csMountableDevices;

CRITICAL_SECTION csVolumeIdCandidates;

static std::vector<HostDevice> mountableDevices;

static std::vector<HostDevice> rawHostDeviceList;

/* Critical section used to ensure that only one thread at a time can create a secure desktop */

CRITICAL_SECTION csSecureDesktop;

/* Boolean that indicates if our Secure Desktop is active and being used or not */

volatile BOOL bSecureDesktopOngoing = FALSE;

TCHAR SecureDesktopName[65];

HINSTANCE hInst = NULL;

HCURSOR hCursor = NULL;

ATOM hDlgClass, hSplashClass;

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

(others may still read it though). */

int SystemEncryptionStatus = SYSENC_STATUS_NONE;

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

WipeAlgorithmId nWipeMode = TC_WIPE_NONE;

BOOL bSysPartitionSelected = FALSE; /* TRUE if the user selected the system partition via the Select Device dialog */

BOOL bSysDriveSelected = FALSE; /* TRUE if the user selected the system drive via the Select Device dialog */

/* To populate these arrays, call GetSysDevicePaths(). If they contain valid paths, bCachedSysDevicePathsValid is TRUE. */

wchar_t SysPartitionDevicePath [TC_MAX_PATH];

wchar_t SysDriveDevicePath [TC_MAX_PATH];

wstring ExtraBootPartitionDevicePath;

char bCachedSysDevicePathsValid = FALSE;

BOOL bHyperLinkBeingTracked = FALSE;

int WrongPwdRetryCounter = 0;

static FILE *ConfigFileHandle;

char *ConfigBuffer;

BOOL SystemFileSelectorCallPending = FALSE;

DWORD SystemFileSelectorCallerThreadId;

#define RANDPOOL_DISPLAY_REFRESH_INTERVAL 30

#define RANDPOOL_DISPLAY_ROWS 16

#define RANDPOOL_DISPLAY_COLUMNS 20

HMODULE hRichEditDll = NULL;

HMODULE hComctl32Dll = NULL;

HMODULE hSetupDll = NULL;

HMODULE hShlwapiDll = NULL;

HMODULE hProfApiDll = NULL;

HMODULE hUsp10Dll = NULL;

HMODULE hCryptSpDll = NULL;

HMODULE hUXThemeDll = NULL;

HMODULE hUserenvDll = NULL;

HMODULE hRsaenhDll = NULL;

HMODULE himm32dll = NULL;

HMODULE hMSCTFdll = NULL;

HMODULE hfltlibdll = NULL;

HMODULE hframedyndll = NULL;

HMODULE hpsapidll = NULL;

HMODULE hsecur32dll = NULL;

HMODULE hnetapi32dll = NULL;

HMODULE hauthzdll = NULL;

HMODULE hxmllitedll = NULL;

HMODULE hmprdll = NULL;

HMODULE hsppdll = NULL;

HMODULE vssapidll = NULL;

HMODULE hvsstracedll = NULL;

HMODULE hcfgmgr32dll = NULL;

HMODULE hdevobjdll = NULL;

HMODULE hpowrprofdll = NULL;

HMODULE hsspiclidll = NULL;

HMODULE hcryptbasedll = NULL;

HMODULE hdwmapidll = NULL;

HMODULE hmsasn1dll = NULL;

HMODULE hcrypt32dll = NULL;

HMODULE hbcryptdll = NULL;

HMODULE hbcryptprimitivesdll = NULL;

HMODULE hMsls31 = NULL;

HMODULE hntmartadll = NULL;

HMODULE hwinscarddll = NULL;

HMODULE hmsvcrtdll = NULL;

HMODULE hWinTrustLib = NULL;

HMODULE hAdvapi32Dll = NULL;

#define FREE_DLL(h) if (h) { FreeLibrary (h); h = NULL;}

#ifndef BASE_SEARCH_PATH_ENABLE_SAFE_SEARCHMODE

#define BASE_SEARCH_PATH_ENABLE_SAFE_SEARCHMODE 0x00000001

#endif

#ifndef BASE_SEARCH_PATH_PERMANENT

#define BASE_SEARCH_PATH_PERMANENT 0x00008000

#endif

#ifndef LOAD_LIBRARY_SEARCH_SYSTEM32

#define LOAD_LIBRARY_SEARCH_SYSTEM32 0x00000800

#endif

typedef BOOL (WINAPI *SetDllDirectoryPtr)(LPCWSTR lpPathName);

typedef BOOL (WINAPI *SetSearchPathModePtr)(DWORD Flags);

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

typedef void (WINAPI *InitCommonControlsPtr)(void);

typedef HIMAGELIST (WINAPI *ImageList_CreatePtr)(int cx, int cy, UINT flags, int cInitial, int cGrow);

typedef int (WINAPI *ImageList_AddPtr)(HIMAGELIST himl, HBITMAP hbmImage, HBITMAP hbmMask);

typedef VOID (WINAPI *SetupCloseInfFilePtr)(HINF InfHandle);

typedef HKEY (WINAPI *SetupDiOpenClassRegKeyPtr)(CONST GUID *ClassGuid,REGSAM samDesired);

typedef BOOL (WINAPI *SetupInstallFromInfSectionWPtr)(HWND,HINF,PCWSTR,UINT,HKEY,PCWSTR,UINT,PSP_FILE_CALLBACK_W,PVOID,HDEVINFO,PSP_DEVINFO_DATA);

typedef HINF (WINAPI *SetupOpenInfFileWPtr)(PCWSTR FileName,PCWSTR InfClass,DWORD InfStyle,PUINT ErrorLine);

typedef LSTATUS (STDAPICALLTYPE *SHDeleteKeyWPtr)(HKEY hkey, LPCWSTR pszSubKey);

typedef HRESULT (STDAPICALLTYPE *SHStrDupWPtr)(LPCWSTR psz, LPWSTR *ppwsz);

typedef HRESULT (STDAPICALLTYPE *UrlUnescapeWPtr)(

PWSTR pszUrl,

PWSTR pszUnescaped,

DWORD *pcchUnescaped,

DWORD dwFlags

);

// ChangeWindowMessageFilter

typedef BOOL (WINAPI *ChangeWindowMessageFilterPtr) (UINT, DWORD);

typedef BOOL (WINAPI *CreateProcessWithTokenWFn)(

__in HANDLE hToken,

__in DWORD dwLogonFlags,

__in_opt LPCWSTR lpApplicationName,

__inout_opt LPWSTR lpCommandLine,

__in DWORD dwCreationFlags,

__in_opt LPVOID lpEnvironment,

__in_opt LPCWSTR lpCurrentDirectory,

__in LPSTARTUPINFOW lpStartupInfo,

__out LPPROCESS_INFORMATION lpProcessInformation

);

typedef HRESULT (WINAPI *IUnknown_QueryServiceFn)(

__in IUnknown* punk,

__in REFGUID guidService,

__in REFIID riid,

__deref_out void ** ppvOut);

SetDllDirectoryPtr SetDllDirectoryFn = NULL;

SetSearchPathModePtr SetSearchPathModeFn = NULL;

SetDefaultDllDirectoriesPtr SetDefaultDllDirectoriesFn = NULL;

ImageList_CreatePtr ImageList_CreateFn = NULL;

ImageList_AddPtr ImageList_AddFn = NULL;

SetupCloseInfFilePtr SetupCloseInfFileFn = NULL;

SetupDiOpenClassRegKeyPtr SetupDiOpenClassRegKeyFn = NULL;

SetupInstallFromInfSectionWPtr SetupInstallFromInfSectionWFn = NULL;

SetupOpenInfFileWPtr SetupOpenInfFileWFn = NULL;

SHDeleteKeyWPtr SHDeleteKeyWFn = NULL;

SHStrDupWPtr SHStrDupWFn = NULL;

UrlUnescapeWPtr UrlUnescapeWFn = NULL;

ChangeWindowMessageFilterPtr ChangeWindowMessageFilterFn = NULL;

CreateProcessWithTokenWFn CreateProcessWithTokenWPtr = NULL;

IUnknown_QueryServiceFn IUnknown_QueryServicePtr = NULL;

typedef LONG (WINAPI *WINVERIFYTRUST)(HWND hwnd, GUID *pgActionID, LPVOID pWVTData);

typedef CRYPT_PROVIDER_DATA* (WINAPI *WTHELPERPROVDATAFROMSTATEDATA)(HANDLE hStateData);

typedef CRYPT_PROVIDER_SGNR* (WINAPI *WTHELPERGETPROVSIGNERFROMCHAIN)(CRYPT_PROVIDER_DATA *pProvData,

DWORD idxSigner,

BOOL fCounterSigner,

DWORD idxCounterSigner);

typedef CRYPT_PROVIDER_CERT* (WINAPI *WTHELPERGETPROVCERTFROMCHAIN)(CRYPT_PROVIDER_SGNR *pSgnr,

DWORD idxCert);

static WINVERIFYTRUST WinVerifyTrustFn = NULL;

static WTHELPERPROVDATAFROMSTATEDATA WTHelperProvDataFromStateDataFn = NULL;

static WTHELPERGETPROVSIGNERFROMCHAIN WTHelperGetProvSignerFromChainFn = NULL;

static WTHELPERGETPROVCERTFROMCHAIN WTHelperGetProvCertFromChainFn = NULL;

static unsigned char gpbSha256CodeSignCertFingerprint[64] = {

0x9C, 0xA0, 0x21, 0xD3, 0x7C, 0x90, 0x61, 0x88, 0xEF, 0x5F, 0x99, 0x3D,

0x54, 0x9F, 0xB8, 0xCE, 0x72, 0x32, 0x4F, 0x57, 0x4F, 0x19, 0xD2, 0xA4,

0xDC, 0x84, 0xFF, 0xE2, 0x84, 0x2B, 0xD4, 0x30, 0xAB, 0xA7, 0xE4, 0x63,

0x18, 0xD1, 0xD8, 0x32, 0x0E, 0xA4, 0x81, 0x3C, 0x19, 0xBF, 0x13, 0x11,

0xA4, 0x37, 0xD6, 0xDB, 0x26, 0xBA, 0xDC, 0x8F, 0x86, 0x96, 0x55, 0x96,

0xDB, 0x6F, 0xC0, 0x62

};

static unsigned char gpbSha256MSCodeSignCertFingerprint[64] = {

0x9C, 0x96, 0x81, 0x3B, 0x88, 0x54, 0xCB, 0x81, 0xB5, 0x94, 0x40, 0x4E,

0x15, 0x81, 0x20, 0xA1, 0x19, 0x00, 0x4E, 0x49, 0x8A, 0xA8, 0x98, 0x13,

0x9D, 0xE2, 0x86, 0x6A, 0xC1, 0xFA, 0xD3, 0x00, 0x0D, 0xAC, 0xE9, 0xE3,

0x3B, 0xFC, 0x6B, 0x26, 0xCE, 0xC8, 0xE2, 0x36, 0x3B, 0x60, 0x9C, 0x8E,

0x0A, 0x2A, 0x74, 0x20, 0xD7, 0x4E, 0x0F, 0xEE, 0x2E, 0x79, 0xE2, 0xAF,

0x1C, 0x90, 0x0B, 0x9C

};

typedef HRESULT (WINAPI *SHGETKNOWNFOLDERPATH) (

_In_ REFKNOWNFOLDERID rfid,

_In_ DWORD dwFlags,

_In_opt_ HANDLE hToken,

_Out_ PWSTR *ppszPath

);

/* Windows dialog class */

#define WINDOWS_DIALOG_CLASS L"#32770"

/* Custom class names */

#define TC_DLG_CLASS L"VeraCryptCustomDlg"

#define TC_SPLASH_CLASS L"VeraCryptSplashDlg"

/* constant used by ChangeWindowMessageFilter calls */

#ifndef MSGFLT_ADD

#define MSGFLT_ADD 1

#endif

/* undocumented message sent during drag-n-drop */

#ifndef WM_COPYGLOBALDATA

#define WM_COPYGLOBALDATA 0x0049

#endif

/* Benchmarks */

#ifndef SETUP

#define BENCHMARK_MAX_ITEMS 100

#define BENCHMARK_DEFAULT_BUF_SIZE BYTES_PER_MB

#define HASH_FNC_BENCHMARKS FALSE // For development purposes only. Must be FALSE when building a public release.

#define PKCS5_BENCHMARKS FALSE // For development purposes only. Must be FALSE when building a public release.

#if PKCS5_BENCHMARKS && HASH_FNC_BENCHMARKS

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

#endif

enum

{

BENCHMARK_TYPE_ENCRYPTION = 0,

BENCHMARK_TYPE_PRF,

BENCHMARK_TYPE_HASH

};

enum

{

BENCHMARK_SORT_BY_NAME = 0,

BENCHMARK_SORT_BY_SPEED

};

typedef struct

{

int id;

wchar_t name[100];

unsigned __int64 encSpeed;

unsigned __int64 decSpeed;

unsigned __int64 meanBytesPerSec;

} BENCHMARK_REC;

BENCHMARK_REC benchmarkTable [BENCHMARK_MAX_ITEMS];

int benchmarkTotalItems = 0;

int benchmarkBufferSize = BENCHMARK_DEFAULT_BUF_SIZE;

int benchmarkLastBufferSize = BENCHMARK_DEFAULT_BUF_SIZE;

int benchmarkSortMethod = BENCHMARK_SORT_BY_SPEED;

LARGE_INTEGER benchmarkPerformanceFrequency;

int benchmarkType = BENCHMARK_TYPE_ENCRYPTION;

int benchmarkPim = -1;

BOOL benchmarkPreBoot = FALSE;

BOOL benchmarkGPT = FALSE;

#endif // #ifndef SETUP

typedef struct

{

void *strings;

BOOL bold;

} MULTI_CHOICE_DLGPROC_PARAMS;

// Loads a 32-bit integer from the file at the specified file offset. The saved value is assumed to have been

// processed by mputLong(). The result is stored in *result. Returns TRUE if successful (otherwise FALSE).

BOOL LoadInt32 (const wchar_t *filePath, unsigned __int32 *result, __int64 fileOffset)

{

DWORD bufSize = sizeof(__int32);

unsigned char *buffer = (unsigned char *) malloc (bufSize);

unsigned char *bufferPtr = buffer;

HANDLE src = NULL;

DWORD bytesRead;

LARGE_INTEGER seekOffset, seekOffsetNew;

BOOL retVal = FALSE;

if (buffer == NULL)

return -1;

src = CreateFile (filePath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);

if (src == INVALID_HANDLE_VALUE)

{

free (buffer);

return FALSE;

}

seekOffset.QuadPart = fileOffset;

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

goto fsif_end;

if (ReadFile (src, buffer, bufSize, &bytesRead, NULL) == 0

|| bytesRead != bufSize)

goto fsif_end;

retVal = TRUE;

*result = mgetLong(bufferPtr);

fsif_end:

CloseHandle (src);

free (buffer);

return retVal;

}

// Loads a 16-bit integer from the file at the specified file offset. The saved value is assumed to have been

// processed by mputWord(). The result is stored in *result. Returns TRUE if successful (otherwise FALSE).

BOOL LoadInt16 (const wchar_t *filePath, int *result, __int64 fileOffset)

{

DWORD bufSize = sizeof(__int16);

unsigned char *buffer = (unsigned char *) malloc (bufSize);

unsigned char *bufferPtr = buffer;

HANDLE src = NULL;

DWORD bytesRead;

LARGE_INTEGER seekOffset, seekOffsetNew;

BOOL retVal = FALSE;

if (buffer == NULL)

return -1;

src = CreateFile (filePath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);

if (src == INVALID_HANDLE_VALUE)

{

free (buffer);

return FALSE;

}

seekOffset.QuadPart = fileOffset;

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

goto fsif_end;

if (ReadFile (src, buffer, bufSize, &bytesRead, NULL) == 0

|| bytesRead != bufSize)

goto fsif_end;

retVal = TRUE;

*result = mgetWord(bufferPtr);

fsif_end:

CloseHandle (src);

free (buffer);

return retVal;

}

// Returns NULL if there's any error. Although the buffer can contain binary data, it is always null-terminated.

char *LoadFile (const wchar_t *fileName, DWORD *size)

{

char *buf;

DWORD fileSize = INVALID_FILE_SIZE;

HANDLE h = CreateFile (fileName, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);

*size = 0;

if (h == INVALID_HANDLE_VALUE)

return NULL;

if ((fileSize = GetFileSize (h, NULL)) == INVALID_FILE_SIZE)

{

CloseHandle (h);

return NULL;

}

buf = (char *) calloc (fileSize + 1, 1);

if (buf == NULL)

{

CloseHandle (h);

return NULL;

}

if (!ReadFile (h, buf, fileSize, size, NULL))

{

free (buf);

buf = NULL;

}

else

{

buf[*size] = 0; //make coverity happy eventhough buf is guaranteed to be null terminated because of fileSize+1 in calloc call

}

CloseHandle (h);

return buf;

}

// Returns NULL if there's any error.

char *LoadFileBlock (const wchar_t *fileName, __int64 fileOffset, DWORD count)

{

char *buf;

DWORD bytesRead = 0;

LARGE_INTEGER seekOffset, seekOffsetNew;

BOOL bStatus;

HANDLE h = CreateFile (fileName, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);

if (h == INVALID_HANDLE_VALUE)

return NULL;

seekOffset.QuadPart = fileOffset;

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

{

CloseHandle (h);

return NULL;

}

buf = (char *) calloc (count, 1);

if (buf == NULL)

{

CloseHandle (h);

return NULL;

}

bStatus = ReadFile (h, buf, count, &bytesRead, NULL);

CloseHandle (h);

if (!bStatus || (bytesRead != count))

{

free (buf);

return NULL;

}

return buf;

}

// Returns -1 if there is an error, or the size of the file.

__int64 GetFileSize64 (const wchar_t *path)

{

HANDLE h = CreateFile (path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);

LARGE_INTEGER size;

__int64 retSize = -1;

if (h)

{

if (GetFileSizeEx (h, &size))

{

retSize = size.QuadPart;

}

CloseHandle (h);

}

return retSize;

}

// If bAppend is TRUE, the buffer is appended to an existing file. If bAppend is FALSE, any existing file

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

{

HANDLE dst;

DWORD bytesWritten;

BOOL res = TRUE;

DWORD dwLastError = 0;

dst = CreateFile (destinationFile,

GENERIC_WRITE,

FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, bAppend ? OPEN_EXISTING : CREATE_ALWAYS, 0, NULL);

dwLastError = GetLastError();

if (!bAppend && bRenameIfFailed && (dst == INVALID_HANDLE_VALUE) && (GetLastError () == ERROR_SHARING_VIOLATION))

{

wchar_t renamedPath[TC_MAX_PATH + 1];

StringCbCopyW (renamedPath, sizeof(renamedPath), destinationFile);

StringCbCatW (renamedPath, sizeof(renamedPath), VC_FILENAME_RENAMED_SUFFIX);

/* rename the locked file in order to be able to create a new one */

if (MoveFileEx (destinationFile, renamedPath, MOVEFILE_REPLACE_EXISTING))

{

dst = CreateFile (destinationFile,

GENERIC_WRITE,

FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, NULL);

dwLastError = GetLastError();

if (dst == INVALID_HANDLE_VALUE)

{

/* restore the original file name */

MoveFileEx (renamedPath, destinationFile, MOVEFILE_REPLACE_EXISTING);

}

else

{

/* delete the renamed file when the machine reboots */

MoveFileEx (renamedPath, NULL, MOVEFILE_DELAY_UNTIL_REBOOT);

}

}

}

if (dst == INVALID_HANDLE_VALUE)

{

SetLastError (dwLastError);

handleWin32Error (MainDlg, SRC_POS);

return FALSE;

}

if (bAppend)

SetFilePointer (dst, 0, NULL, FILE_END);

if (!WriteFile (dst, inputBuffer, inputLength, &bytesWritten, NULL)

|| inputLength != bytesWritten)

{

res = FALSE;

}

if (!res)

{

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

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

if (! (GetLastError() == ERROR_ALREADY_EXISTS && !bAppend) )

handleWin32Error (MainDlg, SRC_POS);

}

CloseHandle (dst);

if (!res && !bAppend)

_wremove (destinationFile);

return res;

}

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

// offset of the first occurrence of the string. The string and the buffer may contain zeroes,

// which do NOT terminate them.

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

{

if (buf == NULL

|| str == NULL

|| strLen > bufLen

|| bufLen < 1

|| strLen < 1

|| startOffset > bufLen - strLen)

{

return -1;

}

for (int64 i = startOffset; i <= bufLen - strLen; i++)

{

if (memcmp (buf + i, str, (size_t) strLen) == 0)

return i;

}

return -1;

}

// Returns TRUE if the file or directory exists (both may be enclosed in quotation marks).

BOOL FileExists (const wchar_t *filePathPtr)

{

wchar_t filePath [TC_MAX_PATH * 2 + 1];

// Strip quotation marks (if any)

if (filePathPtr [0] == L'"')

{

StringCbCopyW (filePath, sizeof(filePath), filePathPtr + 1);

}

else

{

StringCbCopyW (filePath, sizeof(filePath), filePathPtr);

}

// Strip quotation marks (if any)

if (filePath [wcslen (filePath) - 1] == L'"')

filePath [wcslen (filePath) - 1] = 0;

return (_waccess (filePath, 0) != -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 is found, its offset from the start of the file is returned.

// 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 bufSize = 64 * BYTES_PER_KB;

char *buffer = (char *) err_malloc (bufSize);

HANDLE src = NULL;

DWORD bytesRead;

BOOL readRetVal;

__int64 filePos = GetFileSize64 (filePath);

int bufPos = 0;

LARGE_INTEGER seekOffset, seekOffsetNew;

BOOL bExit = FALSE;

int filePosStep;

__int64 retVal = -1;

if (filePos <= 0

|| buffer == NULL

|| strLen > bufSize

|| strLen < 1)

{

if (buffer)

free (buffer);

return -1;

}

src = CreateFile (filePath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);

if (src == INVALID_HANDLE_VALUE)

{

free (buffer);

return -1;

}

filePosStep = bufSize - strLen + 1;

do

{

filePos -= filePosStep;

if (filePos < 0)

{

filePos = 0;

bExit = TRUE;

}

seekOffset.QuadPart = filePos;

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

goto fsif_end;

if ((readRetVal = ReadFile (src, buffer, bufSize, &bytesRead, NULL)) == 0

|| bytesRead == 0)

goto fsif_end;

bufPos = bytesRead - strLen;

while (bufPos > 0)

{

if (memcmp (buffer + bufPos, str, strLen) == 0)

{

// String found

retVal = filePos + bufPos;

goto fsif_end;

}

bufPos--;

}

} while (!bExit);

fsif_end:

CloseHandle (src);

free (buffer);

return retVal;

}

// System CopyFile() copies source file attributes (like FILE_ATTRIBUTE_ENCRYPTED)

// so we need to use our own copy function

BOOL TCCopyFileBase (HANDLE src, HANDLE dst)

{

__int8 *buffer;

FILETIME fileTime;

DWORD bytesRead, bytesWritten;

BOOL res;

buffer = (char *) malloc (64 * 1024);

if (!buffer)

{

CloseHandle (src);

CloseHandle (dst);

return FALSE;

}

while (res = ReadFile (src, buffer, 64 * 1024, &bytesRead, NULL))

{

if (bytesRead == 0)

{

res = 1;

break;

}

if (!WriteFile (dst, buffer, bytesRead, &bytesWritten, NULL)

|| bytesRead != bytesWritten)

{

res = 0;

break;

}

}

if (GetFileTime (src, NULL, NULL, &fileTime))

SetFileTime (dst, NULL, NULL, &fileTime);

CloseHandle (src);

CloseHandle (dst);

free (buffer);

return res != 0;

}

BOOL TCCopyFile (wchar_t *sourceFileName, wchar_t *destinationFile)

{

HANDLE src, dst;

src = CreateFileW (sourceFileName,

GENERIC_READ,

FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);

if (src == INVALID_HANDLE_VALUE)

return FALSE;

dst = CreateFileW (destinationFile,

GENERIC_WRITE,

0, NULL, CREATE_ALWAYS, 0, NULL);

if (dst == INVALID_HANDLE_VALUE)

{

CloseHandle (src);

return FALSE;

}

return TCCopyFileBase (src, dst);

}

#if defined(NDEBUG) && !defined(VC_SKIP_OS_DRIVER_REQ_CHECK)

static BOOL InitializeWintrust()

{

if (!hWinTrustLib)

{

wchar_t szPath[MAX_PATH] = {0};

if (GetSystemDirectory(szPath, MAX_PATH))

StringCchCatW (szPath, MAX_PATH, L"\\Wintrust.dll");

else

StringCchCopyW (szPath, MAX_PATH, L"C:\\Windows\\System32\\Wintrust.dll");

hWinTrustLib = LoadLibrary (szPath);

if (hWinTrustLib)

{

WinVerifyTrustFn = (WINVERIFYTRUST) GetProcAddress (hWinTrustLib, "WinVerifyTrust");

WTHelperProvDataFromStateDataFn = (WTHELPERPROVDATAFROMSTATEDATA) GetProcAddress (hWinTrustLib, "WTHelperProvDataFromStateData");

WTHelperGetProvSignerFromChainFn = (WTHELPERGETPROVSIGNERFROMCHAIN) GetProcAddress (hWinTrustLib, "WTHelperGetProvSignerFromChain");

WTHelperGetProvCertFromChainFn = (WTHELPERGETPROVCERTFROMCHAIN) GetProcAddress (hWinTrustLib, "WTHelperGetProvCertFromChain");

if ( !WinVerifyTrustFn

|| !WTHelperProvDataFromStateDataFn

|| !WTHelperGetProvSignerFromChainFn

|| !WTHelperGetProvCertFromChainFn)

{

FreeLibrary (hWinTrustLib);

hWinTrustLib = NULL;

}

}

}

if (hWinTrustLib)

return TRUE;

else

return FALSE;

}

static void FinalizeWintrust()

{

if (hWinTrustLib)

{

FreeLibrary (hWinTrustLib);

hWinTrustLib = NULL;

}

}

#endif

BOOL VerifyModuleSignature (const wchar_t* path)

{

#if defined(NDEBUG) && !defined (VC_SKIP_OS_DRIVER_REQ_CHECK)

BOOL bResult = FALSE;

HRESULT hResult;

GUID gActionID = WINTRUST_ACTION_GENERIC_VERIFY_V2;

WINTRUST_FILE_INFO fileInfo = {0};

WINTRUST_DATA WVTData = {0};

wchar_t filePath [TC_MAX_PATH + 1024];

// we check our own authenticode signature only starting from Windows 10 since this is

// the minimal supported OS apart from XP where we can't verify SHA256 signatures

if (!IsOSAtLeast (WIN_10))

return TRUE;

// Strip quotation marks (if any)

if (path [0] == L'"')

{

StringCbCopyW (filePath, sizeof(filePath), path + 1);

}

else

{

StringCbCopyW (filePath, sizeof(filePath), path);

}

// Strip quotation marks (if any)

if (filePath [wcslen (filePath) - 1] == L'"')

filePath [wcslen (filePath) - 1] = 0;

if (!InitializeWintrust ())

return FALSE;

fileInfo.cbStruct = sizeof(WINTRUST_FILE_INFO);

fileInfo.pcwszFilePath = filePath;

fileInfo.hFile = NULL;

WVTData.cbStruct = sizeof(WINTRUST_DATA);

WVTData.dwUIChoice = WTD_UI_NONE;

WVTData.fdwRevocationChecks = WTD_REVOKE_NONE;

WVTData.dwUnionChoice = WTD_CHOICE_FILE;

WVTData.pFile = &fileInfo;

WVTData.dwStateAction = WTD_STATEACTION_VERIFY;

WVTData.dwProvFlags = WTD_REVOCATION_CHECK_NONE | WTD_CACHE_ONLY_URL_RETRIEVAL;

hResult = WinVerifyTrustFn(0, &gActionID, &WVTData);

if (0 == hResult)

{

PCRYPT_PROVIDER_DATA pProviderData = WTHelperProvDataFromStateDataFn (WVTData.hWVTStateData);

if (pProviderData)

{

PCRYPT_PROVIDER_SGNR pProviderSigner = WTHelperGetProvSignerFromChainFn (pProviderData, 0, FALSE, 0);

if (pProviderSigner)

{

PCRYPT_PROVIDER_CERT pProviderCert = WTHelperGetProvCertFromChainFn (pProviderSigner, 0);

if (pProviderCert && (pProviderCert->pCert))

{

BYTE hashVal[64];

sha512 (hashVal, pProviderCert->pCert->pbCertEncoded, pProviderCert->pCert->cbCertEncoded);

if ( (0 == memcmp (hashVal, gpbSha256CodeSignCertFingerprint, 64))

|| (0 == memcmp (hashVal, gpbSha256MSCodeSignCertFingerprint, 64))

)

{

bResult = TRUE;

}

}

}

}

}

WVTData.dwUIChoice = WTD_UI_NONE;

WVTData.dwStateAction = WTD_STATEACTION_CLOSE;

WinVerifyTrustFn(0, &gActionID, &WVTData);

FinalizeWintrust ();

return bResult;

#else

return TRUE;

#endif

}

DWORD handleWin32Error (HWND hwndDlg, const char* srcPos)

{

#ifndef VC_COMREG

PWSTR lpMsgBuf;

DWORD dwError = GetLastError ();

wchar_t szErrorValue[32];

wchar_t* pszDesc;

if (Silent || dwError == 0 || dwError == ERROR_INVALID_WINDOW_HANDLE)

return dwError;

// Access denied

if (dwError == ERROR_ACCESS_DENIED && !IsAdmin ())

{

ErrorDirect ( AppendSrcPos (GetString ("ERR_ACCESS_DENIED"), srcPos).c_str (), hwndDlg);

SetLastError (dwError); // Preserve the original error code

return dwError;

}

FormatMessageW (

FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,

NULL,

dwError,

MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */

(PWSTR) &lpMsgBuf,

0,

NULL

);

if (lpMsgBuf)

pszDesc = (wchar_t*) lpMsgBuf;

else

{

StringCchPrintfW (szErrorValue, ARRAYSIZE (szErrorValue), L"Error 0x%.8X", dwError);

pszDesc = szErrorValue;

}

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

if (lpMsgBuf) LocalFree (lpMsgBuf);

// User-friendly hardware error explanation

if (IsDiskError (dwError))

Error ("ERR_HARDWARE_ERROR", hwndDlg);

// Device not ready

if (dwError == ERROR_NOT_READY)

HandleDriveNotReadyError(hwndDlg);

SetLastError (dwError); // Preserve the original error code

return dwError;

#else

return GetLastError();

#endif

}

int Error (char *stringId, HWND hwnd)

{

#ifndef VC_COMREG

if (Silent) return 0;

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

#else

return 0;

#endif

}

BOOL IsOSAtLeast (OSVersionEnum reqMinOS)

{

return IsOSVersionAtLeast (reqMinOS, 0);

}

// Returns TRUE if the operating system is at least reqMinOS and service pack at least reqMinServicePack.

// Example 1: IsOSVersionAtLeast (WIN_VISTA, 1) called under Windows 2008, returns TRUE.

// Example 2: IsOSVersionAtLeast (WIN_XP, 3) called under Windows XP SP1, returns FALSE.

// Example 3: IsOSVersionAtLeast (WIN_XP, 3) called under Windows Vista SP1, returns TRUE.

BOOL IsOSVersionAtLeast (OSVersionEnum reqMinOS, int reqMinServicePack)

{

/* When updating this function, update IsOSAtLeast() in Ntdriver.c too. */

if (CurrentOSMajor <= 0)

TC_THROW_FATAL_EXCEPTION;

int major = 0, minor = 0;

switch (reqMinOS)

{

case WIN_2000: major = 5; minor = 0; break;

case WIN_XP: major = 5; minor = 1; break;

case WIN_SERVER_2003: major = 5; minor = 2; break;

case WIN_VISTA: major = 6; minor = 0; break;

case WIN_7: major = 6; minor = 1; break;

case WIN_8: major = 6; minor = 2; break;

case WIN_8_1: major = 6; minor = 3; break;

case WIN_10: major = 10; minor = 0; break;

default:

TC_THROW_FATAL_EXCEPTION;

break;

}

return ((CurrentOSMajor << 16 | CurrentOSMinor << 8 | CurrentOSServicePack)

>= (major << 16 | minor << 8 | reqMinServicePack));

}

#ifdef SETUP_DLL

static BOOL GetWindowVersionFromFile(DWORD* pdwMajor, DWORD* pdwMinor, DWORD* pdwBuildNumber)

{

wchar_t dllPath[MAX_PATH];

BOOL bRet = FALSE;

LPBYTE versionInfo = NULL;

UINT size;

VS_FIXEDFILEINFO *vinfo;

/* Load dll explictely from System32 to avoid Dll hijacking attacks*/

if (!GetSystemDirectory(dllPath, MAX_PATH))

StringCbCopyW(dllPath, sizeof(dllPath), L"C:\\Windows\\System32");

StringCbCatW(dllPath, sizeof(dllPath), L"\\");

StringCbCatW(dllPath, sizeof(dllPath), L"Kernel32.dll");

size = GetFileVersionInfoSizeW(dllPath, NULL);

if (size)

{

versionInfo = (LPBYTE) TCalloc(size);

if (GetFileVersionInfo(dllPath, 0, size, versionInfo))

{

if (VerQueryValueW(versionInfo, L"\\", (LPVOID *)&vinfo, &size) && (size >=sizeof(VS_FIXEDFILEINFO)))

{

*pdwMajor = HIWORD(vinfo->dwProductVersionMS);

*pdwMinor = LOWORD(vinfo->dwProductVersionMS);

*pdwBuildNumber = HIWORD(vinfo->dwProductVersionLS);

bRet = TRUE;

}

}

}

if (versionInfo)

TCfree(versionInfo);

return bRet;

}

#endif

/*

* Use RtlGetVersion to get Windows version because GetVersionEx is affected by application manifestation.

*/

typedef NTSTATUS (WINAPI* RtlGetVersionPtr)(PRTL_OSVERSIONINFOW);

static BOOL GetWindowsVersion(LPOSVERSIONINFOW lpVersionInformation)

{

BOOL bRet = FALSE;

#ifdef SETUP_DLL

DWORD dwMajor, dwMinor, dwBuildNumber;

#endif

RtlGetVersionPtr RtlGetVersionFn = (RtlGetVersionPtr) GetProcAddress(GetModuleHandle (L"ntdll.dll"), "RtlGetVersion");

if (RtlGetVersionFn != NULL)

{

if (ERROR_SUCCESS == RtlGetVersionFn (lpVersionInformation))

bRet = TRUE;

}

if (!bRet)

bRet = GetVersionExW (lpVersionInformation);

#ifdef SETUP_DLL

// we get real version from Kernel32.dll version since MSI always sets current version to 6.0

// https://stackoverflow.com/questions/49335885/windows-10-not-detecting-on-installshield/49343826#49343826

if (GetWindowVersionFromFile(&dwMajor, &dwMinor, &dwBuildNumber))

{

lpVersionInformation->dwMajorVersion = dwMajor;

lpVersionInformation->dwMinorVersion = dwMinor;

lpVersionInformation->dwBuildNumber = dwBuildNumber;

}

#endif

return bRet;

}

void InitOSVersionInfo ()

{

OSVERSIONINFOEXW os;

os.dwOSVersionInfoSize = sizeof (OSVERSIONINFOEXW);

if (GetWindowsVersion ((LPOSVERSIONINFOW) &os) == FALSE)

AbortProcess ("NO_OS_VER");

CurrentOSMajor = os.dwMajorVersion;

CurrentOSMinor = os.dwMinorVersion;

CurrentOSServicePack = os.wServicePackMajor;

CurrentOSBuildNumber = os.dwBuildNumber;

if (os.dwPlatformId == VER_PLATFORM_WIN32_NT && CurrentOSMajor == 5 && CurrentOSMinor == 0)

nCurrentOS = WIN_2000;

else if (os.dwPlatformId == VER_PLATFORM_WIN32_NT && CurrentOSMajor == 5 && CurrentOSMinor == 1)

nCurrentOS = WIN_XP;

else if (os.dwPlatformId == VER_PLATFORM_WIN32_NT && CurrentOSMajor == 5 && CurrentOSMinor == 2)

{

if (os.wProductType == VER_NT_SERVER || os.wProductType == VER_NT_DOMAIN_CONTROLLER)

nCurrentOS = WIN_SERVER_2003;

else

nCurrentOS = WIN_XP64;

}

else if (os.dwPlatformId == VER_PLATFORM_WIN32_NT && CurrentOSMajor == 6 && CurrentOSMinor == 0)

{

if (os.wProductType != VER_NT_WORKSTATION)

nCurrentOS = WIN_SERVER_2008;

else

nCurrentOS = WIN_VISTA;

}

else if (os.dwPlatformId == VER_PLATFORM_WIN32_NT && CurrentOSMajor == 6 && CurrentOSMinor == 1)

nCurrentOS = ((os.wProductType != VER_NT_WORKSTATION) ? WIN_SERVER_2008_R2 : WIN_7);

else if (os.dwPlatformId == VER_PLATFORM_WIN32_NT && CurrentOSMajor == 6 && CurrentOSMinor == 2)

nCurrentOS = ((os.wProductType != VER_NT_WORKSTATION) ? WIN_SERVER_2012 : WIN_8);

else if (os.dwPlatformId == VER_PLATFORM_WIN32_NT && CurrentOSMajor == 6 && CurrentOSMinor == 3)

nCurrentOS = ((os.wProductType != VER_NT_WORKSTATION) ? WIN_SERVER_2012_R2 : WIN_8_1);

else if (os.dwPlatformId == VER_PLATFORM_WIN32_NT && CurrentOSMajor == 10 && CurrentOSMinor == 0)

nCurrentOS = ((os.wProductType != VER_NT_WORKSTATION) ? WIN_SERVER_2016 : WIN_10);

else if (os.dwPlatformId == VER_PLATFORM_WIN32_NT && CurrentOSMajor == 4)

nCurrentOS = WIN_NT4;

else if (os.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS && os.dwMajorVersion == 4 && os.dwMinorVersion == 0)

nCurrentOS = WIN_95;

else if (os.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS && os.dwMajorVersion == 4 && os.dwMinorVersion == 10)

nCurrentOS = WIN_98;

else if (os.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS && os.dwMajorVersion == 4 && os.dwMinorVersion == 90)

nCurrentOS = WIN_ME;

else if (os.dwPlatformId == VER_PLATFORM_WIN32s)

nCurrentOS = WIN_31;

else

nCurrentOS = WIN_UNKNOWN;

}

#pragma warning(push)

#pragma warning(disable:4702)

void *err_malloc (size_t size)

{

void *z = (void *) TCalloc (size);

if (z)

return z;

AbortProcess ("OUTOFMEMORY");

return 0;

}

#pragma warning(pop)

char *err_strdup (char *lpszText)

{

size_t j = (strlen (lpszText) + 1) * sizeof (char);

char *z = (char *) err_malloc (j);

memmove (z, lpszText, j);

return z;

}

void AbortProcessDirect (wchar_t *abortMsg)

{

// Note that this function also causes localcleanup() to be called (see atexit())

MessageBeep (MB_ICONEXCLAMATION);

MessageBoxW (NULL, abortMsg, lpszTitle, ICON_HAND);

#ifndef VC_COMREG

FREE_DLL (hRichEditDll);

FREE_DLL (hComctl32Dll);

FREE_DLL (hSetupDll);

FREE_DLL (hShlwapiDll);

FREE_DLL (hProfApiDll);

FREE_DLL (hUsp10Dll);

FREE_DLL (hCryptSpDll);

FREE_DLL (hUXThemeDll);

FREE_DLL (hUserenvDll);

FREE_DLL (hRsaenhDll);

FREE_DLL (himm32dll);

FREE_DLL (hMSCTFdll);

FREE_DLL (hfltlibdll);

FREE_DLL (hframedyndll);

FREE_DLL (hpsapidll);

FREE_DLL (hsecur32dll);

FREE_DLL (hnetapi32dll);

FREE_DLL (hauthzdll);

FREE_DLL (hxmllitedll);

FREE_DLL (hmprdll);

FREE_DLL (hsppdll);

FREE_DLL (vssapidll);

FREE_DLL (hvsstracedll);

FREE_DLL (hCryptSpDll);

FREE_DLL (hcfgmgr32dll);

FREE_DLL (hdevobjdll);

FREE_DLL (hpowrprofdll);

FREE_DLL (hsspiclidll);

FREE_DLL (hcryptbasedll);

FREE_DLL (hdwmapidll);

FREE_DLL (hmsasn1dll);

FREE_DLL (hcrypt32dll);

FREE_DLL (hbcryptdll);

FREE_DLL (hbcryptprimitivesdll);

FREE_DLL (hMsls31);

FREE_DLL (hntmartadll);

FREE_DLL (hwinscarddll);

FREE_DLL (hmsvcrtdll);

FREE_DLL (hAdvapi32Dll);

#endif

exit (1);

}

void AbortProcess (char *stringId)

{

// Note that this function also causes localcleanup() to be called (see atexit())

#ifndef VC_COMREG

AbortProcessDirect (GetString (stringId));

#else

static wchar_t g_wszUnknown[1024];

StringCbPrintfW (g_wszUnknown, sizeof(g_wszUnknown), UNKNOWN_STRING_ID L"%hs" UNKNOWN_STRING_ID, stringId);

AbortProcessDirect (g_wszUnknown);

#endif

}

#ifndef VC_COMREG

void AbortProcessSilent (void)

{

FREE_DLL (hRichEditDll);

FREE_DLL (hComctl32Dll);

FREE_DLL (hSetupDll);

FREE_DLL (hShlwapiDll);

FREE_DLL (hProfApiDll);

FREE_DLL (hUsp10Dll);

FREE_DLL (hCryptSpDll);

FREE_DLL (hUXThemeDll);

FREE_DLL (hUserenvDll);

FREE_DLL (hRsaenhDll);

FREE_DLL (himm32dll);

FREE_DLL (hMSCTFdll);

FREE_DLL (hfltlibdll);

FREE_DLL (hframedyndll);

FREE_DLL (hpsapidll);

FREE_DLL (hsecur32dll);

FREE_DLL (hnetapi32dll);

FREE_DLL (hauthzdll);

FREE_DLL (hxmllitedll);

FREE_DLL (hmprdll);

FREE_DLL (hsppdll);

FREE_DLL (vssapidll);

FREE_DLL (hvsstracedll);

FREE_DLL (hCryptSpDll);

FREE_DLL (hcfgmgr32dll);

FREE_DLL (hdevobjdll);

FREE_DLL (hpowrprofdll);

FREE_DLL (hsspiclidll);

FREE_DLL (hcryptbasedll);

FREE_DLL (hdwmapidll);

FREE_DLL (hmsasn1dll);

FREE_DLL (hcrypt32dll);

FREE_DLL (hbcryptdll);

FREE_DLL (hbcryptprimitivesdll);

FREE_DLL (hMsls31);

FREE_DLL (hntmartadll);

FREE_DLL (hwinscarddll);

FREE_DLL (hmsvcrtdll);

FREE_DLL (hAdvapi32Dll);

// Note that this function also causes localcleanup() to be called (see atexit())

exit (1);

}

void InitGlobalLocks ()

{

InitializeCriticalSection (&csWNetCalls);

InitializeCriticalSection (&csMountableDevices);

InitializeCriticalSection (&csVolumeIdCandidates);

InitializeCriticalSection (&csSecureDesktop);

}

void FinalizeGlobalLocks ()

{

DeleteCriticalSection (&csWNetCalls);

DeleteCriticalSection (&csMountableDevices);

DeleteCriticalSection (&csVolumeIdCandidates);

DeleteCriticalSection (&csSecureDesktop);

}

void cleanup ()

{

burn (&CmdTokenPin, sizeof (CmdTokenPin));

#ifndef SETUP

KeyFileRemoveAll (&FirstKeyFile);

KeyFileRemoveAll (&defaultKeyFilesParam.FirstKeyFile);

#endif

/* Cleanup the GDI fonts */

if (hFixedFont != NULL)

DeleteObject (hFixedFont);

if (hFixedDigitFont != NULL)

DeleteObject (hFixedDigitFont);

if (hBoldFont != NULL)

DeleteObject (hBoldFont);

if (hTitleFont != NULL)

DeleteObject (hTitleFont);

if (hUserFont != NULL)

DeleteObject (hUserFont);

if (hUserUnderlineFont != NULL)

DeleteObject (hUserUnderlineFont);

if (hUserBoldFont != NULL)

DeleteObject (hUserBoldFont);

if (hUserUnderlineBoldFont != NULL)

DeleteObject (hUserUnderlineBoldFont);

/* Cleanup our dialog class */

if (hDlgClass)

UnregisterClassW (TC_DLG_CLASS, hInst);

if (hSplashClass)

UnregisterClassW (TC_SPLASH_CLASS, hInst);

/* Close the device driver handle */

if (hDriver != INVALID_HANDLE_VALUE)

{

// Unload driver mode if possible (non-install mode)

if (IsNonInstallMode ())

{

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

// the same path. Therefore, the driver will not be unloaded even though it was loaded in non-install mode.

int driverUnloadDisabled;

DWORD dwResult;

if (!DeviceIoControl (hDriver, TC_IOCTL_IS_DRIVER_UNLOAD_DISABLED, NULL, 0, &driverUnloadDisabled, sizeof (driverUnloadDisabled), &dwResult, NULL))

driverUnloadDisabled = 0;

if (!driverUnloadDisabled)

DriverUnload ();

else

{

CloseHandle (hDriver);

hDriver = INVALID_HANDLE_VALUE;

}

}

else

{

CloseHandle (hDriver);

hDriver = INVALID_HANDLE_VALUE;

}

}

if (ConfigBuffer != NULL)

{

free (ConfigBuffer);

ConfigBuffer = NULL;

}

CoUninitialize ();

CloseSysEncMutex ();

#ifndef SETUP

try

{

if (SecurityToken::IsInitialized())

SecurityToken::CloseLibrary();

}

catch (...) { }

EncryptionThreadPoolStop();

#endif

FinalizeGlobalLocks ();

}

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

{

size_t i = wcslen (lpszSource) + 1;

lpszDest[i - 1] = 0;

while (--i > 0)

{

lpszDest[i - 1] = (wchar_t) towlower (lpszSource[i - 1]);

}

}

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

{

if (lpszDest && cbDest)

{

size_t i = wcslen (lpszSource);

if (i >= cbDest)

i = cbDest - 1;

lpszDest[i] = 0;

i++;

while (--i > 0)

{

lpszDest[i - 1] = (wchar_t) towupper (lpszSource[i - 1]);

}

}

}

std::wstring ToUpperCase (const std::wstring &str)

{

wstring u;

foreach (wchar_t c, str)

{

u += (wchar_t) towupper (c);

}

return u;

}

size_t TrimWhiteSpace(wchar_t *str)

{

wchar_t *end, *ptr = str;

size_t out_size;

if(!str || *str == 0)

return 0;

// Trim leading space

while(iswspace(*ptr)) ptr++;

if(*ptr == 0) // All spaces?

{

*str = 0;

return 0;

}

// Trim trailing space

end = str + wcslen(str) - 1;

while(end > ptr && iswspace(*end)) end--;

end++;

// Set output size to trimmed string length

out_size = (end - ptr);

// Copy trimmed string and add null terminator

wmemmove(str, ptr, out_size);

str[out_size] = 0;

return out_size;

}

BOOL IsNullTerminateString (const wchar_t* str, size_t cbSize)

{

if (str && cbSize)

{

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

{

if (str[i] == 0)

return TRUE;

}

}

return FALSE;

}

// 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'*'};

wchar_t c;

int i;

BOOL bNotDotOnly = FALSE;

while ((c = *str))

{

if (c != L'.')

bNotDotOnly = TRUE;

for (i= 0; i < ARRAYSIZE(invalidChars); i++)

if (c == invalidChars[i])

return FALSE;

str++;

}

return bNotDotOnly;

}

BOOL IsVolumeDeviceHosted (const wchar_t *lpszDiskFile)

{

return wcsstr (lpszDiskFile, L"\\Device\\") == lpszDiskFile

|| wcsstr (lpszDiskFile, L"\\DEVICE\\") == lpszDiskFile;

}

void CreateFullVolumePath (wchar_t *lpszDiskFile, size_t cbDiskFile, const wchar_t *lpszFileName, BOOL * bDevice)

{

UpperCaseCopy (lpszDiskFile, cbDiskFile, lpszFileName);

*bDevice = FALSE;

if (wmemcmp (lpszDiskFile, L"\\DEVICE", 7) == 0)

{

*bDevice = TRUE;

}

StringCbCopyW (lpszDiskFile, cbDiskFile, lpszFileName);

#if _DEBUG

OutputDebugString (L"CreateFullVolumePath: ");

OutputDebugString (lpszDiskFile);

OutputDebugString (L"\n");

#endif

}

int FakeDosNameForDevice (const wchar_t *lpszDiskFile , wchar_t *lpszDosDevice , size_t cbDosDevice, wchar_t *lpszCFDevice , size_t cbCFDevice, BOOL bNameOnly)

{

BOOL bDosLinkCreated = TRUE;

StringCbPrintfW (lpszDosDevice, cbDosDevice,L"veracrypt%lu", GetCurrentProcessId ());

if (bNameOnly == FALSE)

bDosLinkCreated = DefineDosDevice (DDD_RAW_TARGET_PATH, lpszDosDevice, lpszDiskFile);

if (bDosLinkCreated == FALSE)

return ERR_OS_ERROR;

else

StringCbPrintfW (lpszCFDevice, cbCFDevice,L"\\\\.\\%s", lpszDosDevice);

return 0;

}

int RemoveFakeDosName (wchar_t *lpszDiskFile, wchar_t *lpszDosDevice)

{

BOOL bDosLinkRemoved = DefineDosDevice (DDD_RAW_TARGET_PATH | DDD_EXACT_MATCH_ON_REMOVE |

DDD_REMOVE_DEFINITION, lpszDosDevice, lpszDiskFile);

if (bDosLinkRemoved == FALSE)

{

return ERR_OS_ERROR;

}

return 0;

}

BOOL IsDiskReadError (DWORD error)

{

return (error == ERROR_CRC

|| error == ERROR_IO_DEVICE

|| error == ERROR_BAD_CLUSTERS

|| error == ERROR_SECTOR_NOT_FOUND

|| error == ERROR_READ_FAULT

|| error == ERROR_INVALID_FUNCTION // I/O error may be reported as ERROR_INVALID_FUNCTION by buggy chipset drivers

|| error == ERROR_SEM_TIMEOUT); // I/O operation timeout may be reported as ERROR_SEM_TIMEOUT

}

BOOL IsDiskWriteError (DWORD error)

{

return (error == ERROR_IO_DEVICE

|| error == ERROR_BAD_CLUSTERS

|| error == ERROR_SECTOR_NOT_FOUND

|| error == ERROR_WRITE_FAULT

|| error == ERROR_INVALID_FUNCTION // I/O error may be reported as ERROR_INVALID_FUNCTION by buggy chipset drivers

|| error == ERROR_SEM_TIMEOUT); // I/O operation timeout may be reported as ERROR_SEM_TIMEOUT

}

BOOL IsDiskError (DWORD error)

{

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

}

BOOL translateWin32Error (wchar_t *lpszMsgBuf, int nWSizeOfBuf)

{

DWORD dwError = GetLastError ();

if (FormatMessageW (FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, dwError,

MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */

lpszMsgBuf, nWSizeOfBuf, NULL))

{

SetLastError (dwError); // Preserve the original error code

return TRUE;

}

SetLastError (dwError); // Preserve the original error code

return FALSE;

}

// If the user has a non-default screen DPI, all absolute font sizes must be

// converted using this function.

int CompensateDPIFont (int val)

{

if (ScreenDPI == USER_DEFAULT_SCREEN_DPI)

return val;

else

{

double tmpVal = (double) val * DPIScaleFactorY * DlgAspectRatio * 0.999;

if (tmpVal > 0)

return (int) floor(tmpVal);

else

return (int) ceil(tmpVal);

}

}

// If the user has a non-default screen DPI, some screen coordinates and sizes must

// be converted using this function

int CompensateXDPI (int val)

{

if (ScreenDPI == USER_DEFAULT_SCREEN_DPI)

return val;

else

{

double tmpVal = (double) val * DPIScaleFactorX;

if (tmpVal > 0)

return (int) floor(tmpVal);

else

return (int) ceil(tmpVal);

}

}

// If the user has a non-default screen DPI, some screen coordinates and sizes must

// be converted using this function

int CompensateYDPI (int val)

{

if (ScreenDPI == USER_DEFAULT_SCREEN_DPI)

return val;

else

{

double tmpVal = (double) val * DPIScaleFactorY;

if (tmpVal > 0)

return (int) floor(tmpVal);

else

return (int) ceil(tmpVal);

}

}

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

{

SIZE sizes;

TEXTMETRIC textMetrics;

HDC hdc = GetDC (hwndDlgItem);

SelectObject(hdc, (HGDIOBJ) hFont);

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

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

ReleaseDC (hwndDlgItem, hdc);

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

}

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

{

SIZE sizes;

HDC hdc = GetDC (hwndDlgItem);

SelectObject(hdc, (HGDIOBJ) hFont);

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

ReleaseDC (hwndDlgItem, hdc);

return ((int) sizes.cy);

}

std::wstring FitPathInGfxWidth (HWND hwnd, HFONT hFont, LONG width, const std::wstring &path)

{

wstring newPath;

RECT rect;

rect.left = 0;

rect.top = 0;

rect.right = width;

rect.bottom = LONG_MAX;

HDC hdc = GetDC (hwnd);

SelectObject (hdc, (HGDIOBJ) hFont);

wchar_t pathBuf[TC_MAX_PATH];

StringCchCopyW (pathBuf, ARRAYSIZE (pathBuf), path.c_str());

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

newPath = pathBuf;

ReleaseDC (hwnd, hdc);

return newPath;

}

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

{

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

switch (message)

{

case WM_SETCURSOR:

if (!bHyperLinkBeingTracked)

{

TRACKMOUSEEVENT trackMouseEvent;

trackMouseEvent.cbSize = sizeof(trackMouseEvent);

trackMouseEvent.dwFlags = TME_LEAVE;

trackMouseEvent.hwndTrack = hwnd;

bHyperLinkBeingTracked = TrackMouseEvent(&trackMouseEvent);

HandCursor();

}

return 0;

case WM_MOUSELEAVE:

bHyperLinkBeingTracked = FALSE;

NormalCursor();

return 0;

}

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

}

BOOL ToHyperlink (HWND hwndDlg, UINT ctrlId)

{

return ToCustHyperlink (hwndDlg, ctrlId, hUserUnderlineFont);

}

BOOL ToCustHyperlink (HWND hwndDlg, UINT ctrlId, HFONT hFont)

{

HWND hwndCtrl = GetDlgItem (hwndDlg, ctrlId);

SendMessageW (hwndCtrl, WM_SETFONT, (WPARAM) hFont, 0);

SetWindowLongPtrW (hwndCtrl, GWLP_USERDATA, (LONG_PTR) GetWindowLongPtrW (hwndCtrl, GWLP_WNDPROC));

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

// Resize the field according to its actual size in pixels and move it if centered or right-aligned.

// This should be done again if the link text changes.

AccommodateTextField (hwndDlg, ctrlId, TRUE, hFont);

return TRUE;

}

// Resizes a text field according to its actual width and height in pixels (font size is taken into account) and moves

// it accordingly if the field is centered or right-aligned. Should be used on all hyperlinks upon dialog init

// after localization (bFirstUpdate should be TRUE) and later whenever a hyperlink text changes (bFirstUpdate

// must be FALSE).

void AccommodateTextField (HWND hwndDlg, UINT ctrlId, BOOL bFirstUpdate, HFONT hFont)

{

RECT rec, wrec, trec;

HWND hwndCtrl = GetDlgItem (hwndDlg, ctrlId);

int width, origWidth, height, origHeight;

int horizSubOffset, vertSubOffset, vertOffset, alignPosDiff = 0;

wchar_t text [MAX_URL_LENGTH];

WINDOWINFO windowInfo;

BOOL bBorderlessWindow = !(GetWindowLongPtrW (hwndDlg, GWL_STYLE) & (WS_BORDER | WS_DLGFRAME));

// Resize the field according to its length and font size and move if centered or right-aligned

GetWindowTextW (hwndCtrl, text, sizeof (text) / sizeof (wchar_t));

width = GetTextGfxWidth (hwndCtrl, text, hFont);

height = GetTextGfxHeight (hwndCtrl, text, hFont);

GetClientRect (hwndCtrl, &rec);

origWidth = rec.right;

origHeight = rec.bottom;

if (width >= 0

&& (!bFirstUpdate || origWidth > width)) // The original width of the field is the maximum allowed size

{

horizSubOffset = origWidth - width;

vertSubOffset = origHeight - height;

// Window coords

GetWindowRect(hwndDlg, &wrec);

GetClientRect(hwndDlg, &trec);

// Vertical "title bar" offset

vertOffset = wrec.bottom - wrec.top - trec.bottom - (bBorderlessWindow ? 0 : GetSystemMetrics(SM_CYFIXEDFRAME));

// Text field coords

GetWindowRect(hwndCtrl, &rec);

// Alignment offset

windowInfo.cbSize = sizeof(windowInfo);

GetWindowInfo (hwndCtrl, &windowInfo);

if (windowInfo.dwStyle & SS_CENTER)

alignPosDiff = horizSubOffset / 2;

else if (windowInfo.dwStyle & SS_RIGHT)

alignPosDiff = horizSubOffset;

// Resize/move

if (alignPosDiff > 0)

{

// Resize and move the text field

MoveWindow (hwndCtrl,

rec.left - wrec.left - (bBorderlessWindow ? 0 : GetSystemMetrics(SM_CXFIXEDFRAME)) + alignPosDiff,

rec.top - wrec.top - vertOffset,

origWidth - horizSubOffset,

origHeight - vertSubOffset,

TRUE);

}

else

{

// Resize the text field

SetWindowPos (hwndCtrl, 0, 0, 0,

origWidth - horizSubOffset,

origHeight - vertSubOffset,

SWP_NOMOVE | SWP_NOZORDER);

}

SetWindowPos (hwndCtrl, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);

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

}

void EnableCloseButton (HWND hwndDlg)

{

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

}

void HandlePasswordEditWmChar (HWND hwnd, WPARAM wParam)

{

DWORD dwStartPos = 0, dwEndPos = 0;

short vk = VkKeyScanW ((WCHAR) wParam);

BYTE vkCode = LOBYTE (vk);

BYTE vkState = HIBYTE (vk);

bool ctrlPressed = (vkState & 2) && !(vkState & 4);

int dwMaxPassLen = (int) SendMessage (hwnd, EM_GETLIMITTEXT, 0, 0);

// check if there is a selected text

SendMessage (hwnd, EM_GETSEL, (WPARAM) &dwStartPos, (LPARAM) &dwEndPos);

if ((dwStartPos == dwEndPos)

&& (vkCode != VK_DELETE) && (vkCode != VK_BACK)

&& !ctrlPressed

&& (GetWindowTextLength (hwnd) == dwMaxPassLen))

{

EDITBALLOONTIP ebt;

DWORD dwTextSize = (DWORD) wcslen (GetString ("PASSWORD_MAXLENGTH_REACHED")) + 16;

WCHAR* szErrorText = (WCHAR*) malloc (dwTextSize * sizeof (WCHAR));

StringCchPrintf (szErrorText, dwTextSize, GetString ("PASSWORD_MAXLENGTH_REACHED"), dwMaxPassLen);

ebt.cbStruct = sizeof( EDITBALLOONTIP );

ebt.pszText = szErrorText;

ebt.pszTitle = lpszTitle;

ebt.ttiIcon = TTI_ERROR_LARGE; // tooltip warning icon

SendMessage(hwnd, EM_SHOWBALLOONTIP, 0, (LPARAM)&ebt);

MessageBeep (0xFFFFFFFF);

free (szErrorText);

}

else

SendMessage(hwnd, EM_HIDEBALLOONTIP, 0, 0);

}

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;

case WM_CHAR:

HandlePasswordEditWmChar (hwnd, wParam);

break;

}

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

}

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

// input fields (only the US keyboard layout is supported in pre-boot environment so we must prevent the

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

void ToBootPwdField (HWND hwndDlg, UINT ctrlId)

{

HWND hwndCtrl = GetDlgItem (hwndDlg, ctrlId);

WNDPROC originalwp = (WNDPROC) GetWindowLongPtrW (hwndCtrl, GWLP_USERDATA);

SendMessage (hwndCtrl, EM_LIMITTEXT, MAX_LEGACY_PASSWORD, 0);

// if ToNormalPwdField has been called before, GWLP_USERDATA already contains original WNDPROC

if (!originalwp)

{

SetWindowLongPtrW (hwndCtrl, GWLP_USERDATA, (LONG_PTR) GetWindowLongPtrW (hwndCtrl, GWLP_WNDPROC));

}

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

}

// Ensures that a warning is displayed when user is pasting a password longer than the maximum

// length which is set to 64 characters

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

{

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

switch (message)

{

case WM_PASTE:

{

bool bBlock = false;

if (OpenClipboard (NULL))

{

HANDLE h = GetClipboardData (CF_UNICODETEXT);

if (h)

{

wchar_t *pchData = (wchar_t*)GlobalLock(h);

int txtlen = 0;

int dwMaxPassLen = bUseLegacyMaxPasswordLength? MAX_LEGACY_PASSWORD : MAX_PASSWORD;

while (*pchData)

{

if (*pchData == '\r' || *pchData == '\n')

break;

else

{

txtlen++;

pchData++;

}

}

if (txtlen)

{

int curLen = GetWindowTextLength (hwnd);

if (curLen == dwMaxPassLen)

{

EDITBALLOONTIP ebt;

DWORD dwTextSize = (DWORD) wcslen (GetString ("PASSWORD_MAXLENGTH_REACHED")) + 16;

WCHAR* szErrorText = (WCHAR*) malloc (dwTextSize * sizeof (WCHAR));

StringCchPrintf (szErrorText, dwTextSize, GetString ("PASSWORD_MAXLENGTH_REACHED"), dwMaxPassLen);

ebt.cbStruct = sizeof( EDITBALLOONTIP );

ebt.pszText = szErrorText;

ebt.pszTitle = lpszTitle;

ebt.ttiIcon = TTI_ERROR_LARGE; // tooltip warning icon

SendMessage(hwnd, EM_SHOWBALLOONTIP, 0, (LPARAM)&ebt);

MessageBeep (0xFFFFFFFF);

free (szErrorText);

bBlock = true;

}

else if ((txtlen + curLen) > dwMaxPassLen)

{

EDITBALLOONTIP ebt;

DWORD dwTextSize = (DWORD) wcslen (GetString ("PASSWORD_PASTED_TRUNCATED")) + 16;

WCHAR* szErrorText = (WCHAR*) malloc (dwTextSize * sizeof (WCHAR));

StringCchPrintf (szErrorText, dwTextSize, GetString ("PASSWORD_PASTED_TRUNCATED"), dwMaxPassLen);

ebt.cbStruct = sizeof( EDITBALLOONTIP );

ebt.pszText = szErrorText;

ebt.pszTitle = lpszTitle;

ebt.ttiIcon = TTI_WARNING_LARGE; // tooltip warning icon

SendMessage(hwnd, EM_SHOWBALLOONTIP, 0, (LPARAM)&ebt);

MessageBeep (0xFFFFFFFF);

free (szErrorText);

}

else

SendMessage(hwnd, EM_HIDEBALLOONTIP, 0, 0);

}

GlobalUnlock(h);

}

CloseClipboard ();

}

if (bBlock)

return FALSE;

}

break;

case WM_CHAR:

HandlePasswordEditWmChar (hwnd, wParam);

break;

}

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

}

void ToNormalPwdField (HWND hwndDlg, UINT ctrlId)

{

HWND hwndCtrl = GetDlgItem (hwndDlg, ctrlId);

WNDPROC originalwp = (WNDPROC) GetWindowLongPtrW (hwndCtrl, GWLP_USERDATA);

DWORD dwMaxPassLen = bUseLegacyMaxPasswordLength? MAX_LEGACY_PASSWORD : MAX_PASSWORD;

SendMessage (hwndCtrl, EM_LIMITTEXT, dwMaxPassLen, 0);

// only change WNDPROC if not changed already

if (!originalwp)

{

SetWindowLongPtrW (hwndCtrl, GWLP_USERDATA, (LONG_PTR) GetWindowLongPtrW (hwndCtrl, GWLP_WNDPROC));

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

}

}

// This function currently serves the following purposes:

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

// - Determines how Windows skews the GUI aspect ratio (which happens when the user has a non-default DPI).

// The determined values must be used when performing some GUI operations and calculations.

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

{

switch (msg)

{

case WM_INITDIALOG:

{

HDC hDC = GetDC (hwndDlg);

if (hDC)

{

ScreenDPI = GetDeviceCaps (hDC, LOGPIXELSY);

ReleaseDC (hwndDlg, hDC);

}

DPIScaleFactorX = 1;

DPIScaleFactorY = 1;

DlgAspectRatio = 1;

if (ScreenDPI != USER_DEFAULT_SCREEN_DPI)

{

// Windows skews the GUI aspect ratio if the user has a non-default DPI. Hence, working with

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

RECT trec;

trec.right = 0;

trec.bottom = 0;

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

if (trec.right != 0 && trec.bottom != 0)

{

// The size of the 282x282 IDC_ASPECT_RATIO_CALIBRATION_BOX rendered at the default DPI (96) is 423x458

DPIScaleFactorX = (double) trec.right / 423;

DPIScaleFactorY = (double) trec.bottom / 458;

DlgAspectRatio = DPIScaleFactorX / DPIScaleFactorY;

}

}

EndDialog (hwndDlg, 0);

return 1;

}

case WM_CLOSE:

EndDialog (hwndDlg, 0);

return 1;

}

return 0;

}

/* Except in response to the WM_INITDIALOG message, the dialog box procedure

should return nonzero if it processes the message, and zero if it does

not. - see DialogProc */

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

{

WORD lw = LOWORD (wParam);

static HBITMAP hbmTextualLogoBitmapRescaled = NULL;

switch (msg)

{

case WM_INITDIALOG:

{

wchar_t szTmp[100];

RECT rec;

LocalizeDialog (hwndDlg, "IDD_ABOUT_DLG");

// Hyperlink

SetWindowText (GetDlgItem (hwndDlg, IDC_HOMEPAGE), L"www.idrix.fr");

ToHyperlink (hwndDlg, IDC_HOMEPAGE);

// Logo area background (must not keep aspect ratio; must retain Windows-imposed distortion)

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

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

// Resize the logo bitmap if the user has a non-default DPI

if (ScreenDPI != USER_DEFAULT_SCREEN_DPI)

{

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

hbmTextualLogoBitmapRescaled = RenderBitmap (MAKEINTRESOURCE (IDB_TEXTUAL_LOGO_288DPI),

GetDlgItem (hwndDlg, IDC_TEXTUAL_LOGO_IMG),

0, 0, 0, 0, FALSE, TRUE);

SetWindowPos (GetDlgItem (hwndDlg, IDC_ABOUT_BKG), HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);

}

// Version

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

StringCbPrintfW (szTmp, sizeof(szTmp), L"VeraCrypt %s", _T(VERSION_STRING) _T(VERSION_STRING_SUFFIX));

#ifdef _WIN64

StringCbCatW (szTmp, sizeof(szTmp), L" (64-bit)");

#else

StringCbCatW (szTmp, sizeof(szTmp), L" (32-bit)");

#endif

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

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

#endif

SetDlgItemText (hwndDlg, IDT_ABOUT_VERSION, szTmp);

SetDlgItemText (hwndDlg, IDT_ABOUT_RELEASE, TC_STR_RELEASED_BY);

// Credits

SendMessage (GetDlgItem (hwndDlg, IDC_ABOUT_CREDITS), WM_SETFONT, (WPARAM) hUserFont, (LPARAM) 0);

SendMessage (hwndDlg, WM_APP, 0, 0);

return 1;

}

case WM_APP:

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 2013-2022 IDRIX. All rights reserved.\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 1995-2017 Jean-loup Gailly and Mark Adler.\r\n"

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

L"Copyright \xA9 1999-2017 Dieter Baron and Thomas Klausner.\r\n"

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

L"Copyright \xA9 1999-2016 Jack Lloyd. All rights reserved.\r\n"

L"Copyright \xA9 2013-2019 Stephan Mueller <smueller@chronox.de>\r\n"

L"Copyright \xA9 1999-2021 Igor Pavlov\r\n\r\n"

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

L"Copyright \xA9 2013-2022 IDRIX. All rights reserved.\r\n\r\n"

L"An IDRIX Release");

return 1;

case WM_COMMAND:

if (lw == IDOK || lw == IDCANCEL)

{

PostMessage (hwndDlg, WM_CLOSE, 0, 0);

return 1;

}

if (lw == IDC_HOMEPAGE)

{

Applink ("main");

return 1;

}

// Disallow modification of credits

if (HIWORD (wParam) == EN_UPDATE)

{

SendMessage (hwndDlg, WM_APP, 0, 0);

return 1;

}

return 0;

case WM_CLOSE:

/* Delete buffered bitmaps (if any) */

if (hbmTextualLogoBitmapRescaled != NULL)

{

DeleteObject ((HGDIOBJ) hbmTextualLogoBitmapRescaled);

hbmTextualLogoBitmapRescaled = NULL;

}

EndDialog (hwndDlg, 0);

return 1;

}

return 0;

}

static HWND StaticModelessWaitDlgHandle = NULL;

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

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

{

WORD lw = LOWORD (wParam);

switch (msg)

{

case WM_INITDIALOG:

{

LocalizeDialog (hwndDlg, NULL);

return 0;

}

case WM_COMMAND:

if (lw == IDOK || lw == IDCANCEL)

return 1;

return 0;

case WM_CLOSE:

StaticModelessWaitDlgHandle = NULL;

EndDialog (hwndDlg, 0);

return 1;

}

return 0;

}

// Opens a dialog window saying "Please wait..." which is not modal and does not need any GUI refresh after initialization.

void DisplayStaticModelessWaitDlg (HWND parent)

{

if (StaticModelessWaitDlgHandle != NULL)

return; // Already shown

StaticModelessWaitDlgHandle = CreateDialogParamW (hInst, MAKEINTRESOURCEW (IDD_STATIC_MODELESS_WAIT_DLG), parent, (DLGPROC) StaticModelessWaitDlgProc, (LPARAM) 0);

ShowWindow (StaticModelessWaitDlgHandle, SW_SHOWNORMAL);

// Allow synchronous use with the GUI being instantly and fully rendered

ProcessPaintMessages (StaticModelessWaitDlgHandle, 500);

}

void CloseStaticModelessWaitDlg (void)

{

if (StaticModelessWaitDlgHandle == NULL)

return; // Not shown

DestroyWindow (StaticModelessWaitDlgHandle);

}

BOOL IsButtonChecked (HWND hButton)

{

if (SendMessage (hButton, BM_GETCHECK, 0, 0) == BST_CHECKED)

return TRUE;

else

return FALSE;

}

void CheckButton (HWND hButton)

{

SendMessage (hButton, BM_SETCHECK, BST_CHECKED, 0);

}

void LeftPadString (wchar_t *szTmp, int len, int targetLen, wchar_t filler)

{

int i;

if (targetLen <= len)

return;

for (i = targetLen-1; i >= (targetLen-len); i--)

szTmp [i] = szTmp [i-(targetLen-len)];

wmemset (szTmp, filler, targetLen-len);

szTmp [targetLen] = 0;

}

/* InitDialog - initialize the applications main dialog, this function should

be called only once in the dialogs WM_INITDIALOG message handler */

void InitDialog (HWND hwndDlg)

{

NONCLIENTMETRICSW metric;

static BOOL aboutMenuAppended = FALSE;

int nHeight;

LOGFONTW lf;

HMENU hMenu;

Font *font;

/* Fonts */

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

// Normal

font = GetFont ("font_normal");

metric.cbSize = sizeof (metric);

SystemParametersInfoW (SPI_GETNONCLIENTMETRICS, sizeof(metric), &metric, 0);

WindowTitleBarFont = CreateFontIndirectW (&metric.lfCaptionFont);

metric.lfMessageFont.lfHeight = CompensateDPIFont (!font ? -11 : -font->Size);

metric.lfMessageFont.lfWidth = 0;

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

{

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

}

else if (IsOSAtLeast (WIN_VISTA))

{

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

}

hUserFont = CreateFontIndirectW (&metric.lfMessageFont);

metric.lfMessageFont.lfUnderline = TRUE;

hUserUnderlineFont = CreateFontIndirectW (&metric.lfMessageFont);

metric.lfMessageFont.lfUnderline = FALSE;

metric.lfMessageFont.lfWeight = FW_BOLD;

hUserBoldFont = CreateFontIndirectW (&metric.lfMessageFont);

metric.lfMessageFont.lfUnderline = TRUE;

metric.lfMessageFont.lfWeight = FW_BOLD;

hUserUnderlineBoldFont = CreateFontIndirectW (&metric.lfMessageFont);

// Fixed-size (hexadecimal digits)

nHeight = CompensateDPIFont (-12);

lf.lfHeight = nHeight;

lf.lfWidth = 0;

lf.lfEscapement = 0;

lf.lfOrientation = 0;

lf.lfWeight = FW_NORMAL;

lf.lfItalic = FALSE;

lf.lfUnderline = FALSE;

lf.lfStrikeOut = FALSE;

lf.lfCharSet = DEFAULT_CHARSET;

lf.lfOutPrecision = OUT_DEFAULT_PRECIS;

lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;

lf.lfQuality = PROOF_QUALITY;

lf.lfPitchAndFamily = FF_DONTCARE;

StringCbCopyW (lf.lfFaceName, sizeof(lf.lfFaceName), L"Courier New");

hFixedDigitFont = CreateFontIndirectW (&lf);

if (hFixedDigitFont == NULL)

{

handleWin32Error (hwndDlg, SRC_POS);

AbortProcess ("NOFONT");

}

// Bold

font = GetFont ("font_bold");

nHeight = CompensateDPIFont (!font ? -13 : -font->Size);

lf.lfHeight = nHeight;

lf.lfWeight = FW_BLACK;

StringCbCopyW (lf.lfFaceName, sizeof(lf.lfFaceName), !font ? L"Arial" : font->FaceName);

hBoldFont = CreateFontIndirectW (&lf);

if (hBoldFont == NULL)

{

handleWin32Error (hwndDlg, SRC_POS);

AbortProcess ("NOFONT");

}

// Title

font = GetFont ("font_title");

nHeight = CompensateDPIFont (!font ? -21 : -font->Size);

lf.lfHeight = nHeight;

lf.lfWeight = FW_REGULAR;

StringCbCopyW (lf.lfFaceName, sizeof(lf.lfFaceName),!font ? L"Times New Roman" : font->FaceName);

hTitleFont = CreateFontIndirectW (&lf);

if (hTitleFont == NULL)

{

handleWin32Error (hwndDlg, SRC_POS);

AbortProcess ("NOFONT");

}

// Fixed-size

font = GetFont ("font_fixed");

nHeight = CompensateDPIFont (!font ? -12 : -font->Size);

lf.lfHeight = nHeight;

lf.lfWidth = 0;

lf.lfEscapement = 0;

lf.lfOrientation = 0;

lf.lfWeight = FW_NORMAL;

lf.lfItalic = FALSE;

lf.lfUnderline = FALSE;

lf.lfStrikeOut = FALSE;

lf.lfCharSet = DEFAULT_CHARSET;

lf.lfOutPrecision = OUT_DEFAULT_PRECIS;

lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;

lf.lfQuality = PROOF_QUALITY;

lf.lfPitchAndFamily = FF_DONTCARE;

StringCbCopyW (lf.lfFaceName, sizeof(lf.lfFaceName),!font ? L"Lucida Console" : font->FaceName);

hFixedFont = CreateFontIndirectW (&lf);

if (hFixedFont == NULL)

{

handleWin32Error (hwndDlg, SRC_POS);

AbortProcess ("NOFONT");

}

if (!aboutMenuAppended)

{

hMenu = GetSystemMenu (hwndDlg, FALSE);

AppendMenu (hMenu, MF_SEPARATOR, 0, L"");

AppendMenuW (hMenu, MF_ENABLED | MF_STRING, IDC_ABOUT, GetString ("ABOUTBOX"));

aboutMenuAppended = TRUE;

}

}

// The parameter maxMessagesToProcess prevents endless processing of paint messages

void ProcessPaintMessages (HWND hwnd, int maxMessagesToProcess)

{

MSG paintMsg;

int msgCounter = maxMessagesToProcess;

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

{

DispatchMessageW (&paintMsg);

}

}

HDC CreateMemBitmap (HINSTANCE hInstance, HWND hwnd, wchar_t *resource)

{

HBITMAP picture = LoadBitmap (hInstance, resource);

HDC viewDC = GetDC (hwnd), dcMem;

dcMem = CreateCompatibleDC (viewDC);

SetMapMode (dcMem, MM_TEXT);

SelectObject (dcMem, picture);

DeleteObject (picture);

ReleaseDC (hwnd, viewDC);

return dcMem;

}

/* Renders the specified bitmap at the specified location and stretches it to fit (anti-aliasing is applied).

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

both directions depending on the DPI). If bDirectRender is TRUE, bKeepAspectRatio is ignored.

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

deleted by calling DeleteObject() with the handle passed as the parameter.

Known Windows issues:

- For some reason, anti-aliasing is not applied if the source bitmap contains less than 16K pixels.

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

{

LRESULT lResult = 0;

HDC hdcSrc = CreateMemBitmap (hInst, hwndDest, resource);

if (!hdcSrc)

return NULL;

HGDIOBJ picture = GetCurrentObject (hdcSrc, OBJ_BITMAP);

HBITMAP hbmpRescaled = NULL;

BITMAP bitmap;

HDC hdcRescaled;

if (!bDirectRender && nWidth == 0 && nHeight == 0)

{

RECT rec;

GetClientRect (hwndDest, &rec);

if (bKeepAspectRatio)

{

if (DlgAspectRatio > 1)

{

// Do not fix this, it's correct. We use the Y scale factor intentionally for both

// directions to maintain aspect ratio (see above for more info).

nWidth = CompensateYDPI (rec.right);

nHeight = CompensateYDPI (rec.bottom);

}

else

{

// Do not fix this, it's correct. We use the X scale factor intentionally for both

// directions to maintain aspect ratio (see above for more info).

nWidth = CompensateXDPI (rec.right);

nHeight = CompensateXDPI (rec.bottom);

}

}

else

{

nWidth = CompensateXDPI (rec.right);

nHeight = CompensateYDPI (rec.bottom);

}

}

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

hdcRescaled = CreateCompatibleDC (hdcSrc);

if (hdcRescaled)

{

hbmpRescaled = CreateCompatibleBitmap (hdcSrc, nWidth, nHeight);

SelectObject (hdcRescaled, hbmpRescaled);

/* Anti-aliasing mode (HALFTONE is the only anti-aliasing algorithm natively supported by Windows 2000.

TODO: GDI+ offers higher quality -- InterpolationModeHighQualityBicubic) */

SetStretchBltMode (hdcRescaled, HALFTONE);

StretchBlt (hdcRescaled,

0,

0,

nWidth,

nHeight,

hdcSrc,

0,

0,

bitmap.bmWidth,

bitmap.bmHeight,

SRCCOPY);

DeleteDC (hdcSrc);

if (bDirectRender)

{

HDC hdcDest = GetDC (hwndDest);

if (hdcDest)

{

BitBlt (hdcDest, x, y, nWidth, nHeight, hdcRescaled, 0, 0, SRCCOPY);

ReleaseDC (hwndDest, hdcDest);

}

}

else

{

lResult = SendMessage (hwndDest, (UINT) STM_SETIMAGE, (WPARAM) IMAGE_BITMAP, (LPARAM) (HANDLE) hbmpRescaled);

}

if ((HGDIOBJ) lResult != NULL && (HGDIOBJ) lResult != (HGDIOBJ) hbmpRescaled)

DeleteObject ((HGDIOBJ) lResult);

DeleteDC (hdcRescaled);

}

return hbmpRescaled;

}

LRESULT CALLBACK

RedTick (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)

{

if (uMsg == WM_CREATE)

{

}

else if (uMsg == WM_DESTROY)

{

}

else if (uMsg == WM_TIMER)

{

}

else if (uMsg == WM_PAINT)

{

PAINTSTRUCT tmp;

HPEN hPen;

HDC hDC;

BOOL bEndPaint;

RECT Rect;

if (GetUpdateRect (hwnd, NULL, FALSE))

{

hDC = BeginPaint (hwnd, &tmp);

bEndPaint = TRUE;

if (hDC == NULL)

return DefWindowProcW (hwnd, uMsg, wParam, lParam);

}

else

{

hDC = GetDC (hwnd);

bEndPaint = FALSE;

}

GetClientRect (hwnd, &Rect);

hPen = CreatePen (PS_SOLID, 2, RGB (0, 255, 0));

if (hPen != NULL)

{

HGDIOBJ hObj = SelectObject (hDC, hPen);

WORD bx = LOWORD (GetDialogBaseUnits ());

WORD by = HIWORD (GetDialogBaseUnits ());

MoveToEx (hDC, (Rect.right - Rect.left) / 2, Rect.bottom, NULL);

LineTo (hDC, Rect.right, Rect.top);

MoveToEx (hDC, (Rect.right - Rect.left) / 2, Rect.bottom, NULL);

LineTo (hDC, (3 * bx) / 4, (2 * by) / 8);

SelectObject (hDC, hObj);

DeleteObject (hPen);

}

if (bEndPaint)

EndPaint (hwnd, &tmp);

else

ReleaseDC (hwnd, hDC);

return TRUE;

}

return DefWindowProcW (hwnd, uMsg, wParam, lParam);

}

BOOL

RegisterRedTick (HINSTANCE hInstance)

{

WNDCLASSW wc;

ULONG rc;

memset(&wc, 0 , sizeof wc);

wc.style = CS_HREDRAW | CS_VREDRAW;

wc.cbClsExtra = 0;

wc.cbWndExtra = 4;

wc.hInstance = hInstance;

wc.hIcon = LoadIcon (NULL, IDI_APPLICATION);

wc.hCursor = NULL;

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

wc.lpszClassName = L"VCREDTICK";

wc.lpfnWndProc = &RedTick;

rc = (ULONG) RegisterClassW (&wc);

return rc == 0 ? FALSE : TRUE;

}

BOOL

UnregisterRedTick (HINSTANCE hInstance)

{

return UnregisterClassW (L"VCREDTICK", hInstance);

}

LRESULT CALLBACK

SplashDlgProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)

{

return DefDlgProcW (hwnd, uMsg, wParam, lParam);

}

static int g_waitCursorCounter = 0;

void

WaitCursor ()

{

static HCURSOR hcWait = NULL;

if (hcWait == NULL)

hcWait = LoadCursor (NULL, IDC_WAIT);

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

{

if (!Silent) SetCursor (hcWait);

hCursor = hcWait;

}

g_waitCursorCounter++;

}

void

NormalCursor ()

{

static HCURSOR hcArrow = NULL;

if (hcArrow == NULL)

hcArrow = LoadCursor (NULL, IDC_ARROW);

if (g_waitCursorCounter > 0)

g_waitCursorCounter--;

if (g_waitCursorCounter == 0)

{

if (!Silent) SetCursor (hcArrow);

hCursor = NULL;

}

}

void

ArrowWaitCursor ()

{

static HCURSOR hcArrowWait = NULL;

if (hcArrowWait == NULL)

hcArrowWait = LoadCursor (NULL, IDC_APPSTARTING);

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

{

if (!Silent) SetCursor (hcArrowWait);

hCursor = hcArrowWait;

}

g_waitCursorCounter++;

}

void HandCursor ()

{

static HCURSOR hcHand = NULL;

if (hcHand == NULL)

hcHand = LoadCursor (NULL, IDC_HAND);

SetCursor (hcHand);

hCursor = hcHand;

}

void

AddComboPair (HWND hComboBox, const wchar_t *lpszItem, int value)

{

LPARAM nIndex;

nIndex = SendMessage (hComboBox, CB_ADDSTRING, 0, (LPARAM) lpszItem);

nIndex = SendMessage (hComboBox, CB_SETITEMDATA, nIndex, (LPARAM) value);

}

void

SelectAlgo (HWND hComboBox, int *algo_id)

{

LPARAM nCount = SendMessage (hComboBox, CB_GETCOUNT, 0, 0);

LPARAM x, i;

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

{

x = SendMessage (hComboBox, CB_GETITEMDATA, i, 0);

if (x == (LPARAM) *algo_id)

{

SendMessage (hComboBox, CB_SETCURSEL, i, 0);

return;

}

}

/* Something went wrong ; couldn't find the requested algo id so we drop

back to a default */

*algo_id = (int) SendMessage (hComboBox, CB_GETITEMDATA, 0, 0);

SendMessage (hComboBox, CB_SETCURSEL, 0, 0);

}

void PopulateWipeModeCombo (HWND hComboBox, BOOL bNA, BOOL bInPlaceEncryption, BOOL bHeaderWipe)

{

if (bNA)

{

AddComboPair (hComboBox, GetString ("NOT_APPLICABLE_OR_NOT_AVAILABLE"), TC_WIPE_NONE);

}

else

{

if (!bHeaderWipe)

{

AddComboPair (hComboBox, GetString ("WIPE_MODE_NONE"), TC_WIPE_NONE);

}

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

AddComboPair (hComboBox, GetString ("WIPE_MODE_3_DOD_5220"), TC_WIPE_3_DOD_5220);

AddComboPair (hComboBox, GetString ("WIPE_MODE_7_DOD_5220"), TC_WIPE_7_DOD_5220);

AddComboPair (hComboBox, GetString ("WIPE_MODE_35_GUTMANN"), TC_WIPE_35_GUTMANN);

if (bHeaderWipe)

AddComboPair (hComboBox, GetString ("WIPE_MODE_256"), TC_WIPE_256); // paranoid wipe for volume header

}

}

wchar_t *GetWipeModeName (WipeAlgorithmId modeId)

{

switch (modeId)

{

case TC_WIPE_NONE:

return GetString ("WIPE_MODE_NONE");

case TC_WIPE_1_RAND:

return GetString ("WIPE_MODE_1_RAND");

case TC_WIPE_3_DOD_5220:

return GetString ("WIPE_MODE_3_DOD_5220");

case TC_WIPE_7_DOD_5220:

return GetString ("WIPE_MODE_7_DOD_5220");

case TC_WIPE_35_GUTMANN:

return GetString ("WIPE_MODE_35_GUTMANN");

case TC_WIPE_256:

return GetString ("WIPE_MODE_256");

default:

return GetString ("NOT_APPLICABLE_OR_NOT_AVAILABLE");

}

}

wchar_t *GetPathType (const wchar_t *path, BOOL bUpperCase, BOOL *bIsPartition)

{

if (wcsstr (path, L"Partition")

&& wcsstr (path, L"Partition0") == NULL)

{

*bIsPartition = TRUE;

return GetString (bUpperCase ? "PARTITION_UPPER_CASE" : "PARTITION_LOWER_CASE");

}

else if (wcsstr (path, L"HarddiskVolume"))

{

*bIsPartition = TRUE;

return GetString (bUpperCase ? "VOLUME_UPPER_CASE" : "VOLUME_LOWER_CASE");

}

*bIsPartition = FALSE;

return GetString (bUpperCase ? "DEVICE_UPPER_CASE" : "DEVICE_LOWER_CASE");

}

LRESULT CALLBACK CustomDlgProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)

{

if (uMsg == WM_SETCURSOR && hCursor != NULL)

{

SetCursor (hCursor);

return TRUE;

}

return DefDlgProcW (hwnd, uMsg, wParam, lParam);

}

/*

static BOOL IsReturnAddress (DWORD64 address)

{

static size_t codeEnd = 0;

byte *sp = (byte *) address;

if (codeEnd == 0)

{

MEMORY_BASIC_INFORMATION mi;

if (VirtualQuery ((LPCVOID) 0x401000, &mi, sizeof (mi)) >= sizeof (mi))

codeEnd = (size_t) mi.BaseAddress + mi.RegionSize;

}

if (address < 0x401000 + 8 || address > codeEnd)

return FALSE;

return sp[-5] == 0xe8 // call ADDR

|| (sp[-6] == 0xff && sp[-5] == 0x15) // call [ADDR]

|| (sp[-2] == 0xff && (sp[-1] & 0xf0) == 0xd0); // call REG

}

*/

typedef struct

{

EXCEPTION_POINTERS *ExceptionPointers;

HANDLE ExceptionThread;

} ExceptionHandlerThreadArgs;

void ExceptionHandlerThread (void *threadArg)

{

ExceptionHandlerThreadArgs *args = (ExceptionHandlerThreadArgs *) threadArg;

EXCEPTION_POINTERS *ep = args->ExceptionPointers;

//DWORD addr;

DWORD exCode = ep->ExceptionRecord->ExceptionCode;

// SYSTEM_INFO si;

// wchar_t msg[8192];

// char modPath[MAX_PATH];

// int crc = 0;

// char url[MAX_URL_LENGTH];

// char lpack[128];

// stringstream callStack;

// addr = (DWORD) ep->ExceptionRecord->ExceptionAddress;

// PDWORD sp = (PDWORD) ep->ContextRecord->Esp;

// int frameNumber = 0;

switch (exCode)

{

case STATUS_IN_PAGE_ERROR:

case 0xeedfade:

// Exception not caused by VeraCrypt

MessageBoxW (0, GetString ("EXCEPTION_REPORT_EXT"),

GetString ("EXCEPTION_REPORT_TITLE"),

MB_ICONERROR | MB_OK | MB_SETFOREGROUND | MB_TOPMOST);

return;

}

// Call stack

/* HMODULE dbgDll = LoadLibrary ("dbghelp.dll");

if (dbgDll)

{

typedef DWORD (__stdcall *SymGetOptions_t) ();

typedef DWORD (__stdcall *SymSetOptions_t) (DWORD SymOptions);

typedef BOOL (__stdcall *SymInitialize_t) (HANDLE hProcess, PCSTR UserSearchPath, BOOL fInvadeProcess);

typedef BOOL (__stdcall *StackWalk64_t) (DWORD MachineType, HANDLE hProcess, HANDLE hThread, LPSTACKFRAME64 StackFrame, PVOID ContextRecord, PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine, PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine, PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine, PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress);

typedef BOOL (__stdcall * SymFromAddr_t) (HANDLE hProcess, DWORD64 Address, PDWORD64 Displacement, PSYMBOL_INFO Symbol);

SymGetOptions_t DbgHelpSymGetOptions = (SymGetOptions_t) GetProcAddress (dbgDll, "SymGetOptions");

SymSetOptions_t DbgHelpSymSetOptions = (SymSetOptions_t) GetProcAddress (dbgDll, "SymSetOptions");

SymInitialize_t DbgHelpSymInitialize = (SymInitialize_t) GetProcAddress (dbgDll, "SymInitialize");

PFUNCTION_TABLE_ACCESS_ROUTINE64 DbgHelpSymFunctionTableAccess64 = (PFUNCTION_TABLE_ACCESS_ROUTINE64) GetProcAddress (dbgDll, "SymFunctionTableAccess64");

PGET_MODULE_BASE_ROUTINE64 DbgHelpSymGetModuleBase64 = (PGET_MODULE_BASE_ROUTINE64) GetProcAddress (dbgDll, "SymGetModuleBase64");

StackWalk64_t DbgHelpStackWalk64 = (StackWalk64_t) GetProcAddress (dbgDll, "StackWalk64");

SymFromAddr_t DbgHelpSymFromAddr = (SymFromAddr_t) GetProcAddress (dbgDll, "SymFromAddr");

if (DbgHelpSymGetOptions && DbgHelpSymSetOptions && DbgHelpSymInitialize && DbgHelpSymFunctionTableAccess64 && DbgHelpSymGetModuleBase64 && DbgHelpStackWalk64 && DbgHelpSymFromAddr)

{

DbgHelpSymSetOptions (DbgHelpSymGetOptions() | SYMOPT_DEFERRED_LOADS | SYMOPT_ALLOW_ABSOLUTE_SYMBOLS | SYMOPT_NO_CPP);

if (DbgHelpSymInitialize (GetCurrentProcess(), NULL, TRUE))

{

STACKFRAME64 frame;

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

frame.AddrPC.Offset = ep->ContextRecord->Eip;

frame.AddrPC.Mode = AddrModeFlat;

frame.AddrStack.Offset = ep->ContextRecord->Esp;

frame.AddrStack.Mode = AddrModeFlat;

frame.AddrFrame.Offset = ep->ContextRecord->Ebp;

frame.AddrFrame.Mode = AddrModeFlat;

string lastSymbol;

while (frameNumber < 32 && DbgHelpStackWalk64 (IMAGE_FILE_MACHINE_I386, GetCurrentProcess(), args->ExceptionThread, &frame, ep->ContextRecord, NULL, DbgHelpSymFunctionTableAccess64, DbgHelpSymGetModuleBase64, NULL))

{

if (!frame.AddrPC.Offset)

continue;

ULONG64 symbolBuffer[(sizeof (SYMBOL_INFO) + MAX_SYM_NAME * sizeof (TCHAR) + sizeof (ULONG64) - 1) / sizeof (ULONG64)];

memset (symbolBuffer, 0, sizeof (symbolBuffer));

PSYMBOL_INFO symbol = (PSYMBOL_INFO) symbolBuffer;

symbol->SizeOfStruct = sizeof (SYMBOL_INFO);

symbol->MaxNameLen = MAX_SYM_NAME;

if (DbgHelpSymFromAddr (GetCurrentProcess(), frame.AddrPC.Offset, NULL, symbol) && symbol->NameLen > 0)

{

for (size_t i = 0; i < symbol->NameLen; ++i)

{

if (!isalnum (symbol->Name[i]))

symbol->Name[i] = '_';

}

if (symbol->Name != lastSymbol)

callStack << "&st" << frameNumber++ << "=" << symbol->Name;

lastSymbol = symbol->Name;

}

else if (frameNumber == 0 || IsReturnAddress (frame.AddrPC.Offset))

{

callStack << "&st" << frameNumber++ << "=0x" << hex << frame.AddrPC.Offset << dec;

}

}

}

}

}

// StackWalk64() may fail due to missing frame pointers

list <DWORD> retAddrs;

if (frameNumber == 0)

retAddrs.push_back (ep->ContextRecord->Eip);

retAddrs.push_back (0);

MEMORY_BASIC_INFORMATION mi;

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

PDWORD stackTop = (PDWORD)((byte *) mi.BaseAddress + mi.RegionSize);

int i = 0;

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

{

if (IsReturnAddress (sp[i]))

{

bool duplicate = false;

foreach (DWORD prevAddr, retAddrs)

{

if (sp[i] == prevAddr)

{

duplicate = true;

break;

}

}

if (!duplicate)

retAddrs.push_back (sp[i]);

}

i++;

}

if (retAddrs.size() > 1)

{

foreach (DWORD addr, retAddrs)

{

callStack << "&st" << frameNumber++ << "=0x" << hex << addr << dec;

}

}

// Checksum of the module

if (GetModuleFileName (NULL, modPath, sizeof (modPath)))

{

HANDLE h = CreateFile (modPath, FILE_READ_DATA | FILE_READ_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);

if (h != INVALID_HANDLE_VALUE)

{

BY_HANDLE_FILE_INFORMATION fi;

if (GetFileInformationByHandle (h, &fi))

{

char *buf = (char *) malloc (fi.nFileSizeLow);

if (buf)

{

DWORD bytesRead;

if (ReadFile (h, buf, fi.nFileSizeLow, &bytesRead, NULL) && bytesRead == fi.nFileSizeLow)

crc = GetCrc32 ((unsigned char *) buf, fi.nFileSizeLow);

free (buf);

}

}

CloseHandle (h);

}

}

GetSystemInfo (&si);

if (LocalizationActive)

sprintf_s (lpack, sizeof (lpack), "&langpack=%s_%s", GetPreferredLangId (), GetActiveLangPackVersion ());

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

, CurrentOSMajor

, CurrentOSMinor

, CurrentOSServicePack

, Is64BitOs () ? "x64" : "x86"

, si.dwNumberOfProcessors

#ifdef TCMOUNT

,"main"

#endif

#ifdef VOLFORMAT

,"format"

#endif

#ifdef SETUP

,"setup"

#endif

, crc

, LastDialogId ? LastDialogId : "-"

, exCode

, addr);

string urlStr = url + callStack.str();

_snwprintf (msg, array_capacity (msg), GetString ("EXCEPTION_REPORT"), urlStr.c_str());

if (IDYES == MessageBoxW (0, msg, GetString ("EXCEPTION_REPORT_TITLE"), MB_ICONERROR | MB_YESNO | MB_DEFBUTTON1))

ShellExecute (NULL, "open", urlStr.c_str(), NULL, NULL, SW_SHOWNORMAL);

else */

UnhandledExceptionFilter (ep);

}

LONG __stdcall ExceptionHandler (EXCEPTION_POINTERS *ep)

{

SetUnhandledExceptionFilter (NULL);

if (SystemFileSelectorCallPending && SystemFileSelectorCallerThreadId == GetCurrentThreadId())

{

MessageBoxW (NULL, GetString ("EXCEPTION_REPORT_EXT_FILESEL"), GetString ("EXCEPTION_REPORT_TITLE"), MB_ICONERROR | MB_OK | MB_SETFOREGROUND | MB_TOPMOST);

UnhandledExceptionFilter (ep);

return EXCEPTION_EXECUTE_HANDLER;

}

ExceptionHandlerThreadArgs args;

args.ExceptionPointers = ep;

args.ExceptionThread = GetCurrentThread();

WaitForSingleObject ((HANDLE) _beginthread (ExceptionHandlerThread, 0, &args), INFINITE);

return EXCEPTION_EXECUTE_HANDLER;

}

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

{

TC_THROW_FATAL_EXCEPTION;

}

static LRESULT CALLBACK NonInstallUacWndProc (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

{

return DefWindowProcW (hWnd, message, wParam, lParam);

}

BOOL LaunchElevatedProcess (HWND hwndDlg, const wchar_t* szModPath, const wchar_t* args)

{

wchar_t newCmdLine[4096];

WNDCLASSEXW wcex;

HWND hWnd;

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

wcex.cbSize = sizeof(WNDCLASSEX);

wcex.lpfnWndProc = (WNDPROC) NonInstallUacWndProc;

wcex.hInstance = hInst;

wcex.lpszClassName = L"VeraCrypt";

RegisterClassExW (&wcex);

// A small transparent window is necessary to bring the new instance to foreground

hWnd = CreateWindowExW (WS_EX_TOOLWINDOW | WS_EX_LAYERED,

L"VeraCrypt", L"VeraCrypt", 0,

GetSystemMetrics (SM_CXSCREEN)/2,

GetSystemMetrics (SM_CYSCREEN)/2,

1, 1, NULL, NULL, hInst, NULL);

SetLayeredWindowAttributes (hWnd, 0, 0, LWA_ALPHA);

ShowWindow (hWnd, SW_SHOWNORMAL);

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

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

if ((int)ShellExecuteW (hWnd, L"runas", szModPath, newCmdLine, NULL, SW_SHOWNORMAL) <= 32)

{

if (hwndDlg)

handleWin32Error (hwndDlg, SRC_POS);

return FALSE;

}

else

{

Sleep (2000);

return TRUE;

}

}

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

// Returns TRUE if the mutex is (or had been) successfully acquired (otherwise FALSE).

BOOL CreateSysEncMutex (void)

{

return TCCreateMutex (&hSysEncMutex, TC_MUTEX_NAME_SYSENC);

}

BOOL InstanceHasSysEncMutex (void)

{

return (hSysEncMutex != NULL);

}

// Mutex handling to prevent multiple instances of the wizard from dealing with system encryption

void CloseSysEncMutex (void)

{

TCCloseMutex (&hSysEncMutex);

}

// Returns TRUE if the mutex is (or had been) successfully acquired (otherwise FALSE).

BOOL CreateNonSysInplaceEncMutex (void)

{

return TCCreateMutex (&hNonSysInplaceEncMutex, TC_MUTEX_NAME_NONSYS_INPLACE_ENC);

}

BOOL InstanceHasNonSysInplaceEncMutex (void)

{

return (hNonSysInplaceEncMutex != NULL);

}

void CloseNonSysInplaceEncMutex (void)

{

TCCloseMutex (&hNonSysInplaceEncMutex);

}

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

BOOL NonSysInplaceEncInProgressElsewhere (void)

{

return (!InstanceHasNonSysInplaceEncMutex ()

&& 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.

// Returns TRUE if the mutex is (or had been) successfully acquired (otherwise FALSE).

BOOL CreateDriverSetupMutex (void)

{

return TCCreateMutex (&hDriverSetupMutex, TC_MUTEX_NAME_DRIVER_SETUP);

}

void CloseDriverSetupMutex (void)

{

TCCloseMutex (&hDriverSetupMutex);

}

BOOL CreateAppSetupMutex (void)

{

return TCCreateMutex (&hAppSetupMutex, TC_MUTEX_NAME_APP_SETUP);

}

void CloseAppSetupMutex (void)

{

TCCloseMutex (&hAppSetupMutex);

}

BOOL IsTrueCryptInstallerRunning (void)

{

return (MutexExistsOnSystem (TC_MUTEX_NAME_APP_SETUP));

}

// Returns TRUE if the mutex is (or had been) successfully acquired (otherwise FALSE).

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

{

if (*hMutex != NULL)

return TRUE; // This instance already has the mutex

*hMutex = CreateMutex (NULL, TRUE, name);

if (*hMutex == NULL)

{

// In multi-user configurations, the OS returns "Access is denied" here when a user attempts

// to acquire the mutex if another user already has. However, on Vista, "Access is denied" is

// returned also if the mutex is owned by a process with admin rights while we have none.

return FALSE;

}

if (GetLastError () == ERROR_ALREADY_EXISTS)

{

ReleaseMutex (*hMutex);

CloseHandle (*hMutex);

*hMutex = NULL;

return FALSE;

}

return TRUE;

}

void TCCloseMutex (volatile HANDLE *hMutex)

{

if (*hMutex != NULL)

{

if (ReleaseMutex (*hMutex)

&& CloseHandle (*hMutex))

*hMutex = NULL;

}

}

// Returns TRUE if a process running on the system has the specified mutex (otherwise FALSE).

BOOL MutexExistsOnSystem (wchar_t *name)

{

if (name[0] == 0)

return FALSE;

HANDLE hMutex = OpenMutex (MUTEX_ALL_ACCESS, FALSE, name);

if (hMutex == NULL)

{

if (GetLastError () == ERROR_FILE_NOT_FOUND)

return FALSE;

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

return TRUE;

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

return FALSE;

}

CloseHandle (hMutex);

return TRUE;

}

uint32 ReadDriverConfigurationFlags ()

{

DWORD configMap;

if (!ReadLocalMachineRegistryDword (L"SYSTEM\\CurrentControlSet\\Services\\veracrypt", TC_DRIVER_CONFIG_REG_VALUE_NAME, &configMap))

configMap = 0;

return configMap;

}

uint32 ReadServiceConfigurationFlags ()

{

DWORD configMap;

if (!ReadLocalMachineRegistryDword (L"SYSTEM\\CurrentControlSet\\Services\\" TC_SYSTEM_FAVORITES_SERVICE_NAME, TC_SYSTEM_FAVORITES_SERVICE_NAME L"Config", &configMap))

configMap = 0;

return configMap;

}

uint32 ReadEncryptionThreadPoolFreeCpuCountLimit ()

{

DWORD count;

if (!ReadLocalMachineRegistryDword (L"SYSTEM\\CurrentControlSet\\Services\\veracrypt", TC_ENCRYPTION_FREE_CPU_COUNT_REG_VALUE_NAME, &count))

count = 0;

return count;

}

BOOL LoadSysEncSettings ()

{

BOOL status = TRUE;

DWORD size = 0;

char *sysEncCfgFileBuf = LoadFile (GetConfigPath (TC_APPD_FILENAME_SYSTEM_ENCRYPTION), &size);

char *xml = sysEncCfgFileBuf;

char paramName[100], paramVal[MAX_PATH];

// Defaults

int newSystemEncryptionStatus = SYSENC_STATUS_NONE;

WipeAlgorithmId newnWipeMode = TC_WIPE_NONE;

if (!FileExists (GetConfigPath (TC_APPD_FILENAME_SYSTEM_ENCRYPTION)))

{

SystemEncryptionStatus = newSystemEncryptionStatus;

nWipeMode = newnWipeMode;

}

if (xml == NULL)

{

return FALSE;

}

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

{

XmlGetAttributeText (xml, "key", paramName, sizeof (paramName));

XmlGetNodeText (xml, paramVal, sizeof (paramVal));

if (strcmp (paramName, "SystemEncryptionStatus") == 0)

{

newSystemEncryptionStatus = atoi (paramVal);

}

else if (strcmp (paramName, "WipeMode") == 0)

{

newnWipeMode = (WipeAlgorithmId) atoi (paramVal);

}

xml++;

}

SystemEncryptionStatus = newSystemEncryptionStatus;

nWipeMode = newnWipeMode;

free (sysEncCfgFileBuf);

return status;

}

// Returns the number of partitions where non-system in-place encryption is progress or had been in progress

// but was interrupted. In addition, via the passed pointer, returns the last selected wipe algorithm ID.

int LoadNonSysInPlaceEncSettings (WipeAlgorithmId *wipeAlgorithm)

{

char *fileBuf = NULL;

char *fileBuf2 = NULL;

DWORD size, size2;

int count;

*wipeAlgorithm = TC_WIPE_NONE;

if (!FileExists (GetConfigPath (TC_APPD_FILENAME_NONSYS_INPLACE_ENC)))

return 0;

if ((fileBuf = LoadFile (GetConfigPath (TC_APPD_FILENAME_NONSYS_INPLACE_ENC), &size)) == NULL)

return 0;

if (FileExists (GetConfigPath (TC_APPD_FILENAME_NONSYS_INPLACE_ENC_WIPE)))

{

if ((fileBuf2 = LoadFile (GetConfigPath (TC_APPD_FILENAME_NONSYS_INPLACE_ENC_WIPE), &size2)) != NULL)

*wipeAlgorithm = (WipeAlgorithmId) atoi (fileBuf2);

}

count = atoi (fileBuf);

if (fileBuf != NULL)

TCfree (fileBuf);

if (fileBuf2 != NULL)

TCfree (fileBuf2);

return (count);

}

void RemoveNonSysInPlaceEncNotifications (void)

{

if (FileExists (GetConfigPath (TC_APPD_FILENAME_NONSYS_INPLACE_ENC)))

_wremove (GetConfigPath (TC_APPD_FILENAME_NONSYS_INPLACE_ENC));

if (FileExists (GetConfigPath (TC_APPD_FILENAME_NONSYS_INPLACE_ENC_WIPE)))

_wremove (GetConfigPath (TC_APPD_FILENAME_NONSYS_INPLACE_ENC_WIPE));

if (!IsNonInstallMode () && SystemEncryptionStatus == SYSENC_STATUS_NONE)

ManageStartupSeqWiz (TRUE, L"");

}

void SavePostInstallTasksSettings (int command)

{

FILE *f = NULL;

if (IsNonInstallMode() && command != TC_POST_INSTALL_CFG_REMOVE_ALL)

return;

switch (command)

{

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

_wremove (GetConfigPath (TC_APPD_FILENAME_POST_INSTALL_TASK_RESCUE_DISK));

break;

case TC_POST_INSTALL_CFG_TUTORIAL:

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

break;

case TC_POST_INSTALL_CFG_RELEASE_NOTES:

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

break;

case TC_POST_INSTALL_CFG_RESCUE_DISK:

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

break;

default:

return;

}

if (f == NULL)

return;

if (fputws (L"1", f) < 0)

{

// Error

fclose (f);

return;

}

TCFlushFile (f);

fclose (f);

}

void DoPostInstallTasks (HWND hwndDlg)

{

BOOL bDone = FALSE;

if (FileExists (GetConfigPath (TC_APPD_FILENAME_POST_INSTALL_TASK_TUTORIAL)))

{

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

Applink ("beginnerstutorial");

bDone = TRUE;

}

if (FileExists (GetConfigPath (TC_APPD_FILENAME_POST_INSTALL_TASK_RELEASE_NOTES)))

{

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

Applink ("releasenotes");

bDone = TRUE;

}

if (FileExists (GetConfigPath (TC_APPD_FILENAME_POST_INSTALL_TASK_RESCUE_DISK)))

{

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

PostMessage (hwndDlg, VC_APPMSG_CREATE_RESCUE_DISK, 0, 0);

bDone = TRUE;

}

if (bDone)

SavePostInstallTasksSettings (TC_POST_INSTALL_CFG_REMOVE_ALL);

}

static void LoadSystemDll (LPCTSTR szModuleName, HMODULE *pHandle, BOOL bIgnoreError, const char* srcPos)

{

wchar_t dllPath[MAX_PATH];

/* Load dll explictely from System32 to avoid Dll hijacking attacks*/

if (!GetSystemDirectory(dllPath, MAX_PATH))

StringCbCopyW(dllPath, sizeof(dllPath), L"C:\\Windows\\System32");

StringCbCatW(dllPath, sizeof(dllPath), L"\\");

StringCbCatW(dllPath, sizeof(dllPath), szModuleName);

if (((*pHandle = LoadLibrary(dllPath)) == NULL) && !bIgnoreError)

{

// This error is fatal

handleWin32Error (NULL, srcPos);

AbortProcess ("INIT_DLL");

}

}

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

InitCommonControlsPtr InitCommonControlsFn = NULL;

wchar_t modPath[MAX_PATH];

GetModuleFileNameW (NULL, modPath, ARRAYSIZE (modPath));

/* remove current directory from dll search path */

SetDllDirectoryFn = (SetDllDirectoryPtr) GetProcAddress (GetModuleHandle(L"kernel32.dll"), "SetDllDirectoryW");

SetSearchPathModeFn = (SetSearchPathModePtr) GetProcAddress (GetModuleHandle(L"kernel32.dll"), "SetSearchPathMode");

SetDefaultDllDirectoriesFn = (SetDefaultDllDirectoriesPtr) GetProcAddress (GetModuleHandle(L"kernel32.dll"), "SetDefaultDllDirectories");

if (SetDllDirectoryFn)

SetDllDirectoryFn (L"");

if (SetSearchPathModeFn)

SetSearchPathModeFn (BASE_SEARCH_PATH_ENABLE_SAFE_SEARCHMODE | BASE_SEARCH_PATH_PERMANENT);

if (SetDefaultDllDirectoriesFn)

SetDefaultDllDirectoriesFn (LOAD_LIBRARY_SEARCH_SYSTEM32);

InitOSVersionInfo();

VirtualLock (&CmdTokenPin, sizeof (CmdTokenPin));

InitGlobalLocks ();

LoadSystemDll (L"msvcrt.dll", &hmsvcrtdll, TRUE, SRC_POS);

LoadSystemDll (L"ntmarta.dll", &hntmartadll, TRUE, SRC_POS);

LoadSystemDll (L"MPR.DLL", &hmprdll, TRUE, SRC_POS);

#ifdef SETUP

if (IsOSAtLeast (WIN_7))

{

LoadSystemDll (L"ProfApi.DLL", &hProfApiDll, TRUE, SRC_POS);

LoadSystemDll (L"cryptbase.dll", &hcryptbasedll, TRUE, SRC_POS);

LoadSystemDll (L"sspicli.dll", &hsspiclidll, TRUE, SRC_POS);

}

#endif

LoadSystemDll (L"psapi.dll", &hpsapidll, TRUE, SRC_POS);

LoadSystemDll (L"secur32.dll", &hsecur32dll, TRUE, SRC_POS);

LoadSystemDll (L"msasn1.dll", &hmsasn1dll, TRUE, SRC_POS);

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

if (IsOSAtLeast (WIN_7))

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

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

LoadSystemDll (L"msls31.dll", &hMsls31, TRUE, SRC_POS);

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

LoadSystemDll (L"SHLWAPI.DLL", &hShlwapiDll, FALSE, SRC_POS);

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

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

#ifdef SETUP

if (nCurrentOS < WIN_7)

{

if (nCurrentOS == WIN_XP)

{

LoadSystemDll (L"imm32.dll", &himm32dll, TRUE, SRC_POS);

LoadSystemDll (L"MSCTF.dll", &hMSCTFdll, TRUE, SRC_POS);

LoadSystemDll (L"fltlib.dll", &hfltlibdll, TRUE, SRC_POS);

LoadSystemDll (L"wbem\\framedyn.dll", &hframedyndll, 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"atl.dll", &hsppdll, TRUE, SRC_POS);

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

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

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

}

#endif

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

if (IsOSAtLeast (WIN_7))

{

LoadSystemDll (L"CryptSP.dll", &hCryptSpDll, 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"bcrypt.dll", &hbcryptdll, TRUE, SRC_POS);

LoadSystemDll (L"bcryptprimitives.dll", &hbcryptprimitivesdll, TRUE, SRC_POS);

}

#ifndef SETUP

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

ImageList_CreateFn = (ImageList_CreatePtr) GetProcAddress (hComctl32Dll, "ImageList_Create");

if (InitCommonControlsFn && ImageList_AddFn && ImageList_CreateFn)

{

InitCommonControlsFn();

}

else

AbortProcess ("INIT_DLL");

LoadSystemDll (L"Riched20.dll", &hRichEditDll, FALSE, SRC_POS);

LoadSystemDll (L"Advapi32.dll", &hAdvapi32Dll, FALSE, SRC_POS);

#if !defined(SETUP)

if (!VerifyModuleSignature (modPath))

AbortProcess ("DIST_PACKAGE_CORRUPTED");

#endif

// Get SetupAPI functions pointers

SetupCloseInfFileFn = (SetupCloseInfFilePtr) GetProcAddress (hSetupDll, "SetupCloseInfFile");

SetupDiOpenClassRegKeyFn = (SetupDiOpenClassRegKeyPtr) GetProcAddress (hSetupDll, "SetupDiOpenClassRegKey");

SetupInstallFromInfSectionWFn = (SetupInstallFromInfSectionWPtr) GetProcAddress (hSetupDll, "SetupInstallFromInfSectionW");

SetupOpenInfFileWFn = (SetupOpenInfFileWPtr) GetProcAddress (hSetupDll, "SetupOpenInfFileW");

if (!SetupCloseInfFileFn || !SetupDiOpenClassRegKeyFn || !SetupInstallFromInfSectionWFn || !SetupOpenInfFileWFn)

AbortProcess ("INIT_DLL");

// Get SHDeleteKeyW,SHStrDupW, UrlUnescapeW functions pointers

SHDeleteKeyWFn = (SHDeleteKeyWPtr) GetProcAddress (hShlwapiDll, "SHDeleteKeyW");

SHStrDupWFn = (SHStrDupWPtr) GetProcAddress (hShlwapiDll, "SHStrDupW");

UrlUnescapeWFn = (UrlUnescapeWPtr) GetProcAddress(hShlwapiDll, "UrlUnescapeW");

IUnknown_QueryServicePtr = (IUnknown_QueryServiceFn) GetProcAddress(hShlwapiDll, "IUnknown_QueryService");

if (!IUnknown_QueryServicePtr)

IUnknown_QueryServicePtr = (IUnknown_QueryServiceFn) GetProcAddress(hShlwapiDll, MAKEINTRESOURCEA(176));

if (!SHDeleteKeyWFn || !SHStrDupWFn || !UrlUnescapeWFn || !IUnknown_QueryServicePtr)

AbortProcess ("INIT_DLL");

if (IsOSAtLeast (WIN_VISTA))

{

/* Get ChangeWindowMessageFilter used to enable some messages bypasss UIPI (User Interface Privilege Isolation) */

ChangeWindowMessageFilterFn = (ChangeWindowMessageFilterPtr) GetProcAddress (GetModuleHandle (L"user32.dll"), "ChangeWindowMessageFilter");

#ifndef SETUP

/* enable drag-n-drop when we are running elevated */

AllowMessageInUIPI (WM_DROPFILES);

AllowMessageInUIPI (WM_COPYDATA);

AllowMessageInUIPI (WM_COPYGLOBALDATA);

#endif

}

// Get CreateProcessWithTokenW function pointer

CreateProcessWithTokenWPtr = (CreateProcessWithTokenWFn) GetProcAddress(hAdvapi32Dll, "CreateProcessWithTokenW");

/* Save the instance handle for later */

hInst = hInstance;

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

CoInitialize (NULL);

#ifndef SETUP

// Application ID

typedef HRESULT (WINAPI *SetAppId_t) (PCWSTR appID);

SetAppId_t setAppId = (SetAppId_t) GetProcAddress (GetModuleHandle (L"shell32.dll"), "SetCurrentProcessExplicitAppUserModelID");

if (setAppId)

setAppId (TC_APPLICATION_ID);

#endif

// Language

langId[0] = 0;

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

#ifndef SETUP

if (langId[0] == 0)

{

// check if user selected a language during installation

WCHAR uiLang[6];

ReadRegistryString (L"Software\\VeraCrypt", L"SetupUILanguage", L"", uiLang, sizeof (uiLang));

if (0 < WideCharToMultiByte (CP_ACP, 0, uiLang, -1, langId, sizeof (langId), NULL, NULL))

{

SetPreferredLangId (langId);

bLanguageSetInSetup = TRUE;

}

}

#ifndef VCEXPANDER

// delete the registry key created by the installer (if any)

DeleteRegistryKey (HKEY_CURRENT_USER, L"Software\\VeraCrypt");

#endif

#endif

if (langId[0] == 0)

{

if (IsNonInstallMode ())

{

// only support automatic use of a language file in portable mode

// this is achieved by placing a unique language XML file in the same

// place as portable VeraCrypt binaries.

DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_LANGUAGE), NULL,

(DLGPROC) LanguageDlgProc, (LPARAM) 1);

}

else

{

// when installed, force using English as default language

SetPreferredLangId ("en");

}

}

LoadLanguageFile ();

#ifndef SETUP

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

exit (1);

}

#endif

SetUnhandledExceptionFilter (ExceptionHandler);

_set_invalid_parameter_handler (InvalidParameterHandler);

RemoteSession = GetSystemMetrics (SM_REMOTESESSION) != 0;

#ifndef VC_SKIP_OS_DRIVER_REQ_CHECK

if (!IsSupportedOS())

{

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

exit (1);

}

#else

// in TESTSIGNING mode, we support only Windows Vista, Windows 7, Windows 8/8.1

if ( !IsOSVersionAtLeast(WIN_VISTA, 0)

#ifndef SETUP

|| IsOSVersionAtLeast(WIN_10, 0)

#else

|| (IsOSVersionAtLeast(WIN_10, 0) && !bMakePackage)

#endif

)

{

MessageBoxW (NULL, L"TESTSIGNING version of VeraCrypt targets only Windows Vista, Windows 7 and Windows 8/8.1.\n\nPlease use the standard version of VeraCrypt instead.", lpszTitle, MB_ICONSTOP);

exit (1);

}

else if ( !IsTestSigningModeEnabled()

#ifdef SETUP

&& !bMakePackage

#endif

)

{

MessageBoxW (NULL, L"Test-Signing Mode, which is required to run VeraCrypt TESTSIGNING binaries, is not enabled in Windows.\n\nExecution aborted!", lpszTitle, MB_ICONSTOP);

exit (1);

}

#endif

else

{

// Service pack check & warnings about critical MS issues

switch (nCurrentOS)

{

case WIN_XP:

if (CurrentOSServicePack < 1)

{

HKEY k;

// PE environment does not report version of SP

if (RegOpenKeyExW (HKEY_LOCAL_MACHINE, L"System\\CurrentControlSet\\Control\\minint", 0, KEY_READ, &k) != ERROR_SUCCESS)

Warning ("LARGE_IDE_WARNING_XP", NULL);

else

RegCloseKey (k);

}

break;

}

}

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

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

{

handleWin32Error (NULL, SRC_POS);

AbortProcess ("INIT_REGISTER");

}

#ifndef SETUP

wc.hIcon = LoadIcon (hInstance, MAKEINTRESOURCE (IDI_TRUECRYPT_ICON));

#else

#include "../setup/resource.h"

wc.hIcon = LoadIcon (hInstance, MAKEINTRESOURCE (IDI_SETUP));

#endif

wc.lpszClassName = TC_DLG_CLASS;

wc.lpfnWndProc = &CustomDlgProc;

wc.hCursor = LoadCursor (NULL, IDC_ARROW);

wc.cbWndExtra = DLGWINDOWEXTRA;

hDlgClass = RegisterClassW (&wc);

if (hDlgClass == 0)

{

handleWin32Error (NULL, SRC_POS);

AbortProcess ("INIT_REGISTER");

}

wc.lpszClassName = TC_SPLASH_CLASS;

wc.lpfnWndProc = &SplashDlgProc;

wc.hCursor = LoadCursor (NULL, IDC_ARROW);

wc.cbWndExtra = DLGWINDOWEXTRA;

hSplashClass = RegisterClassW (&wc);

if (hSplashClass == 0)

{

handleWin32Error (NULL, SRC_POS);

AbortProcess ("INIT_REGISTER");

}

// DPI and GUI aspect ratio

DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_AUXILIARY_DLG), NULL,

(DLGPROC) AuxiliaryDlgProc, (LPARAM) 1);

InitHelpFileName ();

#ifndef SETUP

#ifdef _WIN64

if (IsOSAtLeast (WIN_7))

{

EnableRamEncryption ((ReadDriverConfigurationFlags() & VC_DRIVER_CONFIG_ENABLE_RAM_ENCRYPTION) ? TRUE : FALSE);

if (IsRamEncryptionEnabled())

{

if (!InitializeSecurityParameters(GetAppRandomSeed))

AbortProcess("OUTOFMEMORY");

}

}

#endif

if (!EncryptionThreadPoolStart (ReadEncryptionThreadPoolFreeCpuCountLimit()))

{

handleWin32Error (NULL, SRC_POS);

FREE_DLL (hRichEditDll);

FREE_DLL (hComctl32Dll);

FREE_DLL (hSetupDll);

FREE_DLL (hShlwapiDll);

FREE_DLL (hProfApiDll);

FREE_DLL (hUsp10Dll);

FREE_DLL (hCryptSpDll);

FREE_DLL (hUXThemeDll);

FREE_DLL (hUserenvDll);

FREE_DLL (hRsaenhDll);

FREE_DLL (himm32dll);

FREE_DLL (hMSCTFdll);

FREE_DLL (hfltlibdll);

FREE_DLL (hframedyndll);

FREE_DLL (hpsapidll);

FREE_DLL (hsecur32dll);

FREE_DLL (hnetapi32dll);

FREE_DLL (hauthzdll);

FREE_DLL (hxmllitedll);

FREE_DLL (hmprdll);

FREE_DLL (hsppdll);

FREE_DLL (vssapidll);

FREE_DLL (hvsstracedll);

FREE_DLL (hCryptSpDll);

FREE_DLL (hcfgmgr32dll);

FREE_DLL (hdevobjdll);

FREE_DLL (hpowrprofdll);

FREE_DLL (hsspiclidll);

FREE_DLL (hcryptbasedll);

FREE_DLL (hdwmapidll);

FREE_DLL (hmsasn1dll);

FREE_DLL (hcrypt32dll);

FREE_DLL (hbcryptdll);

FREE_DLL (hbcryptprimitivesdll);

FREE_DLL (hMsls31);

FREE_DLL (hntmartadll);

FREE_DLL (hwinscarddll);

FREE_DLL (hmsvcrtdll);

FREE_DLL (hAdvapi32Dll);

exit (1);

}

#endif

}

void FinalizeApp (void)

{

FREE_DLL (hRichEditDll);

FREE_DLL (hComctl32Dll);

FREE_DLL (hSetupDll);

FREE_DLL (hShlwapiDll);

FREE_DLL (hProfApiDll);

FREE_DLL (hUsp10Dll);

FREE_DLL (hCryptSpDll);

FREE_DLL (hUXThemeDll);

FREE_DLL (hUserenvDll);

FREE_DLL (hRsaenhDll);

FREE_DLL (himm32dll);

FREE_DLL (hMSCTFdll);

FREE_DLL (hfltlibdll);

FREE_DLL (hframedyndll);

FREE_DLL (hpsapidll);

FREE_DLL (hsecur32dll);

FREE_DLL (hnetapi32dll);

FREE_DLL (hauthzdll);

FREE_DLL (hxmllitedll);

FREE_DLL (hmprdll);

FREE_DLL (hsppdll);

FREE_DLL (vssapidll);

FREE_DLL (hvsstracedll);

FREE_DLL (hCryptSpDll);

FREE_DLL (hcfgmgr32dll);

FREE_DLL (hdevobjdll);

FREE_DLL (hpowrprofdll);

FREE_DLL (hsspiclidll);

FREE_DLL (hcryptbasedll);

FREE_DLL (hdwmapidll);

FREE_DLL (hmsasn1dll);

FREE_DLL (hcrypt32dll);

FREE_DLL (hbcryptdll);

FREE_DLL (hbcryptprimitivesdll);

FREE_DLL (hMsls31);

FREE_DLL (hntmartadll);

FREE_DLL (hwinscarddll);

FREE_DLL (hmsvcrtdll);

FREE_DLL (hAdvapi32Dll);

}

void InitHelpFileName (void)

{

wchar_t *lpszTmp;

GetModuleFileNameW (NULL, szHelpFile, ARRAYSIZE (szHelpFile));

lpszTmp = wcsrchr (szHelpFile, L'\\');

if (lpszTmp)

{

wchar_t szTemp[TC_MAX_PATH];

++lpszTmp;

*lpszTmp = 0; // add null terminating character to prepare for append operations

// Primary file name

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

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

{

StringCbCatW (szHelpFile, sizeof(szHelpFile), L"docs\\VeraCrypt User Guide.chm");

}

else

{

StringCbPrintfW (szTemp, sizeof(szTemp), L"docs\\VeraCrypt User Guide.%S.chm", GetPreferredLangId());

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

}

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

GetModuleFileNameW (NULL, szHelpFile2, ARRAYSIZE (szHelpFile2));

lpszTmp = wcsrchr (szHelpFile2, L'\\');

if (lpszTmp)

{

++lpszTmp;

*lpszTmp = 0;

StringCbCatW (szHelpFile2, sizeof(szHelpFile2), L"docs\\VeraCrypt User Guide.chm");

}

}

}

#ifndef SETUP

BOOL OpenDevice (const wchar_t *lpszPath, OPEN_TEST_STRUCT *driver, BOOL detectFilesystem, BOOL computeVolumeIDs)

{

DWORD dwResult;

BOOL bResult;

wchar_t wszFileName[TC_MAX_PATH];

StringCbCopyW (wszFileName, sizeof(wszFileName), lpszPath);

memset (driver, 0, sizeof (OPEN_TEST_STRUCT));

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

driver->bDetectTCBootLoader = FALSE;

driver->DetectFilesystem = detectFilesystem;

driver->bComputeVolumeIDs = computeVolumeIDs;

bResult = DeviceIoControl (hDriver, TC_IOCTL_OPEN_TEST,

driver, sizeof (OPEN_TEST_STRUCT),

driver, sizeof (OPEN_TEST_STRUCT),

&dwResult, NULL);

// check variable driver

if ( bResult

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

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

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

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

(wcscmp (wszFileName, driver->wszFileName))

)

)

{

return FALSE;

}

if (bResult == FALSE)

{

dwResult = GetLastError ();

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

{

driver->TCBootLoaderDetected = FALSE;

driver->FilesystemDetected = FALSE;

memset (driver->VolumeIDComputed, 0, sizeof (driver->VolumeIDComputed));

return TRUE;

}

else

return FALSE;

}

return TRUE;

}

#endif

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

void NotifyDriverOfPortableMode (void)

{

if (hDriver != INVALID_HANDLE_VALUE)

{

DWORD dwResult;

DeviceIoControl (hDriver, TC_IOCTL_SET_PORTABLE_MODE_STATUS, NULL, 0, NULL, 0, &dwResult, NULL);

}

}

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

{

DWORD fileSystemFlags;

wchar_t root[] = { L'A' + (wchar_t) driveNo, L':', L'\\', 0 };

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

}

#ifndef SETUP

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

a dangerous operation (such as header backup restore or formatting a supposedly non-system device) never

at WM_INITDIALOG or any other GUI events -- instead call IsSystemDevicePath (path, hwndDlg, FALSE) for

very fast preliminary GUI checks; also note that right after the "Select Device" dialog exits with an OK

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

executions complete very fast. Returns TRUE if successful (otherwise FALSE). */

BOOL GetSysDevicePaths (HWND hwndDlg)

{

if (!bCachedSysDevicePathsValid

|| wcslen (SysPartitionDevicePath) <= 1

|| wcslen (SysDriveDevicePath) <= 1)

{

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

{

if (device.ContainsSystem)

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

}

if (IsOSAtLeast (WIN_7))

{

// Find extra boot partition

foreach (const HostDevice &drive, GetAvailableHostDevices (false, false))

{

if (drive.ContainsSystem)

{

foreach (const HostDevice &sysDrivePartition, drive.Partitions)

{

if (sysDrivePartition.Bootable)

{

if (sysDrivePartition.Size <= TC_MAX_EXTRA_BOOT_PARTITION_SIZE)

ExtraBootPartitionDevicePath = sysDrivePartition.Path;

break;

}

}

break;

}

}

}

bCachedSysDevicePathsValid = 1;

}

return (bCachedSysDevicePathsValid

&& wcslen (SysPartitionDevicePath) > 1

&& wcslen (SysDriveDevicePath) > 1);

}

/* Determines whether the device path is the path of the system partition or of the system drive (or neither).

If bReliableRequired is TRUE, very fast execution is guaranteed, but the results cannot be relied upon.

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

operation (such as header backup restore or formatting a supposedly non-system device) never at

WM_INITDIALOG or any other GUI events (use IsSystemDevicePath(path, hwndDlg, FALSE) for fast

preliminary GUI checks; also note that right after the "Select Device" dialog exits with an OK

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

is ignored (TRUE implied), repeated executions complete very fast, and the results are always reliable.

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)

3 - it is the extra boot partition path

0 - it's not the system partition/drive path

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

int IsSystemDevicePath (const wchar_t *path, HWND hwndDlg, BOOL bReliableRequired)

{

if (!bCachedSysDevicePathsValid

&& bReliableRequired)

{

if (!GetSysDevicePaths (hwndDlg))

return -1;

}

if (wcslen (SysPartitionDevicePath) <= 1 || wcslen (SysDriveDevicePath) <= 1)

return -1;

if (!path)

return -1;

if (wcsncmp (path, SysPartitionDevicePath, max (wcslen(path), wcslen(SysPartitionDevicePath))) == 0)

return 1;

else if (wcsncmp (path, SysDriveDevicePath, max (wcslen(path), wcslen(SysDriveDevicePath))) == 0)

return 2;

else if (ExtraBootPartitionDevicePath == path)

return 3;

return 0;

}

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

only before performing a dangerous operation, never at WM_INITDIALOG or any other GUI events.

Return codes:

0 - it isn't a non-system partition on the system drive

1 - it's a non-system partition on the system drive

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

int IsNonSysPartitionOnSysDrive (const wchar_t *path)

{

wchar_t tmpPath [TC_MAX_PATH + 1];

int pos;

if (!GetSysDevicePaths (MainDlg))

return -1;

if (wcslen (SysPartitionDevicePath) <= 1 || wcslen (SysDriveDevicePath) <= 1)

return -1;

if (wcsncmp (path, SysPartitionDevicePath, max (wcslen(path), wcslen(SysPartitionDevicePath))) == 0

|| wcsncmp (path, SysDriveDevicePath, max (wcslen(path), wcslen(SysDriveDevicePath))) == 0)

{

// It is the system partition/drive path (it isn't a non-system partition)

return 0;

}

memset (tmpPath, 0, sizeof (tmpPath));

wcsncpy (tmpPath, path, ARRAYSIZE (tmpPath) - 1);

pos = (int) FindString ((const char*) tmpPath, (const char*) L"Partition", (int) wcslen (tmpPath) * 2, (int) wcslen (L"Partition") * 2, 0);

if (pos < 0)

return -1;

pos /= 2;

pos += (int) strlen ("Partition");

if (pos + 1 > ARRAYSIZE (tmpPath) - 1)

return -1;

tmpPath [pos] = L'0';

tmpPath [pos + 1] = 0;

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

{

// It is a non-system partition on the system drive

return 1;

}

else

{

// The partition is not on the system drive

return 0;

}

}

#endif //!SETUP

wstring GetSysEncryptionPretestInfo2String (void)

{

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

// re-translate it when a minor modification is made to it (the whole huge string will not be

// reverted to English, so they will have to translate only a small portion of it).

return (wstring (L"\n")

+ GetString ("SYS_ENCRYPTION_PRETEST_INFO2_PORTION_1")

+ GetString ("SYS_ENCRYPTION_PRETEST_INFO2_PORTION_2")

+ GetString ("SYS_ENCRYPTION_PRETEST_INFO2_PORTION_3")

+ GetString ("SYS_ENCRYPTION_PRETEST_INFO2_PORTION_4"));

}

wstring GetRescueDiskHelpString (void)

{

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

// re-translate it when a minor modification is made to it (the whole huge string will not be

// reverted to English, so they will have to translate only a small portion of it).

return (wstring (

GetString ("RESCUE_DISK_HELP_PORTION_1"))

+ GetString ("RESCUE_DISK_HELP_PORTION_2")

+ GetString ("RESCUE_DISK_HELP_PORTION_3")

+ GetString ("RESCUE_DISK_HELP_PORTION_4")

+ GetString ("RESCUE_DISK_HELP_PORTION_5")

+ GetString ("RESCUE_DISK_HELP_PORTION_6")

+ GetString ("RESCUE_DISK_HELP_PORTION_7")

+ GetString ("RESCUE_DISK_HELP_PORTION_8")

+ GetString ("RESCUE_DISK_HELP_PORTION_9"));

}

wstring GetDecoyOsInstructionsString (void)

{

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

// re-translate it when a minor modification is made to it (the whole huge string will not be

// reverted to English, so they will have to translate only a small portion of it).

return (wstring (

GetString ("DECOY_OS_INSTRUCTIONS_PORTION_1"))

+ GetString ("DECOY_OS_INSTRUCTIONS_PORTION_2")

+ GetString ("DECOY_OS_INSTRUCTIONS_PORTION_3")

+ GetString ("DECOY_OS_INSTRUCTIONS_PORTION_4")

+ GetString ("DECOY_OS_INSTRUCTIONS_PORTION_5")

+ GetString ("DECOY_OS_INSTRUCTIONS_PORTION_6")

+ GetString ("DECOY_OS_INSTRUCTIONS_PORTION_7")

+ GetString ("DECOY_OS_INSTRUCTIONS_PORTION_8")

+ GetString ("DECOY_OS_INSTRUCTIONS_PORTION_9")

+ GetString ("DECOY_OS_INSTRUCTIONS_PORTION_10")

+ GetString ("DECOY_OS_INSTRUCTIONS_PORTION_11")

+ GetString ("DECOY_OS_INSTRUCTIONS_PORTION_12")

+ GetString ("DECOY_OS_INSTRUCTIONS_PORTION_13")

+ GetString ("DECOY_OS_INSTRUCTIONS_PORTION_14")

+ GetString ("DECOY_OS_INSTRUCTIONS_PORTION_15")

+ GetString ("DECOY_OS_INSTRUCTIONS_PORTION_16")

+ GetString ("DECOY_OS_INSTRUCTIONS_PORTION_17")

+ GetString ("DECOY_OS_INSTRUCTIONS_PORTION_18"));

}

struct _TEXT_EDIT_DIALOG_PARAM {

BOOL ReadOnly;

std::string& Text;

const WCHAR* Title;

_TEXT_EDIT_DIALOG_PARAM (const _TEXT_EDIT_DIALOG_PARAM& other) : ReadOnly (other.ReadOnly), Text (other.Text), Title (other.Title) {}

_TEXT_EDIT_DIALOG_PARAM(BOOL _readOnly, const WCHAR* title, std::string& _text) : ReadOnly(_readOnly), Text(_text), Title(title) {}

_TEXT_EDIT_DIALOG_PARAM& operator=( const _TEXT_EDIT_DIALOG_PARAM& other) {

if (this != &other)

{

ReadOnly = other.ReadOnly;

Text = other.Text;

Title = other.Title;

}

return *this;

}

};

typedef struct _TEXT_EDIT_DIALOG_PARAM TEXT_INFO_DIALOG_PARAM,*TEXT_INFO_DIALOG_PARAM_PTR;

INT_PTR TextEditDialogBox (BOOL readOnly, HWND parent, const WCHAR* Title, std::string& text)

{

TEXT_INFO_DIALOG_PARAM pm(readOnly, Title, text);

return DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_TEXT_EDIT_DLG), parent, (DLGPROC) TextEditDlgProc, (LPARAM) &pm);

}

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

{

WORD lw = LOWORD (wParam);

static int nID = 0;

static TEXT_INFO_DIALOG_PARAM_PTR prm;

switch (msg)

{

case WM_INITDIALOG:

{

prm = (TEXT_INFO_DIALOG_PARAM_PTR)lParam;

// increase size limit of rich edit control

SendMessage(GetDlgItem (hwndDlg, IDC_INFO_BOX_TEXT), EM_EXLIMITTEXT, 0, -1);

SetWindowTextW (hwndDlg, prm->Title);

// Left margin for rich edit text field

SendMessage (GetDlgItem (hwndDlg, IDC_INFO_BOX_TEXT), EM_SETMARGINS, (WPARAM) EC_LEFTMARGIN, (LPARAM) CompensateXDPI (4));

if (prm->ReadOnly)

{

// switch rich edit control to ReadOnly

SendMessage(GetDlgItem (hwndDlg, IDC_INFO_BOX_TEXT), ES_READONLY, TRUE, 0);

// hide cancel button

ShowWindow(GetDlgItem(hwndDlg, IDCANCEL), SW_HIDE);

}

SendMessage (hwndDlg, TC_APPMSG_LOAD_TEXT_BOX_CONTENT, 0, 0);

}

return 0;

case WM_COMMAND:

if (lw == IDOK )

{

if (!prm->ReadOnly)

{

prm->Text.resize(GetWindowTextLengthA (GetDlgItem (hwndDlg, IDC_INFO_BOX_TEXT)) + 1);

GetWindowTextA (GetDlgItem (hwndDlg, IDC_INFO_BOX_TEXT), &(prm->Text)[0], (int) prm->Text.size());

}

NormalCursor ();

EndDialog (hwndDlg, IDOK);

return 1;

}

if (lw == IDCANCEL )

{

NormalCursor ();

EndDialog (hwndDlg, IDCANCEL);

return 1;

}

return 0;

case TC_APPMSG_LOAD_TEXT_BOX_CONTENT:

{

SetWindowTextA (GetDlgItem (hwndDlg, IDC_INFO_BOX_TEXT), prm->Text.c_str());

}

return 0;

case WM_CLOSE:

NormalCursor ();

EndDialog (hwndDlg, 0);

return 1;

}

return 0;

}

INT_PTR TextInfoDialogBox (int nID)

{

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

}

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

{

WORD lw = LOWORD (wParam);

static int nID = 0;

switch (msg)

{

case WM_INITDIALOG:

{

nID = (int) lParam;

// increase size limit of rich edit control

SendMessage(GetDlgItem (hwndDlg, IDC_INFO_BOX_TEXT), EM_EXLIMITTEXT, 0, -1);

// Left margin for rich edit text field

SendMessage (GetDlgItem (hwndDlg, IDC_INFO_BOX_TEXT), EM_SETMARGINS, (WPARAM) EC_LEFTMARGIN, (LPARAM) CompensateXDPI (4));

ShowWindow(GetDlgItem(hwndDlg, IDC_PRINT), SW_HIDE);

switch (nID)

{

case TC_TBXID_LEGAL_NOTICES:

LocalizeDialog (hwndDlg, "LEGAL_NOTICES_DLG_TITLE");

break;

case TC_TBXID_SYS_ENCRYPTION_PRETEST:

LocalizeDialog (hwndDlg, NULL);

ShowWindow(GetDlgItem(hwndDlg, IDC_PRINT), SW_SHOW);

break;

case TC_TBXID_SYS_ENC_RESCUE_DISK:

LocalizeDialog (hwndDlg, NULL);

ShowWindow(GetDlgItem(hwndDlg, IDC_PRINT), SW_SHOW);

break;

case TC_TBXID_DECOY_OS_INSTRUCTIONS:

LocalizeDialog (hwndDlg, NULL);

ShowWindow(GetDlgItem(hwndDlg, IDC_PRINT), SW_SHOW);

break;

case TC_TBXID_EXTRA_BOOT_PARTITION_REMOVAL_INSTRUCTIONS:

LocalizeDialog (hwndDlg, NULL);

ShowWindow(GetDlgItem(hwndDlg, IDC_PRINT), SW_SHOW);

break;

}

SendMessage (hwndDlg, TC_APPMSG_LOAD_TEXT_BOX_CONTENT, 0, 0);

}

return 0;

case WM_COMMAND:

if (lw == IDOK || lw == IDCANCEL)

{

NormalCursor ();

EndDialog (hwndDlg, 0);

return 1;

}

if (lw == IDC_PRINT)

{

switch (nID)

{

case TC_TBXID_SYS_ENCRYPTION_PRETEST:

PrintHardCopyTextUTF16 ((wchar_t *) GetSysEncryptionPretestInfo2String ().c_str(), L"Pre-Boot Troubleshooting", GetSysEncryptionPretestInfo2String ().length () * 2);

break;

case TC_TBXID_SYS_ENC_RESCUE_DISK:

PrintHardCopyTextUTF16 ((wchar_t *) GetRescueDiskHelpString ().c_str(), L"VeraCrypt Rescue Disk Help", GetRescueDiskHelpString ().length () * 2);

break;

case TC_TBXID_DECOY_OS_INSTRUCTIONS:

PrintHardCopyTextUTF16 ((wchar_t *) GetDecoyOsInstructionsString ().c_str(), L"How to Create Decoy OS", GetDecoyOsInstructionsString ().length () * 2);

break;

case TC_TBXID_EXTRA_BOOT_PARTITION_REMOVAL_INSTRUCTIONS:

PrintHardCopyTextUTF16 (GetString ("EXTRA_BOOT_PARTITION_REMOVAL_INSTRUCTIONS"), L"How to Remove Extra Boot Partition", wcslen (GetString ("EXTRA_BOOT_PARTITION_REMOVAL_INSTRUCTIONS")) * 2);

break;

}

return 1;

}

return 0;

case TC_APPMSG_LOAD_TEXT_BOX_CONTENT:

{

char *r = NULL;

switch (nID)

{

case TC_TBXID_LEGAL_NOTICES:

LocalizeDialog (hwndDlg, "LEGAL_NOTICES_DLG_TITLE");

r = GetLegalNotices ();

if (r != NULL)

{

SETTEXTEX TextInfo = {0};

TextInfo.flags = ST_SELECTION;

TextInfo.codepage = CP_ACP;

SendMessage(GetDlgItem (hwndDlg, IDC_INFO_BOX_TEXT), EM_SETTEXTEX, (WPARAM)&TextInfo, (LPARAM)r);

free (r);

}

break;

case TC_TBXID_SYS_ENCRYPTION_PRETEST:

LocalizeDialog (hwndDlg, NULL);

SetWindowTextW (GetDlgItem (hwndDlg, IDC_INFO_BOX_TEXT), (wchar_t *) GetSysEncryptionPretestInfo2String ().c_str());

break;

case TC_TBXID_SYS_ENC_RESCUE_DISK:

LocalizeDialog (hwndDlg, NULL);

SetWindowTextW (GetDlgItem (hwndDlg, IDC_INFO_BOX_TEXT), (wchar_t *) GetRescueDiskHelpString ().c_str());

break;

case TC_TBXID_DECOY_OS_INSTRUCTIONS:

LocalizeDialog (hwndDlg, NULL);

SetWindowTextW (GetDlgItem (hwndDlg, IDC_INFO_BOX_TEXT), (wchar_t *) GetDecoyOsInstructionsString ().c_str());

break;

case TC_TBXID_EXTRA_BOOT_PARTITION_REMOVAL_INSTRUCTIONS:

LocalizeDialog (hwndDlg, NULL);

SetWindowTextW (GetDlgItem (hwndDlg, IDC_INFO_BOX_TEXT), GetString ("EXTRA_BOOT_PARTITION_REMOVAL_INSTRUCTIONS"));

break;

}

}

return 1;

case WM_CLOSE:

NormalCursor ();

EndDialog (hwndDlg, 0);

return 1;

}

return 0;

}

char * GetLegalNotices ()

{

static char *resource;

static DWORD size;

char *buf = NULL;

if (resource == NULL)

resource = (char *) MapResource (L"Text", IDR_LICENSE, &size);

if (resource != NULL)

{

buf = (char *) malloc (size + 1);

if (buf != NULL)

{

memcpy (buf, resource, size);

buf[size] = 0;

}

}

return buf;

}

#ifndef SETUP

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

{

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

static vector <HostDevice> devices;

static map <int, HostDevice> itemToDeviceMap;

WORD lw = LOWORD (wParam);

switch (msg)

{

case WM_INITDIALOG:

{

LVCOLUMNW LvCol;

HWND hList = GetDlgItem (hwndDlg, IDC_DEVICELIST);

RawDevicesDlgParam* pDlgParam = (RawDevicesDlgParam *) lParam;

LocalizeDialog (hwndDlg, "IDD_RAWDEVICES_DLG");

SendMessage (hList,LVM_SETEXTENDEDLISTVIEWSTYLE,0,

LVS_EX_FULLROWSELECT|LVS_EX_HEADERDRAGDROP|LVS_EX_TWOCLICKACTIVATE|LVS_EX_LABELTIP

);

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

LvCol.mask = LVCF_TEXT|LVCF_WIDTH|LVCF_SUBITEM|LVCF_FMT;

LvCol.pszText = GetString ("DEVICE");

LvCol.cx = CompensateXDPI (186);

LvCol.fmt = LVCFMT_LEFT;

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

LvCol.pszText = GetString ("DRIVE");

LvCol.cx = CompensateXDPI (38);

LvCol.fmt = LVCFMT_LEFT;

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

LvCol.pszText = GetString ("SIZE");

LvCol.cx = CompensateXDPI (64);

LvCol.fmt = LVCFMT_RIGHT;

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

LvCol.pszText = GetString ("LABEL");

LvCol.cx = CompensateXDPI (128);

LvCol.fmt = LVCFMT_LEFT;

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

devices.clear();

itemToDeviceMap.clear();

if (pDlgParam->devices.empty())

{

WaitCursor();

devices = GetAvailableHostDevices (false, true, false);

NormalCursor();

}

else

devices = pDlgParam->devices;

if (devices.empty())

{

MessageBoxW (hwndDlg, GetString ("RAWDEVICES"), lpszTitle, ICON_HAND);

EndDialog (hwndDlg, IDCANCEL);

return 1;

}

int line = 1;

LVITEM item;

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

item.mask = LVIF_TEXT;

foreach (const HostDevice &device, devices)

{

item.iSubItem = 1;

if (device.ContainsSystem)

{

if (device.IsPartition)

StringCbCopyW (SysPartitionDevicePath, sizeof (SysPartitionDevicePath), device.Path.c_str());

else

StringCbCopyW (SysDriveDevicePath, sizeof (SysDriveDevicePath), device.Path.c_str());

}

// Path

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

{

if (!device.Floppy && (device.Size == 0)

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

)

continue;

if (line > 1)

{

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

item.iItem = line++;

}

if (device.Floppy || device.DynamicVolume)

{

ListItemAdd (hList, item.iItem, (wchar_t *) device.Path.c_str());

}

else

{

wchar_t s[1024];

if (device.Removable)

StringCbPrintfW (s, sizeof(s), L"%s %d", GetString ("REMOVABLE_DISK"), device.SystemNumber);

else

StringCbPrintfW (s, sizeof(s), L"%s %d", GetString ("HARDDISK"), device.SystemNumber);

if (!device.Partitions.empty())

StringCbCatW (s, sizeof(s), L":");

ListItemAdd (hList, item.iItem, s);

}

}

else

{

ListItemAdd (hList, item.iItem, (wchar_t *) device.Path.c_str());

}

itemToDeviceMap[item.iItem] = device;

// Size

if (device.Size != 0)

{

wchar_t size[100] = { 0 };

GetSizeString (device.Size, size, sizeof(size));

ListSubItemSet (hList, item.iItem, 2, size);

}

// Mount point

if (!device.MountPoint.empty())

ListSubItemSet (hList, item.iItem, 1, (wchar_t *) device.MountPoint.c_str());

// Label

if (!device.Name.empty())

ListSubItemSet (hList, item.iItem, 3, (wchar_t *) device.Name.c_str());

#ifdef TCMOUNT

else

{

bool useInExplorer = false;

wstring favoriteLabel = GetFavoriteVolumeLabel (device.Path, useInExplorer);

if (!favoriteLabel.empty())

ListSubItemSet (hList, item.iItem, 3, (wchar_t *) favoriteLabel.c_str());

}

#endif

item.iItem = line++;

}

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

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

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

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

lpszFileName = pDlgParam->pszFileName;

#ifdef VOLFORMAT

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

#endif

return 1;

}

case WM_COMMAND:

case WM_NOTIFY:

// catch non-device line selected

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

{

BOOL bEnableOkButton = FALSE;

LVITEM LvItem;

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

LvItem.mask = LVIF_TEXT | LVIF_PARAM;

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

LvItem.pszText = lpszFileName;

LvItem.cchTextMax = TC_MAX_PATH;

lpszFileName[0] = 0;

SendMessage (GetDlgItem (hwndDlg, IDC_DEVICELIST), LVM_GETITEM, LvItem.iItem, (LPARAM) &LvItem);

if (lpszFileName[0] != 0 && lpszFileName[0] != ' ')

{

bEnableOkButton = TRUE;

#ifdef VOLFORMAT

if ( bInPlaceEncNonSysResumed && (WizardMode == WIZARD_MODE_NONSYS_DEVICE)

&& LvItem.iItem != -1 && itemToDeviceMap.find (LvItem.iItem) != itemToDeviceMap.end()

)

{

const HostDevice selectedDevice = itemToDeviceMap[LvItem.iItem];

if (selectedDevice.ContainsSystem)

{

bEnableOkButton = FALSE;

}

}

#endif

}

EnableWindow (GetDlgItem ((HWND) hwndDlg, IDOK), bEnableOkButton);

return 1;

}

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

{

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

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

return 1; // non-device line selected

const HostDevice selectedDevice = itemToDeviceMap[selectedItem];

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

#ifdef VOLFORMAT

if (selectedDevice.ContainsSystem && selectedDevice.IsPartition)

{

if (WizardMode != WIZARD_MODE_SYS_DEVICE)

{

if (bInPlaceEncNonSysResumed && (WizardMode == WIZARD_MODE_NONSYS_DEVICE))

{

// disable selection

return 1;

}

if (AskYesNo ("CONFIRM_SYSTEM_ENCRYPTION_MODE", hwndDlg) == IDNO)

{

EndDialog (hwndDlg, IDCANCEL);

return 1;

}

bSysPartitionSelected = TRUE;

bSysDriveSelected = FALSE;

lpszFileName[0] = 0;

SwitchWizardToSysEncMode ();

NormalCursor ();

EndDialog (hwndDlg, IDOK);

return 1;

}

else

{

// This should never be the case because the Select Device dialog is not available in this wizard mode

bSysPartitionSelected = TRUE;

bSysDriveSelected = FALSE;

lpszFileName[0] = 0;

SwitchWizardToSysEncMode ();

NormalCursor ();

EndDialog (hwndDlg, IDCANCEL);

return 1;

}

}

if (!(selectedDevice.ContainsSystem && !selectedDevice.IsPartition))

{

if (bWarnDeviceFormatAdvanced

&& !bHiddenVolDirect

&& AskWarnNoYes("FORMAT_DEVICE_FOR_ADVANCED_ONLY", hwndDlg) == IDNO)

{

if (AskNoYes("CONFIRM_CHANGE_WIZARD_MODE_TO_FILE_CONTAINER", hwndDlg) == IDYES)

{

SwitchWizardToFileContainerMode ();

}

EndDialog (hwndDlg, IDCANCEL);

return 1;

}

if (!bHiddenVolDirect)

bWarnDeviceFormatAdvanced = FALSE;

}

#else // #ifdef VOLFORMAT

bSysPartitionSelected = (selectedDevice.ContainsSystem && selectedDevice.IsPartition);

bSysDriveSelected = FALSE;

#endif // #ifdef VOLFORMAT

if (!selectedDevice.IsPartition && !selectedDevice.Floppy)

{

// Whole device selected

#ifdef VOLFORMAT

if (selectedDevice.ContainsSystem && !selectedDevice.IsPartition)

{

if (WizardMode != WIZARD_MODE_SYS_DEVICE)

{

if (bInPlaceEncNonSysResumed && (WizardMode == WIZARD_MODE_NONSYS_DEVICE))

{

// disable selection

return 1;

}

if (AskYesNo ("CONFIRM_SYSTEM_ENCRYPTION_MODE", hwndDlg) == IDNO)

{

NormalCursor ();

EndDialog (hwndDlg, IDCANCEL);

return 1;

}

bSysDriveSelected = TRUE;

bSysPartitionSelected = FALSE;

lpszFileName[0] = 0;

SwitchWizardToSysEncMode ();

NormalCursor ();

EndDialog (hwndDlg, IDOK);

return 1;

}

else

{

// This should never be the case because the Select Device dialog is not available in this wizard mode

bSysDriveSelected = TRUE;

bSysPartitionSelected = FALSE;

lpszFileName[0] = 0;

SwitchWizardToSysEncMode ();

NormalCursor ();

EndDialog (hwndDlg, IDCANCEL);

return 1;

}

}

// Disallow format if the device contains partitions, but not if the partition is virtual or system

if (!selectedDevice.IsVirtualPartition

&& !bHiddenVolDirect)

{

if (!selectedDevice.Partitions.empty())

{

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

Error ("DEVICE_PARTITIONS_ERR_W_INPLACE_ENC_NOTE", hwndDlg);

return 1;

}

if (AskWarnNoYes ("WHOLE_NONSYS_DEVICE_ENC_CONFIRM", hwndDlg) == IDNO)

return 1;

}

#else // #ifdef VOLFORMAT

bSysDriveSelected = (selectedDevice.ContainsSystem && !selectedDevice.IsPartition);

bSysPartitionSelected = FALSE;

#endif // #ifdef VOLFORMAT

}

else

bSysDriveSelected = FALSE;

#ifdef VOLFORMAT

bRemovableHostDevice = selectedDevice.Removable;

#endif

NormalCursor ();

EndDialog (hwndDlg, IDOK);

return 1;

}

if ((msg == WM_COMMAND) && (lw == IDCANCEL))

{

NormalCursor ();

EndDialog (hwndDlg, IDCANCEL);

return 1;

}

return 0;

}

return 0;

}

#endif //!SETUP

BOOL DoDriverInstall (HWND hwndDlg)

{

#ifdef SETUP

if (SystemEncryptionUpdate)

return TRUE;

#endif

SC_HANDLE hManager, hService = NULL;

BOOL bOK = FALSE, bRet;

hManager = OpenSCManager (NULL, NULL, SC_MANAGER_ALL_ACCESS);

if (hManager == NULL)

goto error;

#ifdef SETUP

StatusMessage (hwndDlg, "INSTALLING_DRIVER");

#endif

hService = CreateService (hManager, L"veracrypt", L"veracrypt",

SERVICE_ALL_ACCESS, SERVICE_KERNEL_DRIVER, SERVICE_SYSTEM_START, SERVICE_ERROR_NORMAL,

L"System32\\drivers\\veracrypt.sys",

NULL, NULL, NULL, NULL, NULL);

if (hService == NULL)

goto error;

else

CloseServiceHandle (hService);

hService = OpenService (hManager, L"veracrypt", SERVICE_ALL_ACCESS);

if (hService == NULL)

goto error;

#ifdef SETUP

StatusMessage (hwndDlg, "STARTING_DRIVER");

#endif

bRet = StartService (hService, 0, NULL);

if (bRet == FALSE)

goto error;

bOK = TRUE;

error:

if (bOK == FALSE && GetLastError () != ERROR_SERVICE_ALREADY_RUNNING)

{

handleWin32Error (hwndDlg, SRC_POS);

MessageBoxW (hwndDlg, GetString ("DRIVER_INSTALL_FAILED"), lpszTitle, MB_ICONHAND);

}

else

bOK = TRUE;

if (hService != NULL)

CloseServiceHandle (hService);

if (hManager != NULL)

CloseServiceHandle (hManager);

return bOK;

}

// Install and start driver service and mark it for removal (non-install mode)

static int DriverLoad ()

{

HANDLE file;

WIN32_FIND_DATA find;

SC_HANDLE hManager, hService = NULL;

wchar_t driverPath[TC_MAX_PATH*2];

BOOL res;

wchar_t *tmp;

DWORD startType;

if (ReadLocalMachineRegistryDword (L"SYSTEM\\CurrentControlSet\\Services\\veracrypt", L"Start", &startType) && startType == SERVICE_BOOT_START)

return ERR_PARAMETER_INCORRECT;

GetModuleFileName (NULL, driverPath, ARRAYSIZE (driverPath));

tmp = wcsrchr (driverPath, L'\\');

if (!tmp)

{

driverPath[0] = L'.';

driverPath[1] = 0;

}

else

*tmp = 0;

StringCbCatW (driverPath, sizeof(driverPath), !Is64BitOs () ? L"\\veracrypt.sys" : IsARM()? L"\\veracrypt-arm64.sys" : L"\\veracrypt-x64.sys");

file = FindFirstFile (driverPath, &find);

if (file == INVALID_HANDLE_VALUE)

{

MessageBoxW (0, GetString ("DRIVER_NOT_FOUND"), lpszTitle, ICON_HAND);

return ERR_DONT_REPORT;

}

FindClose (file);

hManager = OpenSCManager (NULL, NULL, SC_MANAGER_ALL_ACCESS);

if (hManager == NULL)

{

if (GetLastError () == ERROR_ACCESS_DENIED)

{

MessageBoxW (0, GetString ("ADMIN_PRIVILEGES_DRIVER"), lpszTitle, ICON_HAND);

return ERR_DONT_REPORT;

}

return ERR_OS_ERROR;

}

hService = OpenService (hManager, L"veracrypt", SERVICE_ALL_ACCESS);

if (hService != NULL)

{

// Remove stale service (driver is not loaded but service exists)

DeleteService (hService);

CloseServiceHandle (hService);

Sleep (500);

}

hService = CreateService (hManager, L"veracrypt", L"veracrypt",

SERVICE_ALL_ACCESS, SERVICE_KERNEL_DRIVER, SERVICE_DEMAND_START, SERVICE_ERROR_NORMAL,

driverPath, NULL, NULL, NULL, NULL, NULL);

if (hService == NULL)

{

CloseServiceHandle (hManager);

return ERR_OS_ERROR;

}

res = StartService (hService, 0, NULL);

DeleteService (hService);

CloseServiceHandle (hManager);

CloseServiceHandle (hService);

return !res ? ERR_OS_ERROR : ERROR_SUCCESS;

}

BOOL DriverUnload ()

{

MOUNT_LIST_STRUCT driver;

int refCount;

int volumesMounted;

DWORD dwResult;

BOOL bResult;

SC_HANDLE hManager, hService = NULL;

BOOL bRet;

SERVICE_STATUS status;

int x;

BOOL driverUnloaded = FALSE;

if (hDriver == INVALID_HANDLE_VALUE)

return TRUE;

try

{

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

return FALSE;

}

catch (...) { }

// Test for mounted volumes

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

if (!bResult)

{

bResult = DeviceIoControl (hDriver, TC_IOCTL_LEGACY_GET_MOUNTED_VOLUMES, NULL, 0, &driver, sizeof (driver), &dwResult, NULL);

if (bResult)

volumesMounted = driver.ulMountedDrives;

}

if (bResult)

{

if (volumesMounted != 0)

return FALSE;

}

else

return TRUE;

// Test for any applications attached to driver

refCount = GetDriverRefCount ();

if (refCount > 1)

return FALSE;

CloseHandle (hDriver);

hDriver = INVALID_HANDLE_VALUE;

// Stop driver service

hManager = OpenSCManager (NULL, NULL, SC_MANAGER_ALL_ACCESS);

if (hManager == NULL)

goto error;

hService = OpenService (hManager, L"veracrypt", SERVICE_ALL_ACCESS);

if (hService == NULL)

goto error;

bRet = QueryServiceStatus (hService, &status);

if (bRet != TRUE)

goto error;

if (status.dwCurrentState != SERVICE_STOPPED)

{

ControlService (hService, SERVICE_CONTROL_STOP, &status);

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

{

bRet = QueryServiceStatus (hService, &status);

if (bRet != TRUE)

goto error;

if (status.dwCurrentState == SERVICE_STOPPED)

{

driverUnloaded = TRUE;

break;

}

Sleep (200);

}

}

else

driverUnloaded = TRUE;

error:

if (hService != NULL)

CloseServiceHandle (hService);

if (hManager != NULL)

CloseServiceHandle (hManager);

if (driverUnloaded)

{

hDriver = INVALID_HANDLE_VALUE;

return TRUE;

}

return FALSE;

}

int DriverAttach (void)

{

/* Try to open a handle to the device driver. It will be closed later. */

#ifndef SETUP

int nLoadRetryCount = 0;

start:

#endif

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

if (hDriver == INVALID_HANDLE_VALUE)

{

#ifndef SETUP

LoadSysEncSettings ();

if (!CreateDriverSetupMutex ())

{

// Another instance is already attempting to install, register or start the driver

while (!CreateDriverSetupMutex ())

{

Sleep (100); // Wait until the other instance finishes

}

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

goto start;

}

else

{

// No other instance is currently attempting to install, register or start the driver

if (SystemEncryptionStatus != SYSENC_STATUS_NONE)

{

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

// active, but the driver is not running. This may happen e.g. when the pretest fails and

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

if (DoDriverInstall (NULL))

{

Sleep (1000);

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

try

{

BootEncryption bootEnc (NULL);

bootEnc.RegisterBootDriver (bootEnc.GetHiddenOSCreationPhase() != TC_HIDDEN_OS_CREATION_PHASE_NONE ? true : false);

}

catch (Exception &e)

{

e.Show (NULL);

}

}

CloseDriverSetupMutex ();

}

else

{

// Attempt to load the driver (non-install/portable mode)

load:

BOOL res = DriverLoad ();

CloseDriverSetupMutex ();

if (res != ERROR_SUCCESS)

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

}

if (bPortableModeConfirmed)

NotifyDriverOfPortableMode ();

}

#endif // #ifndef SETUP

if (hDriver == INVALID_HANDLE_VALUE)

return ERR_OS_ERROR;

}

CloseDriverSetupMutex ();

if (hDriver != INVALID_HANDLE_VALUE)

{

DWORD dwResult;

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

if (!bResult)

bResult = DeviceIoControl (hDriver, TC_IOCTL_LEGACY_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;

}

else if (DriverVersion != VERSION_NUM)

{

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

#ifdef TCMOUNT

// don't fail in case of service. This solves issues during upgrade when system encryption is enabled

if (!ServiceMode)

#endif

{

CloseDriverSetupMutex ();

CloseHandle (hDriver);

hDriver = INVALID_HANDLE_VALUE;

return ERR_DRIVER_VERSION;

}

}

#else

if (!bResult)

DriverVersion = 0;

#endif

}

return 0;

}

void ResetCurrentDirectory ()

{

wchar_t p[MAX_PATH];

if (!IsNonInstallMode () && SHGetFolderPath (NULL, CSIDL_PROFILE, NULL, 0, p) == ERROR_SUCCESS)

{

SetCurrentDirectory (p);

}

else

{

GetModPath (p, ARRAYSIZE (p));

SetCurrentDirectory (p);

}

}

BOOL BrowseFiles (HWND hwndDlg, char *stringId, wchar_t *lpszFileName, BOOL keepHistory, BOOL saveMode, wchar_t *browseFilter)

{

return BrowseFilesInDir (hwndDlg, stringId, NULL, lpszFileName, keepHistory, saveMode, browseFilter);

}

BOOL BrowseFilesInDir (HWND hwndDlg, char *stringId, wchar_t *initialDir, wchar_t *lpszFileName, BOOL keepHistory, BOOL saveMode, wchar_t *browseFilter, const wchar_t *initialFileName, const wchar_t *defaultExtension)

{

OPENFILENAMEW ofn;

wchar_t file[TC_MAX_PATH] = { 0 };

wchar_t filter[1024];

BOOL status = FALSE;

CoInitialize (NULL);

ZeroMemory (&ofn, sizeof (ofn));

*lpszFileName = 0;

if (initialDir)

{

ofn.lpstrInitialDir = initialDir;

}

if (initialFileName)

StringCchCopyW (file, array_capacity (file), initialFileName);

ofn.lStructSize = sizeof (ofn);

ofn.hwndOwner = hwndDlg;

StringCbPrintfW (filter, sizeof(filter), L"%ls (*.*)%c*.*%c%ls (*.hc)%c*.hc%c%c",

GetString ("ALL_FILES"), 0, 0, GetString ("TC_VOLUMES"), 0, 0, 0);

ofn.lpstrFilter = browseFilter ? browseFilter : filter;

ofn.nFilterIndex = 1;

ofn.lpstrFile = file;

ofn.nMaxFile = sizeof (file) / sizeof (file[0]);

ofn.lpstrTitle = GetString (stringId);

ofn.lpstrDefExt = defaultExtension;

ofn.Flags = OFN_HIDEREADONLY

| OFN_PATHMUSTEXIST

| (keepHistory ? 0 : OFN_DONTADDTORECENT)

| (saveMode ? OFN_OVERWRITEPROMPT : 0);

if (!keepHistory)

CleanLastVisitedMRU ();

SystemFileSelectorCallerThreadId = GetCurrentThreadId();

SystemFileSelectorCallPending = TRUE;

if (!saveMode)

{

if (!GetOpenFileNameW (&ofn))

goto ret;

}

else

{

if (!GetSaveFileNameW (&ofn))

goto ret;

}

SystemFileSelectorCallPending = FALSE;

StringCchCopyW (lpszFileName, MAX_PATH, file);

if (!keepHistory)

CleanLastVisitedMRU ();

status = TRUE;

ret:

SystemFileSelectorCallPending = FALSE;

ResetCurrentDirectory();

CoUninitialize();

return status;

}

static wchar_t SelectMultipleFilesPath[131072];

static int SelectMultipleFilesOffset;

BOOL SelectMultipleFiles (HWND hwndDlg, const char *stringId, wchar_t *lpszFileName, size_t cbFileName,BOOL keepHistory)

{

OPENFILENAMEW ofn;

wchar_t filter[1024];

BOOL status = FALSE;

CoInitialize (NULL);

ZeroMemory (&ofn, sizeof (ofn));

SelectMultipleFilesPath[0] = 0;

*lpszFileName = 0;

ofn.lStructSize = sizeof (ofn);

ofn.hwndOwner = hwndDlg;

StringCbPrintfW (filter, sizeof(filter), L"%ls (*.*)%c*.*%c%ls (*.hc)%c*.hc%c%c",

GetString ("ALL_FILES"), 0, 0, GetString ("TC_VOLUMES"), 0, 0, 0);

ofn.lpstrFilter = filter;

ofn.nFilterIndex = 1;

ofn.lpstrFile = SelectMultipleFilesPath;

ofn.nMaxFile = 0xffff * 2; // The size must not exceed 0xffff*2 due to a bug in Windows 2000 and XP SP1

ofn.lpstrTitle = GetString (stringId);

ofn.Flags = OFN_HIDEREADONLY

| OFN_EXPLORER

| OFN_PATHMUSTEXIST

| OFN_ALLOWMULTISELECT

| (keepHistory ? 0 : OFN_DONTADDTORECENT);

if (!keepHistory)

CleanLastVisitedMRU ();

SystemFileSelectorCallerThreadId = GetCurrentThreadId();

SystemFileSelectorCallPending = TRUE;

if (!GetOpenFileNameW (&ofn))

goto ret;

SystemFileSelectorCallPending = FALSE;

if (SelectMultipleFilesPath[ofn.nFileOffset - 1] != 0)

{

// Single file selected

StringCbCopyW (lpszFileName, cbFileName, SelectMultipleFilesPath);

SelectMultipleFilesOffset = 0;

SecureZeroMemory (SelectMultipleFilesPath, sizeof (SelectMultipleFilesPath));

}

else

{

// Multiple files selected

SelectMultipleFilesOffset = ofn.nFileOffset;

SelectMultipleFilesNext (lpszFileName, cbFileName);

}

if (!keepHistory)

CleanLastVisitedMRU ();

status = TRUE;

ret:

SystemFileSelectorCallPending = FALSE;

ResetCurrentDirectory();

CoUninitialize();

return status;

}

BOOL SelectMultipleFilesNext (wchar_t *lpszFileName, size_t cbFileName)

{

if (SelectMultipleFilesOffset == 0)

return FALSE;

StringCbCopyW (lpszFileName, cbFileName,SelectMultipleFilesPath);

lpszFileName[TC_MAX_PATH - 1] = 0;

if (lpszFileName[wcslen (lpszFileName) - 1] != L'\\')

StringCbCatW (lpszFileName, cbFileName,L"\\");

StringCbCatW (lpszFileName, cbFileName,SelectMultipleFilesPath + SelectMultipleFilesOffset);

SelectMultipleFilesOffset += (int) wcslen (SelectMultipleFilesPath + SelectMultipleFilesOffset) + 1;

if (SelectMultipleFilesPath[SelectMultipleFilesOffset] == 0)

{

SelectMultipleFilesOffset = 0;

SecureZeroMemory (SelectMultipleFilesPath, sizeof (SelectMultipleFilesPath));

}

return TRUE;

}

static int CALLBACK BrowseCallbackProc(HWND hwnd,UINT uMsg,LPARAM lp, LPARAM pData)

{

switch(uMsg) {

case BFFM_INITIALIZED:

{

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

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

SendMessageW (hwnd,BFFM_SETSELECTION,TRUE,(LPARAM)pData);

break;

}

case BFFM_SELCHANGED:

{

wchar_t szDir[TC_MAX_PATH];

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

if (SHGetPathFromIDList((LPITEMIDLIST) lp ,szDir))

{

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

}

break;

}

default:

break;

}

return 0;

}

BOOL BrowseDirectories (HWND hwndDlg, char *lpszTitle, wchar_t *dirName)

{

BROWSEINFOW bi;

LPITEMIDLIST pidl;

LPMALLOC pMalloc;

BOOL bOK = FALSE;

CoInitialize (NULL);

if (SUCCEEDED (SHGetMalloc (&pMalloc)))

{

ZeroMemory (&bi, sizeof(bi));

bi.hwndOwner = hwndDlg;

bi.pszDisplayName = 0;

bi.lpszTitle = GetString (lpszTitle);

bi.pidlRoot = 0;

bi.ulFlags = BIF_RETURNONLYFSDIRS | BIF_STATUSTEXT;

bi.lpfn = BrowseCallbackProc;

bi.lParam = (LPARAM)dirName;

pidl = SHBrowseForFolderW (&bi);

if (pidl != NULL)

{

if (SHGetPathFromIDList(pidl, dirName))

{

bOK = TRUE;

}

pMalloc->Free (pidl);

pMalloc->Release();

}

}

CoUninitialize();

return bOK;

}

std::wstring GetWrongPasswordErrorMessage (HWND hwndDlg)

{

WCHAR szTmp[8192];

StringCbPrintfW (szTmp, sizeof(szTmp), GetString (KeyFilesEnable ? "PASSWORD_OR_KEYFILE_WRONG" : "PASSWORD_WRONG"));

if (CheckCapsLock (hwndDlg, TRUE))

StringCbCatW (szTmp, sizeof(szTmp), GetString ("PASSWORD_WRONG_CAPSLOCK_ON"));

#ifdef TCMOUNT

wchar_t szDevicePath [TC_MAX_PATH+1] = {0};

GetWindowText (GetDlgItem (MainDlg, IDC_VOLUME), szDevicePath, ARRAYSIZE (szDevicePath));

if (TCBootLoaderOnInactiveSysEncDrive (szDevicePath))

{

StringCbPrintfW (szTmp, sizeof(szTmp), GetString (KeyFilesEnable ? "PASSWORD_OR_KEYFILE_OR_MODE_WRONG" : "PASSWORD_OR_MODE_WRONG"));

if (CheckCapsLock (hwndDlg, TRUE))

StringCbCatW (szTmp, sizeof(szTmp), GetString ("PASSWORD_WRONG_CAPSLOCK_ON"));

StringCbCatW (szTmp, sizeof(szTmp), GetString ("SYSENC_MOUNT_WITHOUT_PBA_NOTE"));

}

#endif

wstring msg = szTmp;

#ifdef TCMOUNT

if (KeyFilesEnable && HiddenFilesPresentInKeyfilePath)

{

msg += GetString ("HIDDEN_FILES_PRESENT_IN_KEYFILE_PATH");

HiddenFilesPresentInKeyfilePath = FALSE;

}

#endif

return msg;

}

void handleError (HWND hwndDlg, int code, const char* srcPos)

{

WCHAR szTmp[4096];

if (Silent) return;

switch (code & 0x0000FFFF)

{

case ERR_OS_ERROR:

handleWin32Error (hwndDlg, srcPos);

break;

case ERR_OUTOFMEMORY:

MessageBoxW (hwndDlg, AppendSrcPos (GetString ("OUTOFMEMORY"), srcPos).c_str(), lpszTitle, ICON_HAND);

break;

case ERR_PASSWORD_WRONG:

MessageBoxW (hwndDlg, AppendSrcPos (GetWrongPasswordErrorMessage (hwndDlg).c_str(), srcPos).c_str(), lpszTitle, MB_ICONWARNING);

break;

case ERR_DRIVE_NOT_FOUND:

MessageBoxW (hwndDlg, AppendSrcPos (GetString ("NOT_FOUND"), srcPos).c_str(), lpszTitle, ICON_HAND);

break;

case ERR_FILES_OPEN:

MessageBoxW (hwndDlg, AppendSrcPos (GetString ("OPENFILES_DRIVER"), srcPos).c_str(), lpszTitle, ICON_HAND);

break;

case ERR_FILES_OPEN_LOCK:

MessageBoxW (hwndDlg, AppendSrcPos (GetString ("OPENFILES_LOCK"), srcPos).c_str(), lpszTitle, ICON_HAND);

break;

case ERR_VOL_SIZE_WRONG:

MessageBoxW (hwndDlg, AppendSrcPos (GetString ("VOL_SIZE_WRONG"), srcPos).c_str(), lpszTitle, ICON_HAND);

break;

case ERR_COMPRESSION_NOT_SUPPORTED:

MessageBoxW (hwndDlg, AppendSrcPos (GetString ("COMPRESSION_NOT_SUPPORTED"), srcPos).c_str(), lpszTitle, ICON_HAND);

break;

case ERR_PASSWORD_CHANGE_VOL_TYPE:

MessageBoxW (hwndDlg, AppendSrcPos (GetString ("WRONG_VOL_TYPE"), srcPos).c_str(), lpszTitle, ICON_HAND);

break;

case ERR_VOL_SEEKING:

MessageBoxW (hwndDlg, AppendSrcPos (GetString ("VOL_SEEKING"), srcPos).c_str(), lpszTitle, ICON_HAND);

break;

case ERR_CIPHER_INIT_FAILURE:

MessageBoxW (hwndDlg, AppendSrcPos (GetString ("ERR_CIPHER_INIT_FAILURE"), srcPos).c_str(), lpszTitle, ICON_HAND);

break;

case ERR_CIPHER_INIT_WEAK_KEY:

MessageBoxW (hwndDlg, AppendSrcPos (GetString ("ERR_CIPHER_INIT_WEAK_KEY"), srcPos).c_str(), lpszTitle, ICON_HAND);

break;

case ERR_VOL_ALREADY_MOUNTED:

MessageBoxW (hwndDlg, AppendSrcPos (GetString ("VOL_ALREADY_MOUNTED"), srcPos).c_str(), lpszTitle, ICON_HAND);

break;

case ERR_FILE_OPEN_FAILED:

MessageBoxW (hwndDlg, AppendSrcPos (GetString ("FILE_OPEN_FAILED"), srcPos).c_str(), lpszTitle, ICON_HAND);

break;

case ERR_VOL_MOUNT_FAILED:

MessageBoxW (hwndDlg, AppendSrcPos (GetString ("VOL_MOUNT_FAILED"), srcPos).c_str(), lpszTitle, ICON_HAND);

break;

case ERR_NO_FREE_DRIVES:

MessageBoxW (hwndDlg, AppendSrcPos (GetString ("NO_FREE_DRIVES"), srcPos).c_str(), lpszTitle, ICON_HAND);

break;

case ERR_ACCESS_DENIED:

MessageBoxW (hwndDlg, AppendSrcPos (GetString ("ACCESS_DENIED"), srcPos).c_str(), lpszTitle, ICON_HAND);

break;

case ERR_DRIVER_VERSION:

Error ("DRIVER_VERSION", hwndDlg);

break;

case ERR_NEW_VERSION_REQUIRED:

MessageBoxW (hwndDlg, AppendSrcPos (GetString ("NEW_VERSION_REQUIRED"), srcPos).c_str(), lpszTitle, ICON_HAND);

break;

case ERR_SELF_TESTS_FAILED:

Error ("ERR_SELF_TESTS_FAILED", hwndDlg);

break;

case ERR_VOL_FORMAT_BAD:

Error ("ERR_VOL_FORMAT_BAD", hwndDlg);

break;

case ERR_ENCRYPTION_NOT_COMPLETED:

Error ("ERR_ENCRYPTION_NOT_COMPLETED", hwndDlg);

break;

case ERR_NONSYS_INPLACE_ENC_INCOMPLETE:

Error ("ERR_NONSYS_INPLACE_ENC_INCOMPLETE", hwndDlg);

break;

case ERR_SYS_HIDVOL_HEAD_REENC_MODE_WRONG:

Error ("ERR_SYS_HIDVOL_HEAD_REENC_MODE_WRONG", hwndDlg);

break;

case ERR_PARAMETER_INCORRECT:

Error ("ERR_PARAMETER_INCORRECT", hwndDlg);

break;

case ERR_USER_ABORT:

case ERR_DONT_REPORT:

// A non-error

break;

case ERR_UNSUPPORTED_TRUECRYPT_FORMAT:

StringCbPrintfW (szTmp, sizeof(szTmp), GetString ("UNSUPPORTED_TRUECRYPT_FORMAT"), (code >> 24), (code >> 16) & 0x000000FF);

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

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

break;

case ERR_CAPI_INIT_FAILED:

StringCbPrintfW (szTmp, sizeof(szTmp), GetString ("CAPI_RAND"), SRC_POS, CryptoAPILastError);

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

}

}

BOOL CheckFileStreamWriteErrors (HWND hwndDlg, FILE *file, const wchar_t *fileName)

{

if (ferror (file))

{

wchar_t s[TC_MAX_PATH];

StringCbPrintfW (s, sizeof (s), GetString ("CANNOT_WRITE_FILE_X"), fileName);

ErrorDirect (s, hwndDlg);

return FALSE;

}

return TRUE;

}

static BOOL CALLBACK LocalizeDialogEnum( HWND hwnd, LPARAM font)

{

// Localization of controls

if (LocalizationActive)

{

int ctrlId = GetDlgCtrlID (hwnd);

if (ctrlId != 0)

{

WCHAR name[10] = { 0 };

GetClassNameW (hwnd, name, array_capacity (name));

if (_wcsicmp (name, L"Button") == 0 || _wcsicmp (name, L"Static") == 0)

{

wchar_t *str = (wchar_t *) GetDictionaryValueByInt (ctrlId);

if (str != NULL)

SetWindowTextW (hwnd, str);

}

}

}

// Font

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

return TRUE;

}

void LocalizeDialog (HWND hwnd, char *stringId)

{

LastDialogId = stringId;

SetWindowLongPtrW (hwnd, GWLP_USERDATA, (LONG_PTR) 'VERA');

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

if (stringId == NULL)

SetWindowTextW (hwnd, L"VeraCrypt");

else

SetWindowTextW (hwnd, GetString (stringId));

if (hUserFont != 0)

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

}

void OpenVolumeExplorerWindow (int driveNo)

{

wchar_t dosName[5];

SHFILEINFO fInfo;

StringCbPrintfW (dosName, sizeof(dosName), L"%c:\\", (wchar_t) driveNo + L'A');

// Force explorer to discover the drive

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

SafeOpenURL (dosName);

}

static BOOL explorerCloseSent;

static HWND explorerTopLevelWindow;

static BOOL CALLBACK CloseVolumeExplorerWindowsChildEnum (HWND hwnd, LPARAM driveStr)

{

WCHAR s[MAX_PATH];

SendMessageW (hwnd, WM_GETTEXT, array_capacity (s), (LPARAM) s);

if (wcsstr (s, (WCHAR *) driveStr) != NULL)

{

PostMessageW (explorerTopLevelWindow, WM_CLOSE, 0, 0);

explorerCloseSent = TRUE;

return FALSE;

}

return TRUE;

}

static BOOL CALLBACK CloseVolumeExplorerWindowsEnum (HWND hwnd, LPARAM driveNo)

{

WCHAR driveStr[10];

WCHAR s[MAX_PATH];

StringCbPrintfW (driveStr, sizeof(driveStr), L"%c:\\", driveNo + L'A');

GetClassNameW (hwnd, s, array_capacity (s));

if (wcscmp (s, L"CabinetWClass") == 0)

{

GetWindowTextW (hwnd, s, array_capacity (s));

if (wcsstr (s, driveStr) != NULL)

{

PostMessageW (hwnd, WM_CLOSE, 0, 0);

explorerCloseSent = TRUE;

return TRUE;

}

explorerTopLevelWindow = hwnd;

EnumChildWindows (hwnd, CloseVolumeExplorerWindowsChildEnum, (LPARAM) driveStr);

}

return TRUE;

}

BOOL CloseVolumeExplorerWindows (HWND hwnd, int driveNo)

{

if (driveNo >= 0)

{

explorerCloseSent = FALSE;

EnumWindows (CloseVolumeExplorerWindowsEnum, (LPARAM) driveNo);

}

return explorerCloseSent;

}

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

{

wchar_t wszRegPath[MAX_PATH];

wchar_t driveStr[] = {L'A' + (wchar_t) driveNo, 0};

HKEY hKey;

LSTATUS lStatus;

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

BOOL bToBeDeleted = FALSE;

StringCbPrintfW (wszRegPath, sizeof (wszRegPath), L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\DriveIcons\\%s\\DefaultLabel", driveStr);

if (bSetValue)

lStatus = RegCreateKeyExW (HKEY_CURRENT_USER, wszRegPath, NULL, NULL, 0,

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 (ERROR_SUCCESS == lStatus)

{

if (bSetValue)

lStatus = RegSetValueExW (hKey, NULL, NULL, REG_SZ, (LPCBYTE) effectiveLabel, cbLabelLen);

else

{

wchar_t storedLabel[34] = {0};

DWORD cbStoredLen = sizeof (storedLabel) - 1, dwType;

lStatus = RegQueryValueExW (hKey, NULL, NULL, &dwType, (LPBYTE) storedLabel, &cbStoredLen);

if ((ERROR_SUCCESS == lStatus) && (REG_SZ == dwType) && (0 == wcscmp(storedLabel, effectiveLabel)))

{

// same label stored. mark key for deletion

bToBeDeleted = TRUE;

}

}

RegCloseKey (hKey);

}

if (bToBeDeleted)

{

StringCbPrintfW (wszRegPath, sizeof (wszRegPath), L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\DriveIcons\\%s", driveStr);

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

if (ERROR_SUCCESS == lStatus)

{

lStatus = RegDeleteKeyW (hKey, L"DefaultLabel");

RegCloseKey (hKey);

}

// delete drive letter of nothing else is present under it

RegDeleteKeyW (HKEY_CURRENT_USER, wszRegPath);

}

return (ERROR_SUCCESS == lStatus)? TRUE : FALSE;

}

wstring GetUserFriendlyVersionString (int version)

{

wchar_t szTmp [64];

StringCbPrintfW (szTmp, sizeof(szTmp), L"%x", version);

wstring versionString (szTmp);

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

return (versionString);

}

wstring IntToWideString (int val)

{

wchar_t szTmp [64];

StringCbPrintfW (szTmp, sizeof(szTmp), L"%d", val);

return szTmp;

}

wstring ArrayToHexWideString (const unsigned char* pbData, int cbData)

{

static wchar_t* hexChar = L"0123456789ABCDEF";

wstring result;

if (pbData)

{

for (int i = 0; i < cbData; i++)

{

result += hexChar[pbData[i] >> 4];

result += hexChar[pbData[i] & 0x0F];

}

}

return result;

}

bool HexToByte (wchar_t c, byte& b)

{

bool bRet = true;

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

b = (byte) (c - L'0');

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

b = (byte) (c - L'a' + 10);

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

b = (byte) (c - L'A' + 10);

else

bRet = false;

return bRet;

}

bool HexWideStringToArray (const wchar_t* hexStr, std::vector<byte>& arr)

{

byte b1, b2;

size_t i, len = wcslen (hexStr);

arr.clear();

if (len %2)

return false;

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

{

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

return false;

arr.push_back (b1 << 4 | b2);

}

return true;

}

wstring GetTempPathString ()

{

wchar_t tempPath[MAX_PATH];

DWORD tempLen = ::GetTempPath (ARRAYSIZE (tempPath), tempPath);

if (tempLen == 0 || tempLen > ARRAYSIZE (tempPath))

throw ParameterIncorrect (SRC_POS);

return wstring (tempPath);

}

void GetSizeString (unsigned __int64 size, wchar_t *str, size_t cbStr)

{

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

static int serNo;

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

{

serNo = LocalizationSerialNo;

kb = GetString ("KB");

mb = GetString ("MB");

gb = GetString ("GB");

tb = GetString ("TB");

pb = GetString ("PB");

b = GetString ("BYTE");

}

if (size > 1024I64*1024*1024*1024*1024*99)

StringCbPrintfW (str, cbStr, L"%I64d %s", size/1024/1024/1024/1024/1024, pb);

else if (size > 1024I64*1024*1024*1024*1024)

StringCbPrintfW (str, cbStr, L"%.1f %s",(double)(size/1024.0/1024/1024/1024/1024), pb);

else if (size > 1024I64*1024*1024*1024*99)

StringCbPrintfW (str, cbStr, L"%I64d %s",size/1024/1024/1024/1024, tb);

else if (size > 1024I64*1024*1024*1024)

StringCbPrintfW (str, cbStr, L"%.1f %s",(double)(size/1024.0/1024/1024/1024), tb);

else if (size > 1024I64*1024*1024*99)

StringCbPrintfW (str, cbStr, L"%I64d %s",size/1024/1024/1024, gb);

else if (size > 1024I64*1024*1024)

StringCbPrintfW (str, cbStr, L"%.1f %s",(double)(size/1024.0/1024/1024), gb);

else if (size > 1024I64*1024*99)

StringCbPrintfW (str, cbStr, L"%I64d %s", size/1024/1024, mb);

else if (size > 1024I64*1024)

StringCbPrintfW (str, cbStr, L"%.1f %s",(double)(size/1024.0/1024), mb);

else if (size >= 1024I64)

StringCbPrintfW (str, cbStr, L"%I64d %s", size/1024, kb);

else

StringCbPrintfW (str, cbStr, L"%I64d %s", size, b);

}

#ifndef SETUP

void GetSpeedString (unsigned __int64 speed, wchar_t *str, size_t cbStr)

{

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

static int serNo;

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

{

serNo = LocalizationSerialNo;

kb = GetString ("KB_PER_SEC");

mb = GetString ("MB_PER_SEC");

gb = GetString ("GB_PER_SEC");

tb = GetString ("TB_PER_SEC");

pb = GetString ("PB_PER_SEC");

b = GetString ("B_PER_SEC");

}

if (speed > 1024I64*1024*1024*1024*1024*99)

StringCbPrintfW (str, cbStr, L"%I64d %s", speed/1024/1024/1024/1024/1024, pb);

else if (speed > 1024I64*1024*1024*1024*1024)

StringCbPrintfW (str, cbStr, L"%.1f %s",(double)(speed/1024.0/1024/1024/1024/1024), pb);

else if (speed > 1024I64*1024*1024*1024*99)

StringCbPrintfW (str, cbStr, L"%I64d %s",speed/1024/1024/1024/1024, tb);

else if (speed > 1024I64*1024*1024*1024)

StringCbPrintfW (str, cbStr, L"%.1f %s",(double)(speed/1024.0/1024/1024/1024), tb);

else if (speed > 1024I64*1024*1024*99)

StringCbPrintfW (str, cbStr, L"%I64d %s",speed/1024/1024/1024, gb);

else if (speed > 1024I64*1024*1024)

StringCbPrintfW (str, cbStr, L"%.1f %s",(double)(speed/1024.0/1024/1024), gb);

else if (speed > 1024I64*1024*99)

StringCbPrintfW (str, cbStr, L"%I64d %s", speed/1024/1024, mb);

else if (speed > 1024I64*1024)

StringCbPrintfW (str, cbStr, L"%.1f %s",(double)(speed/1024.0/1024), mb);

else if (speed > 1024I64)

StringCbPrintfW (str, cbStr, L"%I64d %s", speed/1024, kb);

else

StringCbPrintfW (str, cbStr, L"%I64d %s", speed, b);

}

static void ResetBenchmarkList (HWND hwndDlg)

{

LVCOLUMNW LvCol;

HWND hList = GetDlgItem (hwndDlg, IDC_RESULTS);

/* Render the results */

// delete data

SendMessage (hList, LVM_DELETEALLITEMS, 0, 0);

// Delete headers

SendMessageW (hList, LVM_DELETECOLUMN, 1, 0);

SendMessageW (hList, LVM_DELETECOLUMN, 1, 0);

SendMessageW (hList, LVM_DELETECOLUMN, 1, 0);

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

LvCol.mask = LVCF_TEXT|LVCF_WIDTH|LVCF_SUBITEM|LVCF_FMT;

switch(benchmarkType) {

case BENCHMARK_TYPE_ENCRYPTION:

// Create headers

LvCol.pszText = GetString ("ENCRYPTION");

LvCol.cx = CompensateXDPI (80);

LvCol.fmt = LVCFMT_RIGHT;

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

LvCol.pszText = GetString ("DECRYPTION");

LvCol.cx = CompensateXDPI (80);

LvCol.fmt = LVCFMT_RIGHT;

SendMessageW (hList,LVM_INSERTCOLUMNW,2,(LPARAM)&LvCol);

LvCol.pszText = GetString ("MEAN");

LvCol.cx = CompensateXDPI (80);

LvCol.fmt = LVCFMT_RIGHT;

SendMessageW (hList,LVM_INSERTCOLUMNW,3,(LPARAM)&LvCol);

break;

case BENCHMARK_TYPE_HASH:

LvCol.pszText = GetString ("MEAN");

LvCol.cx = CompensateXDPI (80);

LvCol.fmt = LVCFMT_RIGHT;

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

break;

case BENCHMARK_TYPE_PRF:

LvCol.pszText = GetString ("TIME");

LvCol.cx = CompensateXDPI (80);

LvCol.fmt = LVCFMT_RIGHT;

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

LvCol.pszText = GetString ("ITERATIONS");

LvCol.cx = CompensateXDPI (80);

LvCol.fmt = LVCFMT_RIGHT;

SendMessageW (hList,LVM_INSERTCOLUMNW,2,(LPARAM)&LvCol);

break;

}

}

static void DisplayBenchmarkResults (HWND hwndDlg)

{

wchar_t item1[100]={0};

LVITEMW LvItem;

HWND hList = GetDlgItem (hwndDlg, IDC_RESULTS);

int ea, i;

BOOL unsorted = TRUE;

BENCHMARK_REC tmp_line;

ResetBenchmarkList (hwndDlg);

/* Sort the list */

switch (benchmarkSortMethod)

{

case BENCHMARK_SORT_BY_SPEED:

while (unsorted)

{

unsorted = FALSE;

for (i = 0; i < benchmarkTotalItems - 1; i++)

{

if (((benchmarkType == BENCHMARK_TYPE_PRF) && (benchmarkTable[i].meanBytesPerSec > benchmarkTable[i+1].meanBytesPerSec)) ||

((benchmarkType != BENCHMARK_TYPE_PRF) && (benchmarkTable[i].meanBytesPerSec < benchmarkTable[i+1].meanBytesPerSec))

)

{

unsorted = TRUE;

memcpy (&tmp_line, &benchmarkTable[i], sizeof(BENCHMARK_REC));

memcpy (&benchmarkTable[i], &benchmarkTable[i+1], sizeof(BENCHMARK_REC));

memcpy (&benchmarkTable[i+1], &tmp_line, sizeof(BENCHMARK_REC));

}

}

}

break;

case BENCHMARK_SORT_BY_NAME:

while (unsorted)

{

unsorted = FALSE;

for (i = 0; i < benchmarkTotalItems - 1; i++)

{

if (benchmarkTable[i].id > benchmarkTable[i+1].id)

{

unsorted = TRUE;

memcpy (&tmp_line, &benchmarkTable[i], sizeof(BENCHMARK_REC));

memcpy (&benchmarkTable[i], &benchmarkTable[i+1], sizeof(BENCHMARK_REC));

memcpy (&benchmarkTable[i+1], &tmp_line, sizeof(BENCHMARK_REC));

}

}

}

break;

}

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

{

ea = benchmarkTable[i].id;

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

LvItem.mask = LVIF_TEXT;

LvItem.iItem = i;

LvItem.iSubItem = 0;

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

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

switch(benchmarkType) {

case BENCHMARK_TYPE_ENCRYPTION:

GetSpeedString ((unsigned __int64) (benchmarkLastBufferSize / ((float) benchmarkTable[i].encSpeed / benchmarkPerformanceFrequency.QuadPart)), item1, sizeof(item1));

LvItem.iSubItem = 1;

LvItem.pszText = item1;

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

GetSpeedString ((unsigned __int64) (benchmarkLastBufferSize / ((float) benchmarkTable[i].decSpeed / benchmarkPerformanceFrequency.QuadPart)), item1, sizeof(item1));

LvItem.iSubItem = 2;

LvItem.pszText = item1;

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

GetSpeedString (benchmarkTable[i].meanBytesPerSec, item1, sizeof(item1));

LvItem.iSubItem = 3;

LvItem.pszText = item1;

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

break;

case BENCHMARK_TYPE_HASH:

GetSpeedString (benchmarkTable[i].meanBytesPerSec, item1, sizeof(item1));

LvItem.iSubItem = 1;

LvItem.pszText = item1;

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

break;

case BENCHMARK_TYPE_PRF:

swprintf_s (item1, sizeof(item1) / sizeof(item1[0]), L"%d ms", (int) benchmarkTable[i].meanBytesPerSec);

LvItem.iSubItem = 1;

LvItem.pszText = item1;

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

swprintf_s (item1, sizeof(item1) / sizeof(item1[0]), L"%d", (int) benchmarkTable[i].decSpeed);

LvItem.iSubItem = 2;

LvItem.pszText = item1;

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

break;

}

}

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

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

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

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

}

// specific implementation for support of benchmark operation in wait dialog mechanism

typedef struct

{

HWND hBenchDlg;

BOOL bStatus;

} BenchmarkThreadParam;

static BOOL PerformBenchmark(HWND hBenchDlg, HWND hwndDlg);

void CALLBACK BenchmarkThreadProc(void* pArg, HWND hwndDlg)

{

BenchmarkThreadParam* pThreadParam = (BenchmarkThreadParam*) pArg;

pThreadParam->bStatus = PerformBenchmark (pThreadParam->hBenchDlg, hwndDlg);

}

static BOOL PerformBenchmark(HWND hBenchDlg, HWND hwndDlg)

{

LARGE_INTEGER performanceCountStart, performanceCountEnd;

BYTE *lpTestBuffer = NULL;

PCRYPTO_INFO ci = NULL;

UINT64_STRUCT startDataUnitNo;

size_t cpuCount = GetCpuCount(NULL);

startDataUnitNo.Value = 0;

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

if (cpuCount > 1 && (benchmarkType != BENCHMARK_TYPE_ENCRYPTION))

SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);

ci = crypto_open ();

if (!ci)

return FALSE;

if (QueryPerformanceFrequency (&benchmarkPerformanceFrequency) == 0)

{

if (ci)

crypto_close (ci);

MessageBoxW (hwndDlg, GetString ("ERR_PERF_COUNTER"), lpszTitle, ICON_HAND);

return FALSE;

}

if (benchmarkType != BENCHMARK_TYPE_PRF)

{

lpTestBuffer = (BYTE *) _aligned_malloc(benchmarkBufferSize - (benchmarkBufferSize % 16), 16);

if (lpTestBuffer == NULL)

{

if (ci)

crypto_close (ci);

MessageBoxW (hwndDlg, GetString ("ERR_MEM_ALLOC"), lpszTitle, ICON_HAND);

return FALSE;

}

VirtualLock (lpTestBuffer, benchmarkBufferSize - (benchmarkBufferSize % 16));

}

WaitCursor ();

benchmarkTotalItems = 0;

switch(benchmarkType) {

case BENCHMARK_TYPE_HASH:

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

a single digest.

*/

{

BYTE digest [MAX_DIGESTSIZE];

WHIRLPOOL_CTX wctx;

blake2s_state bctx;

sha512_ctx s2ctx;

sha256_ctx s256ctx;

STREEBOG_CTX stctx;

int hid, i;

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

{

if (QueryPerformanceCounter (&performanceCountStart) == 0)

goto counter_error;

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

{

switch (hid)

{

case SHA512:

sha512_begin (&s2ctx);

sha512_hash (lpTestBuffer, benchmarkBufferSize, &s2ctx);

sha512_end ((unsigned char *) digest, &s2ctx);

break;

case SHA256:

sha256_begin (&s256ctx);

sha256_hash (lpTestBuffer, benchmarkBufferSize, &s256ctx);

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

break;

case BLAKE2S:

blake2s_init(&bctx);

blake2s_update(&bctx, lpTestBuffer, benchmarkBufferSize);

blake2s_final(&bctx, (unsigned char *) digest);

break;

case WHIRLPOOL:

WHIRLPOOL_init (&wctx);

WHIRLPOOL_add (lpTestBuffer, benchmarkBufferSize, &wctx);

WHIRLPOOL_finalize (&wctx, (unsigned char *) digest);

break;

case STREEBOG:

STREEBOG_init(&stctx);

STREEBOG_add(&stctx, lpTestBuffer, benchmarkBufferSize);

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

break;

}

}

if (QueryPerformanceCounter (&performanceCountEnd) == 0)

goto counter_error;

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

benchmarkTable[benchmarkTotalItems].decSpeed = benchmarkTable[benchmarkTotalItems].encSpeed;

benchmarkTable[benchmarkTotalItems].id = hid;

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

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

benchmarkTotalItems++;

}

}

break;

case BENCHMARK_TYPE_PRF:

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

each of the implemented PRF algorithms.

*/

{

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

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

{

if (benchmarkPreBoot && !benchmarkGPT && !HashForSystemEncryption (thid))

continue;

if (QueryPerformanceCounter (&performanceCountStart) == 0)

goto counter_error;

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

{

switch (thid)

{

case SHA512:

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

derive_key_sha512 ("passphrase-1234567890", 21, tmp_salt, 64, get_pkcs5_iteration_count(thid, benchmarkPim, FALSE, benchmarkPreBoot), dk, MASTER_KEYDATA_SIZE);

break;

case SHA256:

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

derive_key_sha256 ("passphrase-1234567890", 21, tmp_salt, 64, get_pkcs5_iteration_count(thid, benchmarkPim, FALSE, benchmarkPreBoot), dk, MASTER_KEYDATA_SIZE);

break;

case BLAKE2S:

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

derive_key_blake2s ("passphrase-1234567890", 21, tmp_salt, 64, get_pkcs5_iteration_count(thid, benchmarkPim, FALSE, benchmarkPreBoot), dk, MASTER_KEYDATA_SIZE);

break;

case WHIRLPOOL:

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

derive_key_whirlpool ("passphrase-1234567890", 21, tmp_salt, 64, get_pkcs5_iteration_count(thid, benchmarkPim, FALSE, benchmarkPreBoot), dk, MASTER_KEYDATA_SIZE);

break;

case STREEBOG:

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

derive_key_streebog("passphrase-1234567890", 21, tmp_salt, 64, get_pkcs5_iteration_count(thid, benchmarkPim, FALSE, benchmarkPreBoot), dk, MASTER_KEYDATA_SIZE);

break;

}

}

if (QueryPerformanceCounter (&performanceCountEnd) == 0)

goto counter_error;

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

benchmarkTable[benchmarkTotalItems].id = thid;

benchmarkTable[benchmarkTotalItems].decSpeed = get_pkcs5_iteration_count(thid, benchmarkPim, FALSE, benchmarkPreBoot);

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

if (benchmarkPreBoot)

{

/* heuristics for boot times */

if (benchmarkGPT)

{

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

}

else

{

if (thid == SHA256)

{

#ifdef _WIN64

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

#else

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

#endif

}

else

{

#ifdef _WIN64

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

#else

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

#endif

}

}

}

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

benchmarkTotalItems++;

}

}

break;

case BENCHMARK_TYPE_ENCRYPTION:

{

/* Encryption algorithm benchmarks */

// CPU "warm up" (an attempt to prevent skewed results on systems where CPU frequency

// gradually changes depending on CPU load).

ci->ea = EAGetFirst();

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

{

ci->mode = FIRST_MODE_OF_OPERATION_ID;

if (EAInitMode (ci, ci->k2))

{

int i;

#ifdef _WIN64

if (IsRamEncryptionEnabled ())

VcProtectKeys (ci, VcGetEncryptionID (ci));

#endif

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

{

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

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

}

}

}

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

{

if (!EAIsFormatEnabled (ci->ea))

continue;

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

goto counter_error;

ci->mode = FIRST_MODE_OF_OPERATION_ID;

if (!EAInitMode (ci, ci->k2))

goto counter_error;

#ifdef _WIN64

if (IsRamEncryptionEnabled ())

VcProtectKeys (ci, VcGetEncryptionID (ci));

#endif

if (QueryPerformanceCounter (&performanceCountStart) == 0)

goto counter_error;

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

if (QueryPerformanceCounter (&performanceCountEnd) == 0)

goto counter_error;

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

if (QueryPerformanceCounter (&performanceCountStart) == 0)

goto counter_error;

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

if (QueryPerformanceCounter (&performanceCountEnd) == 0)

goto counter_error;

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;

EAGetName (benchmarkTable[benchmarkTotalItems].name, 100, ci->ea, 1);

benchmarkTotalItems++;

}

}

break;

}

if (ci)

crypto_close (ci);

if (lpTestBuffer)

{

VirtualUnlock (lpTestBuffer, benchmarkBufferSize - (benchmarkBufferSize % 16));

_aligned_free(lpTestBuffer);

}

benchmarkLastBufferSize = benchmarkBufferSize;

DisplayBenchmarkResults(hBenchDlg);

EnableWindow (GetDlgItem (hBenchDlg, IDC_PERFORM_BENCHMARK), TRUE);

EnableWindow (GetDlgItem (hBenchDlg, IDCLOSE), TRUE);

NormalCursor ();

return TRUE;

counter_error:

if (ci)

crypto_close (ci);

if (lpTestBuffer)

{

VirtualUnlock (lpTestBuffer, benchmarkBufferSize - (benchmarkBufferSize % 16));

_aligned_free(lpTestBuffer);

}

NormalCursor ();

EnableWindow (GetDlgItem (hBenchDlg, IDC_PERFORM_BENCHMARK), TRUE);

EnableWindow (GetDlgItem (hBenchDlg, IDCLOSE), TRUE);

MessageBoxW (hwndDlg, GetString ("ERR_PERF_COUNTER"), lpszTitle, ICON_HAND);

return FALSE;

}

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

{

WORD lw = LOWORD (wParam);

LPARAM nIndex;

static HWND hCboxSortMethod = NULL, hCboxBufferSize = NULL, hCboxList = NULL;

switch (msg)

{

case WM_INITDIALOG:

{

LVCOLUMNW LvCol;

wchar_t s[128];

HWND hList = GetDlgItem (hwndDlg, IDC_RESULTS);

hCboxSortMethod = GetDlgItem (hwndDlg, IDC_BENCHMARK_SORT_METHOD);

hCboxBufferSize = GetDlgItem (hwndDlg, IDC_BENCHMARK_BUFFER_SIZE);

hCboxList = GetDlgItem (hwndDlg, IDC_BENCHMARK_LIST);

LocalizeDialog (hwndDlg, "IDD_BENCHMARK_DLG");

benchmarkBufferSize = BENCHMARK_DEFAULT_BUF_SIZE;

benchmarkSortMethod = BENCHMARK_SORT_BY_SPEED;

benchmarkType = BENCHMARK_TYPE_ENCRYPTION;

if (lParam)

{

benchmarkGPT = TRUE;

}

else

benchmarkGPT = FALSE;

SendMessage (hList,LVM_SETEXTENDEDLISTVIEWSTYLE,0,

LVS_EX_FULLROWSELECT|LVS_EX_HEADERDRAGDROP|LVS_EX_LABELTIP

);

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

LvCol.mask = LVCF_TEXT|LVCF_WIDTH|LVCF_SUBITEM|LVCF_FMT;

LvCol.pszText = GetString ("ALGORITHM");

LvCol.cx = CompensateXDPI (114);

LvCol.fmt = LVCFMT_LEFT;

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

ResetBenchmarkList (hwndDlg);

/* Combo boxes */

// Sort method

SendMessage (hCboxSortMethod, CB_RESETCONTENT, 0, 0);

nIndex = SendMessageW (hCboxSortMethod, CB_ADDSTRING, 0, (LPARAM) GetString ("ALPHABETICAL_CATEGORIZED"));

SendMessage (hCboxSortMethod, CB_SETITEMDATA, nIndex, (LPARAM) 0);

nIndex = SendMessageW (hCboxSortMethod, CB_ADDSTRING, 0, (LPARAM) GetString ("MEAN_SPEED"));

SendMessage (hCboxSortMethod, CB_SETITEMDATA, nIndex, (LPARAM) 0);

SendMessage (hCboxSortMethod, CB_SETCURSEL, 1, 0); // Default sort method

// benchmark list

SendMessage (hCboxList, CB_RESETCONTENT, 0, 0);

nIndex = SendMessageW (hCboxList, CB_ADDSTRING, 0, (LPARAM) GetString ("ENCRYPTION_ALGORITHM"));

SendMessage (hCboxList, CB_SETITEMDATA, nIndex, (LPARAM) 0);

nIndex = SendMessageW (hCboxList, CB_ADDSTRING, 0, (LPARAM) GetString ("PKCS5_PRF"));

SendMessage (hCboxList, CB_SETITEMDATA, nIndex, (LPARAM) 0);

nIndex = SendMessageW (hCboxList, CB_ADDSTRING, 0, (LPARAM) GetString ("IDT_HASH_ALGO"));

SendMessage (hCboxList, CB_SETITEMDATA, nIndex, (LPARAM) 0);

SendMessage (hCboxList, CB_SETCURSEL, 0, 0); // Default: benchmark of encryption

// Buffer size

SendMessage (hCboxBufferSize, CB_RESETCONTENT, 0, 0);

StringCbPrintfW (s, sizeof(s), L"100 %s", GetString ("KB"));

nIndex = SendMessageW (hCboxBufferSize, CB_ADDSTRING, 0, (LPARAM) s);

SendMessage (hCboxBufferSize, CB_SETITEMDATA, nIndex, (LPARAM) 100 * BYTES_PER_KB);

StringCbPrintfW (s, sizeof(s), L"500 %s", GetString ("KB"));

nIndex = SendMessageW (hCboxBufferSize, CB_ADDSTRING, 0, (LPARAM) s);

SendMessage (hCboxBufferSize, CB_SETITEMDATA, nIndex, (LPARAM) 500 * BYTES_PER_KB);

StringCbPrintfW (s, sizeof(s), L"1 %s", GetString ("MB"));

nIndex = SendMessageW (hCboxBufferSize, CB_ADDSTRING, 0, (LPARAM) s);

SendMessage (hCboxBufferSize, CB_SETITEMDATA, nIndex, (LPARAM) 1 * BYTES_PER_MB);

StringCbPrintfW (s, sizeof(s), L"5 %s", GetString ("MB"));

nIndex = SendMessageW (hCboxBufferSize, CB_ADDSTRING, 0, (LPARAM) s);

SendMessage (hCboxBufferSize, CB_SETITEMDATA, nIndex, (LPARAM) 5 * BYTES_PER_MB);

StringCbPrintfW (s, sizeof(s), L"10 %s", GetString ("MB"));

nIndex = SendMessageW (hCboxBufferSize, CB_ADDSTRING, 0, (LPARAM) s);

SendMessage (hCboxBufferSize, CB_SETITEMDATA, nIndex, (LPARAM) 10 * BYTES_PER_MB);

StringCbPrintfW (s, sizeof(s), L"50 %s", GetString ("MB"));

nIndex = SendMessageW (hCboxBufferSize, CB_ADDSTRING, 0, (LPARAM) s);

SendMessage (hCboxBufferSize, CB_SETITEMDATA, nIndex, (LPARAM) 50 * BYTES_PER_MB);

StringCbPrintfW (s, sizeof(s), L"100 %s", GetString ("MB"));

nIndex = SendMessageW (hCboxBufferSize, CB_ADDSTRING, 0, (LPARAM) s);

SendMessage (hCboxBufferSize, CB_SETITEMDATA, nIndex, (LPARAM) 100 * BYTES_PER_MB);

StringCbPrintfW (s, sizeof(s), L"200 %s", GetString ("MB"));

nIndex = SendMessageW (hCboxBufferSize, CB_ADDSTRING, 0, (LPARAM) s);

SendMessage (hCboxBufferSize, CB_SETITEMDATA, nIndex, (LPARAM) 200 * BYTES_PER_MB);

StringCbPrintfW (s, sizeof(s), L"500 %s", GetString ("MB"));

nIndex = SendMessageW (hCboxBufferSize, CB_ADDSTRING, 0, (LPARAM) s);

SendMessage (hCboxBufferSize, CB_SETITEMDATA, nIndex, (LPARAM) 500 * BYTES_PER_MB);

StringCbPrintfW (s, sizeof(s), L"1 %s", GetString ("GB"));

nIndex = SendMessageW (hCboxBufferSize, CB_ADDSTRING, 0, (LPARAM) s);

SendMessage (hCboxBufferSize, CB_SETITEMDATA, nIndex, (LPARAM) 1 * BYTES_PER_GB);

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

uint32 driverConfig = ReadDriverConfigurationFlags();

int isAesHwSupported = HasAESNI();

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

if (isAesHwSupported && (driverConfig & TC_DRIVER_CONFIG_DISABLE_HARDWARE_ENCRYPTION))

{

Warning ("DISABLED_HW_AES_AFFECTS_PERFORMANCE", hwndDlg);

}

size_t cpuCount = GetCpuCount (NULL);

size_t nbrThreads = GetEncryptionThreadCount();

wchar_t nbrThreadsStr [300];

if (cpuCount < 2)

{

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

}

else if (nbrThreads < 2)

{

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

}

else

{

StringCbPrintfW (nbrThreadsStr, sizeof(nbrThreadsStr), GetString ("NUMBER_OF_THREADS"), nbrThreads);

}

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

ToHyperlink (hwndDlg, IDC_PARALLELIZATION_LABEL_LINK);

if (nbrThreads < min (cpuCount, GetMaxEncryptionThreadCount())

&& cpuCount > 1)

{

Warning ("LIMITED_THREAD_COUNT_AFFECTS_PERFORMANCE", hwndDlg);

}

return 1;

}

break;

case WM_COMMAND:

switch (lw)

{

case IDC_BENCHMARK_SORT_METHOD:

nIndex = SendMessage (hCboxSortMethod, CB_GETCURSEL, 0, 0);

if (nIndex != benchmarkSortMethod)

{

benchmarkSortMethod = (int) nIndex;

DisplayBenchmarkResults (hwndDlg);

}

return 1;

case IDC_BENCHMARK_LIST:

nIndex = SendMessage (hCboxList, CB_GETCURSEL, 0, 0);

if (nIndex != benchmarkType)

{

benchmarkType = (int) nIndex;

benchmarkTotalItems = 0;

ResetBenchmarkList (hwndDlg);

}

if (benchmarkType == BENCHMARK_TYPE_PRF)

{

ShowWindow (GetDlgItem (hwndDlg, IDC_BENCHMARK_BUFFER_SIZE), SW_HIDE);

ShowWindow (GetDlgItem (hwndDlg, IDT_BUFFER_SIZE), SW_HIDE);

ShowWindow (GetDlgItem (hwndDlg, IDC_PIM), SW_SHOW);

ShowWindow (GetDlgItem (hwndDlg, IDT_PIM), SW_SHOW);

ShowWindow (GetDlgItem (hwndDlg, IDC_BENCHMARK_PREBOOT), SW_SHOW);

}

else

{

ShowWindow (GetDlgItem (hwndDlg, IDC_BENCHMARK_BUFFER_SIZE), SW_SHOW);

ShowWindow (GetDlgItem (hwndDlg, IDT_BUFFER_SIZE), SW_SHOW);

ShowWindow (GetDlgItem (hwndDlg, IDC_PIM), SW_HIDE);

ShowWindow (GetDlgItem (hwndDlg, IDT_PIM), SW_HIDE);

ShowWindow (GetDlgItem (hwndDlg, IDC_BENCHMARK_PREBOOT), SW_HIDE);

}

return 1;

case IDC_PERFORM_BENCHMARK:

if (benchmarkType == BENCHMARK_TYPE_PRF)

{

benchmarkPim = GetPim (hwndDlg, IDC_PIM, 0);

benchmarkPreBoot = GetCheckBox (hwndDlg, IDC_BENCHMARK_PREBOOT);

}

else

{

nIndex = SendMessage (hCboxBufferSize, CB_GETCURSEL, 0, 0);

benchmarkBufferSize = (int) SendMessage (hCboxBufferSize, CB_GETITEMDATA, nIndex, 0);

}

BenchmarkThreadParam threadParam;

threadParam.hBenchDlg = hwndDlg;

threadParam.bStatus = FALSE;

WaitCursor ();

ShowWaitDialog (hwndDlg, TRUE, BenchmarkThreadProc, &threadParam);

NormalCursor ();

if (threadParam.bStatus == FALSE)

{

EndDialog (hwndDlg, IDCLOSE);

}

return 1;

case IDC_HW_AES_LABEL_LINK:

Applink ("hwacceleration");

return 1;

case IDC_PARALLELIZATION_LABEL_LINK:

Applink ("parallelization");

return 1;

case IDCLOSE:

case IDCANCEL:

EndDialog (hwndDlg, IDCLOSE);

return 1;

}

return 0;

break;

case WM_CLOSE:

EndDialog (hwndDlg, IDCLOSE);

return 1;

break;

}

return 0;

}

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

{

WORD lw = LOWORD (wParam);

WORD hw = HIWORD (wParam);

static unsigned char randPool [RNG_POOL_SIZE];

static unsigned char lastRandPool [RNG_POOL_SIZE];

static unsigned char maskRandPool [RNG_POOL_SIZE];

static BOOL bUseMask = FALSE;

static DWORD mouseEntropyGathered = 0xFFFFFFFF;

static DWORD mouseEventsInitialCount = 0;

/* max value of entropy needed to fill all random pool = 8 * RNG_POOL_SIZE = 2560 bits */

static const DWORD maxEntropyLevel = RNG_POOL_SIZE * 8;

static HWND hEntropyBar = NULL;

static wchar_t outputDispBuffer [RNG_POOL_SIZE * 3 + RANDPOOL_DISPLAY_ROWS + 2];

static BOOL bDisplayPoolContents = FALSE;

static BOOL bRandPoolDispAscii = FALSE;

int hash_algo = RandGetHashFunction();

int hid;

switch (msg)

{

case WM_INITDIALOG:

{

HWND hComboBox = GetDlgItem (hwndDlg, IDC_PRF_ID);

HCRYPTPROV hRngProv = NULL;

VirtualLock (randPool, sizeof(randPool));

VirtualLock (lastRandPool, sizeof(lastRandPool));

VirtualLock (outputDispBuffer, sizeof(outputDispBuffer));

VirtualLock (&mouseEntropyGathered, sizeof(mouseEntropyGathered));

VirtualLock (&mouseEventsInitialCount, sizeof(mouseEventsInitialCount));

VirtualLock (maskRandPool, sizeof(maskRandPool));

mouseEntropyGathered = 0xFFFFFFFF;

mouseEventsInitialCount = 0;

bUseMask = FALSE;

if (CryptAcquireContext (&hRngProv, NULL, MS_ENHANCED_PROV, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_SILENT))

{

if (CryptGenRandom (hRngProv, sizeof (maskRandPool), maskRandPool))

bUseMask = TRUE;

CryptReleaseContext (hRngProv, 0);

}

LocalizeDialog (hwndDlg, "IDD_RANDOM_POOL_ENRICHMENT");

SendMessage (hComboBox, CB_RESETCONTENT, 0, 0);

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

{

if (!HashIsDeprecated (hid))

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

}

SelectAlgo (hComboBox, &hash_algo);

SetCheckBox (hwndDlg, IDC_DISPLAY_POOL_CONTENTS, bDisplayPoolContents);

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

SendMessage (hEntropyBar, PBM_SETSTATE, PBST_ERROR, 0);

return 1;

}

case WM_TIMER:

{

wchar_t tmp[4];

unsigned char tmpByte;

int col, row;

DWORD mouseEventsCounter;

RandpeekBytes (hwndDlg, randPool, sizeof (randPool), &mouseEventsCounter);

ProcessEntropyEstimate (hEntropyBar, &mouseEventsInitialCount, mouseEventsCounter, maxEntropyLevel, &mouseEntropyGathered);

if (memcmp (lastRandPool, randPool, sizeof(lastRandPool)) != 0)

{

outputDispBuffer[0] = 0;

for (row = 0; row < RANDPOOL_DISPLAY_ROWS; row++)

{

for (col = 0; col < RANDPOOL_DISPLAY_COLUMNS; col++)

{

if (bDisplayPoolContents)

{

tmpByte = randPool[row * RANDPOOL_DISPLAY_COLUMNS + col];

StringCbPrintfW (tmp, sizeof(tmp), bRandPoolDispAscii ? ((tmpByte >= 32 && tmpByte < 255 && tmpByte != L'&') ? L" %c " : L" . ") : L"%02X ", tmpByte);

}

else if (bUseMask)

{

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

tmpByte = (randPool[row * RANDPOOL_DISPLAY_COLUMNS + col] -

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

tmp[2] = L' ';

tmp[3] = 0;

}

else

{

StringCbCopyW (tmp, sizeof(tmp), L"** ");

}

StringCbCatW (outputDispBuffer, sizeof(outputDispBuffer), tmp);

}

StringCbCatW (outputDispBuffer, sizeof(outputDispBuffer), L"\n");

}

SetWindowText (GetDlgItem (hwndDlg, IDC_POOL_CONTENTS), outputDispBuffer);

memcpy (lastRandPool, randPool, sizeof(lastRandPool));

}

return 1;

}

case WM_COMMAND:

if (lw == IDC_CONTINUE)

lw = IDOK;

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

{

goto exit;

}

if (lw == IDC_PRF_ID && hw == CBN_SELCHANGE)

{

hid = (int) SendMessage (GetDlgItem (hwndDlg, IDC_PRF_ID), CB_GETCURSEL, 0, 0);

hash_algo = (int) SendMessage (GetDlgItem (hwndDlg, IDC_PRF_ID), CB_GETITEMDATA, hid, 0);

RandSetHashFunction (hash_algo);

return 1;

}

if (lw == IDC_DISPLAY_POOL_CONTENTS)

{

if (!(bDisplayPoolContents = GetCheckBox (hwndDlg, IDC_DISPLAY_POOL_CONTENTS)))

{

wchar_t tmp[RNG_POOL_SIZE+1];

wmemset (tmp, L' ', ARRAYSIZE(tmp));

tmp [RNG_POOL_SIZE] = 0;

SetWindowText (GetDlgItem (hwndDlg, IDC_POOL_CONTENTS), tmp);

}

return 1;

}

return 0;

case WM_CLOSE:

{

wchar_t tmp[RNG_POOL_SIZE+1];

exit:

KillTimer (hwndDlg, 0xfd);

burn (randPool, sizeof(randPool));

burn (lastRandPool, sizeof(lastRandPool));

burn (outputDispBuffer, sizeof(outputDispBuffer));

burn (&mouseEntropyGathered, sizeof(mouseEntropyGathered));

burn (&mouseEventsInitialCount, sizeof(mouseEventsInitialCount));

burn (maskRandPool, sizeof(maskRandPool));

// Attempt to wipe the pool contents in the GUI text area

wmemset (tmp, L' ', RNG_POOL_SIZE);

tmp [RNG_POOL_SIZE] = 0;

SetWindowText (GetDlgItem (hwndDlg, IDC_POOL_CONTENTS), tmp);

if (msg == WM_COMMAND && lw == IDOK)

EndDialog (hwndDlg, IDOK);

else

EndDialog (hwndDlg, IDCLOSE);

return 1;

}

}

return 0;

}

/* Randinit is always called before UserEnrichRandomPool, so we don't need

* the extra Randinit call here since it will always succeed but we keep it

* for clarity purposes

*/

void UserEnrichRandomPool (HWND hwndDlg)

{

if ((0 == Randinit()) && !IsRandomPoolEnrichedByUser())

{

INT_PTR result = DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_RANDOM_POOL_ENRICHMENT), hwndDlg ? hwndDlg : MainDlg, (DLGPROC) RandomPoolEnrichementDlgProc, (LPARAM) 0);

SetRandomPoolEnrichedByUserStatus (result == IDOK);

}

}

/* Except in response to the WM_INITDIALOG message, the dialog box procedure

should return nonzero if it processes the message, and zero if it does

not. - see DialogProc */

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

{

WORD lw = LOWORD (wParam);

WORD hw = HIWORD (wParam);

static unsigned char randPool [RNG_POOL_SIZE];

static unsigned char lastRandPool [RNG_POOL_SIZE];

static unsigned char maskRandPool [RNG_POOL_SIZE];

static BOOL bUseMask = FALSE;

static DWORD mouseEntropyGathered = 0xFFFFFFFF;

static DWORD mouseEventsInitialCount = 0;

/* max value of entropy needed to fill all random pool = 8 * RNG_POOL_SIZE = 2560 bits */

static const DWORD maxEntropyLevel = RNG_POOL_SIZE * 8;

static HWND hEntropyBar = NULL;

static wchar_t outputDispBuffer [RNG_POOL_SIZE * 3 + RANDPOOL_DISPLAY_ROWS + 2];

static BOOL bDisplayPoolContents = FALSE;

static BOOL bRandPoolDispAscii = FALSE;

int hash_algo = RandGetHashFunction();

int hid;

switch (msg)

{

case WM_INITDIALOG:

{

HWND hComboBox = GetDlgItem (hwndDlg, IDC_PRF_ID);

HCRYPTPROV hRngProv = NULL;

VirtualLock (randPool, sizeof(randPool));

VirtualLock (lastRandPool, sizeof(lastRandPool));

VirtualLock (outputDispBuffer, sizeof(outputDispBuffer));

VirtualLock (&mouseEntropyGathered, sizeof(mouseEntropyGathered));

VirtualLock (&mouseEventsInitialCount, sizeof(mouseEventsInitialCount));

VirtualLock (maskRandPool, sizeof(maskRandPool));

mouseEntropyGathered = 0xFFFFFFFF;

mouseEventsInitialCount = 0;

bUseMask = FALSE;

if (CryptAcquireContext (&hRngProv, NULL, MS_ENHANCED_PROV, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_SILENT))

{

if (CryptGenRandom (hRngProv, sizeof (maskRandPool), maskRandPool))

bUseMask = TRUE;

CryptReleaseContext (hRngProv, 0);

}

LocalizeDialog (hwndDlg, "IDD_KEYFILE_GENERATOR");

SendMessage (hComboBox, CB_RESETCONTENT, 0, 0);

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

{

if (!HashIsDeprecated (hid))

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 (hEntropyBar, PBM_SETSTATE, PBST_ERROR, 0);

#ifndef VOLFORMAT

if (Randinit ())

{

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

EndDialog (hwndDlg, IDCLOSE);

}

#endif

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

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

// 9-digit limit for the number of keyfiles (more than enough!)

SendMessage (GetDlgItem (hwndDlg, IDC_NUMBER_KEYFILES), EM_SETLIMITTEXT, (WPARAM) 9, 0);

SetWindowText(GetDlgItem (hwndDlg, IDC_NUMBER_KEYFILES), L"1");

// maximum keyfile size is 1048576, so limit the edit control to 7 characters

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:

{

wchar_t tmp[4];

unsigned char tmpByte;

int col, row;

DWORD mouseEventsCounter;

RandpeekBytes (hwndDlg, randPool, sizeof (randPool), &mouseEventsCounter);

ProcessEntropyEstimate (hEntropyBar, &mouseEventsInitialCount, mouseEventsCounter, maxEntropyLevel, &mouseEntropyGathered);

if (memcmp (lastRandPool, randPool, sizeof(lastRandPool)) != 0)

{

outputDispBuffer[0] = 0;

for (row = 0; row < RANDPOOL_DISPLAY_ROWS; row++)

{

for (col = 0; col < RANDPOOL_DISPLAY_COLUMNS; col++)

{

if (bDisplayPoolContents)

{

tmpByte = randPool[row * RANDPOOL_DISPLAY_COLUMNS + col];

StringCbPrintfW (tmp, sizeof(tmp), bRandPoolDispAscii ? ((tmpByte >= 32 && tmpByte < 255 && tmpByte != L'&') ? L" %c " : L" . ") : L"%02X ", tmpByte);

}

else if (bUseMask)

{

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

tmpByte = (randPool[row * RANDPOOL_DISPLAY_COLUMNS + col] -

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

tmp[2] = L' ';

tmp[3] = 0;

}

else

{

StringCbCopyW (tmp, sizeof(tmp), L"** ");

}

StringCbCatW (outputDispBuffer, sizeof(outputDispBuffer), tmp);

}

StringCbCatW (outputDispBuffer, sizeof(outputDispBuffer), L"\n");

}

SetWindowText (GetDlgItem (hwndDlg, IDC_POOL_CONTENTS), outputDispBuffer);

memcpy (lastRandPool, randPool, sizeof(lastRandPool));

}

return 1;

}

case WM_COMMAND:

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

{

goto exit;

}

if (lw == IDC_PRF_ID && hw == CBN_SELCHANGE)

{

hid = (int) SendMessage (GetDlgItem (hwndDlg, IDC_PRF_ID), CB_GETCURSEL, 0, 0);

hash_algo = (int) SendMessage (GetDlgItem (hwndDlg, IDC_PRF_ID), CB_GETITEMDATA, hid, 0);

RandSetHashFunction (hash_algo);

return 1;

}

if (lw == IDC_DISPLAY_POOL_CONTENTS)

{

if (!(bDisplayPoolContents = GetCheckBox (hwndDlg, IDC_DISPLAY_POOL_CONTENTS)))

{

wchar_t tmp[RNG_POOL_SIZE+1];

wmemset (tmp, L' ', ARRAYSIZE(tmp));

tmp [RNG_POOL_SIZE] = 0;

SetWindowText (GetDlgItem (hwndDlg, IDC_POOL_CONTENTS), tmp);

}

return 1;

}

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 szNumber[16] = {0};

wchar_t szFileBaseName[TC_MAX_PATH];

wchar_t szDirName[TC_MAX_PATH];

wchar_t szFileName [2*TC_MAX_PATH + 16];

unsigned char *keyfile = NULL;

int fhKeyfile = -1, status;

long keyfilesCount = 0, keyfilesSize = 0, i;

wchar_t* fileExtensionPtr = 0;

wchar_t szSuffix[32];

BOOL bRandomSize = GetCheckBox (hwndDlg, IDC_KEYFILES_RANDOM_SIZE);

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

szNumber[0] = 0;

keyfilesCount = wcstoul(szNumber, NULL, 0);

if (keyfilesCount <= 0 || keyfilesCount == LONG_MAX)

{

Warning("KEYFILE_INCORRECT_NUMBER", hwndDlg);

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

return 1;

}

if (!bRandomSize)

{

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

szNumber[0] = 0;

keyfilesSize = wcstoul(szNumber, NULL, 0);

if (keyfilesSize < 64 || keyfilesSize > 1024*1024)

{

Warning("KEYFILE_INCORRECT_SIZE", hwndDlg);

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

return 1;

}

}

if (!GetWindowText(GetDlgItem (hwndDlg, IDC_KEYFILES_BASE_NAME), szFileBaseName, TC_MAX_PATH))

szFileBaseName[0] = 0;

// Trim trailing space

if (TrimWhiteSpace(szFileBaseName) == 0)

{

Warning("KEYFILE_EMPTY_BASE_NAME", hwndDlg);

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

return 1;

}

if (!IsValidFileName(szFileBaseName))

{

Warning("KEYFILE_INVALID_BASE_NAME", hwndDlg);

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

return 1;

}

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

/* Select directory */

if (!BrowseDirectories (hwndDlg, "SELECT_KEYFILE_GENERATION_DIRECTORY", szDirName))

return 1;

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

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

WaitCursor();

keyfile = (unsigned char*) TCalloc( bRandomSize? KEYFILE_MAX_READ_LEN : keyfilesSize );

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

{

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

if (i > 0)

{

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

// Append the counter to the name

if (fileExtensionPtr)

{

StringCchCatN(szFileName, ARRAYSIZE(szFileName), szFileBaseName, (size_t) (fileExtensionPtr - szFileBaseName));

StringCbCat(szFileName, sizeof(szFileName), szSuffix);

StringCbCat(szFileName, sizeof(szFileName), fileExtensionPtr);

}

else

{

StringCbCat(szFileName, sizeof(szFileName), szFileBaseName);

StringCbCat(szFileName, sizeof(szFileName), szSuffix);

}

}

else

StringCbCat(szFileName, sizeof(szFileName), szFileBaseName);

// check if the file exists

if ((fhKeyfile = _wopen(szFileName, _O_RDONLY|_O_BINARY, _S_IREAD|_S_IWRITE)) != -1)

{

WCHAR s[4*TC_MAX_PATH] = {0};

_close (fhKeyfile);

StringCbPrintfW (s, sizeof(s), GetString ("KEYFILE_ALREADY_EXISTS"), szFileName);

status = AskWarnNoYesString (s, hwndDlg);

if (status == IDNO)

{

TCfree(keyfile);

NormalCursor();

return 1;

}

}

/* Conceive the file */

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

{

TCfree(keyfile);

NormalCursor();

handleWin32Error (hwndDlg, SRC_POS);

return 1;

}

if (bRandomSize)

{

/* Generate a random size */

if (!RandgetBytes (hwndDlg, (unsigned char*) &keyfilesSize, sizeof(keyfilesSize), FALSE))

{

_close (fhKeyfile);

DeleteFile (szFileName);

TCfree(keyfile);

NormalCursor();

return 1;

}

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

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

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

keyfilesSize += 64;

}

/* Generate the keyfile */

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

{

_close (fhKeyfile);

DeleteFile (szFileName);

TCfree(keyfile);

NormalCursor();

return 1;

}

/* Write the keyfile */

status = _write (fhKeyfile, keyfile, keyfilesSize);

burn (keyfile, keyfilesSize);

_close (fhKeyfile);

if (status == -1)

{

TCfree(keyfile);

NormalCursor();

handleWin32Error (hwndDlg, SRC_POS);

return 1;

}

}

TCfree(keyfile);

NormalCursor();

Info("KEYFILE_CREATED", hwndDlg);

return 1;

}

return 0;

case WM_CLOSE:

{

wchar_t tmp[RNG_POOL_SIZE+1];

exit:

WaitCursor();

KillTimer (hwndDlg, 0xfd);

#ifndef VOLFORMAT

RandStop (FALSE);

#endif

/* Cleanup */

burn (randPool, sizeof(randPool));

burn (lastRandPool, sizeof(lastRandPool));

burn (outputDispBuffer, sizeof(outputDispBuffer));

burn (&mouseEntropyGathered, sizeof(mouseEntropyGathered));

burn (&mouseEventsInitialCount, sizeof(mouseEventsInitialCount));

burn (maskRandPool, sizeof(maskRandPool));

// Attempt to wipe the pool contents in the GUI text area

wmemset (tmp, L' ', RNG_POOL_SIZE);

tmp [RNG_POOL_SIZE] = 0;

SetWindowText (GetDlgItem (hwndDlg, IDC_POOL_CONTENTS), tmp);

EndDialog (hwndDlg, IDCLOSE);

NormalCursor ();

return 1;

}

}

return 0;

}

/* Except in response to the WM_INITDIALOG message, the dialog box procedure

should return nonzero if it processes the message, and zero if it does

not. - see DialogProc */

BOOL CALLBACK

CipherTestDialogProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)

{

static int idTestCipher = -1; /* Currently selected cipher for the test vector facility (none = -1). */

static BOOL bXTSTestEnabled = FALSE;

PCRYPTO_INFO ci;

WORD lw = LOWORD (wParam);

WORD hw = HIWORD (wParam);

switch (uMsg)

{

case WM_INITDIALOG:

{

int ea;

wchar_t buf[100];

LocalizeDialog (hwndDlg, "IDD_CIPHER_TEST_DLG");

SendMessage(GetDlgItem(hwndDlg, IDC_TESTS_MESSAGE), WM_SETFONT, (WPARAM)hBoldFont, MAKELPARAM(TRUE,0));

SendMessage(GetDlgItem(hwndDlg, IDC_KEY), EM_LIMITTEXT, 128,0);

SendMessage(GetDlgItem(hwndDlg, IDC_KEY), WM_SETFONT, (WPARAM)hFixedDigitFont, MAKELPARAM(1,0));

SendMessage(GetDlgItem(hwndDlg, IDC_PLAINTEXT), EM_LIMITTEXT,64,0);

SendMessage(GetDlgItem(hwndDlg, IDC_PLAINTEXT), WM_SETFONT, (WPARAM)hFixedDigitFont, MAKELPARAM(1,0));

SendMessage(GetDlgItem(hwndDlg, IDC_CIPHERTEXT), EM_LIMITTEXT,64,0);

SendMessage(GetDlgItem(hwndDlg, IDC_CIPHERTEXT), WM_SETFONT, (WPARAM)hFixedDigitFont, MAKELPARAM(1,0));

SendMessage(GetDlgItem(hwndDlg, IDC_SECONDARY_KEY), EM_LIMITTEXT, 128,0);

SendMessage(GetDlgItem(hwndDlg, IDC_SECONDARY_KEY), WM_SETFONT, (WPARAM)hFixedDigitFont, MAKELPARAM(1,0));

SendMessage(GetDlgItem(hwndDlg, IDC_TEST_DATA_UNIT_NUMBER), EM_LIMITTEXT,32,0);

SendMessage(GetDlgItem(hwndDlg, IDC_TEST_DATA_UNIT_NUMBER), WM_SETFONT, (WPARAM)hFixedDigitFont, MAKELPARAM(1,0));

SetCheckBox (hwndDlg, IDC_XTS_MODE_ENABLED, bXTSTestEnabled);

EnableWindow (GetDlgItem (hwndDlg, IDC_SECONDARY_KEY), bXTSTestEnabled);

EnableWindow (GetDlgItem (hwndDlg, IDT_SECONDARY_KEY), bXTSTestEnabled);

EnableWindow (GetDlgItem (hwndDlg, IDC_TEST_BLOCK_NUMBER), bXTSTestEnabled);

EnableWindow (GetDlgItem (hwndDlg, IDT_TEST_BLOCK_NUMBER), bXTSTestEnabled);

EnableWindow (GetDlgItem (hwndDlg, IDC_TEST_DATA_UNIT_NUMBER), bXTSTestEnabled);

EnableWindow (GetDlgItem (hwndDlg, IDT_TEST_DATA_UNIT_NUMBER), bXTSTestEnabled);

if (idTestCipher == -1)

idTestCipher = (int) lParam;

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

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

{

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

AddComboPair (GetDlgItem (hwndDlg, IDC_CIPHER), EAGetName (buf, ARRAYSIZE(buf),ea, 1), EAGetFirstCipher (ea));

}

ResetCipherTest(hwndDlg, idTestCipher);

SelectAlgo (GetDlgItem (hwndDlg, IDC_CIPHER), &idTestCipher);

return 1;

}

case WM_COMMAND:

if (hw == CBN_SELCHANGE && lw == IDC_CIPHER)

{

idTestCipher = (int) SendMessage (GetDlgItem (hwndDlg, IDC_CIPHER), CB_GETITEMDATA, SendMessage (GetDlgItem (hwndDlg, IDC_CIPHER), CB_GETCURSEL, 0, 0), 0);

ResetCipherTest(hwndDlg, idTestCipher);

SendMessage (hwndDlg, WM_INITDIALOG, 0, 0);

return 1;

}

if (hw == CBN_SELCHANGE && lw == IDC_KEY_SIZE)

{

// NOP

return 1;

}

if (lw == IDC_RESET)

{

ResetCipherTest(hwndDlg, idTestCipher);

return 1;

}

if (lw == IDC_AUTO)

{

WaitCursor ();

if (!AutoTestAlgorithms())

{

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

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

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

}

NormalCursor ();

return 1;

}

if (lw == IDC_XTS_MODE_ENABLED)

{

bXTSTestEnabled = GetCheckBox (hwndDlg, IDC_XTS_MODE_ENABLED);

EnableWindow (GetDlgItem (hwndDlg, IDC_SECONDARY_KEY), bXTSTestEnabled);

EnableWindow (GetDlgItem (hwndDlg, IDT_SECONDARY_KEY), bXTSTestEnabled);

EnableWindow (GetDlgItem (hwndDlg, IDC_TEST_BLOCK_NUMBER), bXTSTestEnabled);

EnableWindow (GetDlgItem (hwndDlg, IDT_TEST_BLOCK_NUMBER), bXTSTestEnabled);

EnableWindow (GetDlgItem (hwndDlg, IDT_TEST_DATA_UNIT_NUMBER), bXTSTestEnabled);

EnableWindow (GetDlgItem (hwndDlg, IDC_TEST_DATA_UNIT_NUMBER), bXTSTestEnabled);

if (bXTSTestEnabled)

SendMessage(GetDlgItem(hwndDlg, IDC_KEY_SIZE), CB_SETCURSEL, 0,0);

}

if (lw == IDOK || lw == IDC_ENCRYPT || lw == IDC_DECRYPT)

{

CRYPTOPP_ALIGN_DATA(16) char key[128+1], inputtext[128+1], secondaryKey[64+1], dataUnitNo[16+1];

wchar_t szTmp[128+1];

int ks, pt, n, tlen, blockNo = 0;

BOOL bEncrypt;

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

ShowWindow(GetDlgItem(hwndDlg, IDC_REDTICK), SW_HIDE);

ks = (int) SendMessage(GetDlgItem(hwndDlg, IDC_KEY_SIZE), CB_GETCURSEL, 0,0);

ks = (int) SendMessage(GetDlgItem(hwndDlg, IDC_KEY_SIZE), CB_GETITEMDATA, ks,0);

pt = (int) SendMessage(GetDlgItem(hwndDlg, IDC_PLAINTEXT_SIZE), CB_GETITEMDATA, 0,0);

bEncrypt = lw == IDC_ENCRYPT;

memset(key,0,sizeof(key));

memset(szTmp,0,sizeof(szTmp));

n = GetWindowText(GetDlgItem(hwndDlg, IDC_KEY), szTmp, ARRAYSIZE(szTmp));

if (n != ks * 2)

{

Warning ("TEST_KEY_SIZE", hwndDlg);

return 1;

}

for (n = 0; n < ks; n ++)

{

wchar_t szTmp2[3], *ptr;

long x;

szTmp2[2] = 0;

szTmp2[0] = szTmp[n * 2];

szTmp2[1] = szTmp[n * 2 + 1];

x = wcstol(szTmp2, &ptr, 16);

key[n] = (char) x;

}

memset(inputtext, 0, sizeof(inputtext));

memset(secondaryKey, 0, sizeof(secondaryKey));

memset(dataUnitNo, 0, sizeof(dataUnitNo));

memset(szTmp, 0, sizeof(szTmp));

if (bEncrypt)

{

n = GetWindowText(GetDlgItem(hwndDlg, IDC_PLAINTEXT), szTmp, ARRAYSIZE(szTmp));

}

else

{

n = GetWindowText(GetDlgItem(hwndDlg, IDC_CIPHERTEXT), szTmp, ARRAYSIZE(szTmp));

}

if (n != pt * 2)

{

if (bEncrypt)

{

Warning ("TEST_PLAINTEXT_SIZE", hwndDlg);

return 1;

}

else

{

Warning ("TEST_CIPHERTEXT_SIZE", hwndDlg);

return 1;

}

}

for (n = 0; n < pt; n ++)

{

wchar_t szTmp2[3], *ptr;

long x;

szTmp2[2] = 0;

szTmp2[0] = szTmp[n * 2];

szTmp2[1] = szTmp[n * 2 + 1];

x = wcstol(szTmp2, &ptr, 16);

inputtext[n] = (char) x;

}

// XTS

if (bXTSTestEnabled)

{

// Secondary key

if (GetWindowText(GetDlgItem(hwndDlg, IDC_SECONDARY_KEY), szTmp, ARRAYSIZE(szTmp)) != 64)

{

Warning ("TEST_INCORRECT_SECONDARY_KEY_SIZE", hwndDlg);

return 1;

}

for (n = 0; n < 64; n ++)

{

wchar_t szTmp2[3], *ptr;

long x;

szTmp2[2] = 0;

szTmp2[0] = szTmp[n * 2];

szTmp2[1] = szTmp[n * 2 + 1];

x = wcstol(szTmp2, &ptr, 16);

secondaryKey[n] = (char) x;

}

// Data unit number

tlen = GetWindowText(GetDlgItem(hwndDlg, IDC_TEST_DATA_UNIT_NUMBER), szTmp, ARRAYSIZE(szTmp));

if (tlen > 16 || tlen < 1)

{

Warning ("TEST_INCORRECT_TEST_DATA_UNIT_SIZE", hwndDlg);

return 1;

}

LeftPadString (szTmp, tlen, 16, L'0');

for (n = 0; n < 16; n ++)

{

wchar_t szTmp2[3], *ptr;

long x;

szTmp2[2] = 0;

szTmp2[0] = szTmp[n * 2];

szTmp2[1] = szTmp[n * 2 + 1];

x = wcstol(szTmp2, &ptr, 16);

dataUnitNo[n] = (char) x;

}

// Block number