#pragma pack (pop)

#define DRIVER_STR WIDE

#define TC_UNIQUE_ID_PREFIX "VeraCryptVolume"

#define TC_MOUNT_PREFIX L"\\Device\\VeraCryptVolume"

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

{

try

{

file->CheckOpened (SRC_POS);

file->SeekAt (offset);

DWORD BaseCom::WriteLocalMachineRegistryDwordValue (BSTR keyPath, BSTR valueName, DWORD value)

{

return GetLastError();

return ERROR_SUCCESS;

}

}

{

Elevate();

DWORD result;

CComBSTR sourceFileBstr, destinationFileBstr;

if (bstr)

{

sourceFileBstr.Attach (bstr);

if (bstr)

{

destinationFileBstr.Attach (bstr);

}

}

{

Elevate();

CComBSTR fileBstr;

DWORD result;

if (bstr)

{

fileBstr.Attach (bstr);

}

}

{

Elevate();

CComBSTR bufferBstr, fileBstr;

if (bufferBstr.AppendBytes ((const char *) buffer, size) != S_OK)

throw ParameterIncorrect (SRC_POS);

if (bstr)

{

fileBstr.Attach (bstr);

return ElevatedComInstance->IsPagingFileActive (checkNonWindowsPartitionsOnly);

}

{

Elevate();

DWORD result;

CComBSTR keyPathBstr, valueNameBstr;

if (bstr)

{

keyPathBstr.Attach (bstr);

if (bstr)

{

valueNameBstr.Attach (bstr);

public:

static void AddReference () { }

static void CallDriver (DWORD ioctl, void *input, DWORD inputSize, void *output, DWORD outputSize) { throw ParameterIncorrect (SRC_POS); }

static void RegisterFilterDriver (bool registerDriver, BootEncryption::FilterType filterType) { throw ParameterIncorrect (SRC_POS); }

static void Release () { }

static void SetDriverServiceStartType (DWORD startType) { throw ParameterIncorrect (SRC_POS); }

#endif // SETUP

{

Handle = CreateFile (path.c_str(),

readOnly ? GENERIC_READ : GENERIC_READ | GENERIC_WRITE,

}

}

{

MessageBox (parent, str.c_str(), NULL, 0);

}

{

FileOpen = false;

Elevated = false;

readOnly ? GENERIC_READ : GENERIC_READ | GENERIC_WRITE,

FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,

FILE_FLAG_RANDOM_ACCESS | FILE_FLAG_WRITE_THROUGH, NULL);

DWORD BootEncryption::GetDriverServiceStartType ()

{

DWORD startType;

return startType;

}

finally_do_arg (SC_HANDLE, serviceManager, { CloseServiceHandle (finally_arg); });

throw_sys_if (!service);

finally_do_arg (SC_HANDLE, service, { CloseServiceHandle (finally_arg); });

// Windows versions preceding Vista can be installed on FAT filesystem which does not

// support long filenames during boot. Convert the driver path to short form if required.

if (startOnBoot && !IsOSAtLeast (WIN_VISTA))

{

{

// Convert absolute path to relative to the Windows directory

driverPath = pathBuf;

}

}

throw_sys_if (!ChangeServiceConfig (service, SERVICE_NO_CHANGE, SERVICE_NO_CHANGE,

startOnBoot ? SERVICE_ERROR_SEVERE : SERVICE_ERROR_NORMAL,

driverPath.empty() ? NULL : driverPath.c_str(),

NULL, NULL, NULL, NULL, NULL));

// ChangeServiceConfig() rejects SERVICE_BOOT_START with ERROR_INVALID_PARAMETER

}

GetSystemDriveConfiguration();

ProbeRealDriveSizeRequest request;

CallDriver (TC_IOCTL_PROBE_REAL_DRIVE_SIZE, &request, sizeof (request), &request, sizeof (request));

DriveConfig.DrivePartition.Info.PartitionLength = request.RealDriveSize;

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

{

DISK_PARTITION_INFO_STRUCT diskPartInfo = {0};

try

{

part.IsGPT = diskPartInfo.IsGPT;

// Mount point

if (driveNumber >= 0)

{

}

// Volume ID

wchar_t volumePath[TC_MAX_PATH];

{

wchar_t volumeName[TC_MAX_PATH];

HANDLE fh = FindFirstVolumeW (volumeName, array_capacity (volumeName));

DISK_GEOMETRY BootEncryption::GetDriveGeometry (int driveNumber)

{

DISK_GEOMETRY geometry;

return geometry;

}

{

}

{

throw ParameterIncorrect (SRC_POS);

}

}

// Note that this does not require admin rights (it just requires the driver to be running)

{

try

{

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

DWORD dwResult;

openTestStruct.bDetectTCBootLoader = TRUE;

bool BootEncryption::SystemDriveIsDynamic ()

{

GetSystemDriveConfigurationRequest request;

CallDriver (TC_IOCTL_GET_SYSTEM_DRIVE_CONFIG, &request, sizeof (request), &request, sizeof (request));

return request.DriveIsDynamic ? true : false;

SystemDriveConfiguration config;

// Scan all drives

for (int driveNumber = 0; driveNumber < 32; ++driveNumber)

foreach (const Partition &part, partitions)

{

if (!part.MountPoint.empty()

{

config.SystemLoaderPresent = true;

}

{

config.DriveNumber = driveNumber;

config.DevicePath = ss.str();

config.DeviceKernelPath = kernelPath.str();

config.DrivePartition = partitions.front();

// Boot sector

DWORD size;

if (!bootSecResourceImg || size != TC_SECTOR_SIZE_BIOS)

throw ParameterIncorrect (SRC_POS);

}

// Decompressor

if (!decompressor || size > TC_BOOT_LOADER_DECOMPRESSOR_SECTOR_COUNT * TC_SECTOR_SIZE_BIOS)

throw ParameterIncorrect (SRC_POS);

memcpy (buffer + TC_SECTOR_SIZE_BIOS, decompressor, size);

// Compressed boot loader

if (!bootLoader || size > TC_MAX_BOOT_LOADER_SECTOR_COUNT * TC_SECTOR_SIZE_BIOS)

throw ParameterIncorrect (SRC_POS);

throw ParameterIncorrect (SRC_POS);

GetSystemDriveConfigurationRequest request;

try

{

}

#endif

{

throw_sys_if (!SUCCEEDED (SHGetFolderPath (NULL, CSIDL_COMMON_APPDATA | CSIDL_FLAG_CREATE, NULL, 0, pathBuf)));

CreateDirectory (path.c_str(), NULL);

}

void BootEncryption::RenameDeprecatedSystemLoaderBackup ()

{

if (SUCCEEDED (SHGetFolderPath (NULL, CSIDL_COMMON_APPDATA, NULL, 0, pathBuf)))

{

if (FileExists (path.c_str()) && !FileExists (GetSystemLoaderBackupPath().c_str()))

}

}

#ifndef SETUP

{

BootEncryptionStatus encStatus = GetStatus();

if (encStatus.SetupInProgress)

if (!RescueIsoImage)

throw ParameterIncorrect (SRC_POS);

{

try

{

// check that it is a CD/DVD drive or a removable media in case a bootable

// USB key was created from the rescue disk ISO file

if ((DRIVE_CDROM == driveType) || (DRIVE_REMOVABLE == driveType))

return false;

}

{

if (!RescueIsoImage)

throw ParameterIncorrect (SRC_POS);

filter = "veracrypt.sys";

filterReg = "DumpFilters";

throw_sys_if (GetLastError() != ERROR_SUCCESS);

break;

// SetupInstallFromInfSection() does not support prepending of values so we have to modify the registry directly

StringCbCopyA ((char *) regKeyBuf, sizeof(regKeyBuf), filter.c_str());

size = 1;

throw_sys_if (GetLastError() != ERROR_SUCCESS);

}

else

{

File infFile (infFileName, false, true);

string infTxt = "[veracrypt]\r\n"

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

throw_sys_if (hInf == INVALID_HANDLE_VALUE);

finally_do_arg (HINF, hInf, { SetupCloseInfFile (finally_arg); });

}

}

throw_sys_if (!scm);

finally_do_arg (SC_HANDLE, scm, { CloseServiceHandle (finally_arg); });

if (registerService)

{

if (!noFileHandling)

{

throw_sys_if (!CopyFile (appPath, servicePath.c_str(), FALSE));

}

SC_HANDLE service = CreateService (scm,

TC_SYSTEM_FAVORITES_SERVICE_NAME,

SERVICE_ALL_ACCESS,

SERVICE_WIN32_OWN_PROCESS,

SERVICE_AUTO_START,

SERVICE_ERROR_NORMAL,

TC_SYSTEM_FAVORITES_SERVICE_LOAD_ORDER_GROUP,

NULL,

NULL,

throw_sys_if (!service);

SERVICE_DESCRIPTION description;

ChangeServiceConfig2 (service, SERVICE_CONFIG_DESCRIPTION, &description);

CloseServiceHandle (service);

try

{

SetDriverConfigurationFlag (TC_DRIVER_CONFIG_CACHE_BOOT_PASSWORD_FOR_SYS_FAVORITES, true);

}

{

SetDriverConfigurationFlag (TC_DRIVER_CONFIG_CACHE_BOOT_PASSWORD_FOR_SYS_FAVORITES, false);

SC_HANDLE service = OpenService (scm, TC_SYSTEM_FAVORITES_SERVICE_NAME, SERVICE_ALL_ACCESS);

throw_sys_if (!service);

finally_do_arg (SC_HANDLE, scm, { CloseServiceHandle (finally_arg); });

// check if service exists

SC_HANDLE service = OpenService (scm, TC_SYSTEM_FAVORITES_SERVICE_NAME, SERVICE_ALL_ACCESS);

SERVICE_WIN32_OWN_PROCESS,

SERVICE_AUTO_START,

SERVICE_ERROR_NORMAL,

TC_SYSTEM_FAVORITES_SERVICE_LOAD_ORDER_GROUP,

NULL,

NULL,

NULL,

NULL,

}

else

else

configMap &= ~flag;

#ifdef SETUP

#else

#endif

}

void BootEncryption::InitialSecurityChecksForHiddenOS ()

{

// Paging files

bool pagingFilesOk = !IsPagingFileActive (TRUE);

DWORD pagingFileRegDataSize = sizeof (pagingFileRegData);

{

{

{

pagingFilesOk = false;

break;

}

// User profile

{

throw ErrorException (wstring (GetString ("USER_PROFILE_NOT_ON_SYS_PARTITION"))

+ GetString ("LEAKS_OUTSIDE_SYSPART_UNIVERSAL_EXPLANATION"), SRC_POS);

}

// Temporary files

{

throw ErrorException (wstring (GetString ("TEMP_NOT_ON_SYS_PARTITION"))

+ GetString ("LEAKS_OUTSIDE_SYSPART_UNIVERSAL_EXPLANATION"), SRC_POS);

}

{

BootEncryptionStatus encStatus = GetStatus();

if (encStatus.DriveMounted)

void BootEncryption::RestrictPagingFilesToSystemPartition ()

{

pagingFiles[0] = GetWindowsDirectory()[0];

}

{

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

{

CallDriver (TC_IOCTL_BOOT_ENCRYPTION_SETUP, &request, sizeof (request), NULL, 0);

}

{

if (!IsAdmin())

{

throw_sys_if (!::CopyFile (sourceFile.c_str(), destinationFile.c_str(), FALSE));

}

{

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

Elevator::DeleteFile (file);

{

DWORD configMap;

configMap = 0;

return configMap;

{

public:

File () : Elevated (false), FileOpen (false), FilePointerPosition(0), Handle(INVALID_HANDLE_VALUE), IsDevice(false), LastError(0) { }

virtual ~File () { Close(); }

void CheckOpened (const char* srcPos) { if (!FileOpen) { SetLastError (LastError); throw SystemException (srcPos);} }

uint64 FilePointerPosition;

HANDLE Handle;

bool IsDevice;

DWORD LastError;

};

class Device : public File

{

public:

virtual ~Device () {}

};

struct Partition

{

PARTITION_INFORMATION Info;

size_t Number;

BOOL IsGPT;

wstring VolumeNameId;

struct SystemDriveConfiguration

{

int DriveNumber;

Partition DrivePartition;

bool ExtraBootPartitionPresent;

void CheckEncryptionSetupResult ();

void CheckRequirements ();

void CheckRequirementsHiddenOS ();

void Deinstall (bool displayWaitDialog = false);

DecoySystemWipeStatus GetDecoyOSWipeStatus ();

DWORD GetDriverServiceStartType ();

unsigned int GetHiddenOSCreationPhase ();

uint16 GetInstalledBootLoaderVersion ();

void GetInstalledBootLoaderFingerprint (byte fingerprint[WHIRLPOOL_DIGESTSIZE + SHA512_DIGESTSIZE]);

Partition GetPartitionForHiddenOS ();

BootEncryptionStatus GetStatus ();

void GetVolumeProperties (VOLUME_PROPERTIES_STRUCT *properties);

SystemDriveConfiguration GetSystemDriveConfiguration ();

void Install (bool hiddenSystem);

bool IsHiddenSystemRunning ();

bool IsPagingFileActive (BOOL checkNonWindowsPartitionsOnly);

void PrepareHiddenOSCreation (int ea, int mode, int pkcs5);

void ProbeRealSystemDriveSize ();

void ReadBootSectorConfig (byte *config, size_t bufLength, byte *userConfig = nullptr, string *customUserMessage = nullptr, uint16 *bootLoaderVersion = nullptr);

uint32 ReadDriverConfigurationFlags ();

bool SystemPartitionCoversWholeDrive ();

bool SystemDriveIsDynamic ();

bool VerifyRescueDisk ();

void WipeHiddenOSCreationConfig ();

void WriteBootDriveSector (uint64 offset, byte *data);

void WriteBootSectorConfig (const byte newConfig[]);

void WriteBootSectorUserConfig (byte userConfig, const string &customUserMessage);

protected:

static const uint32 RescueIsoImageSize = 1835008; // Size of ISO9660 image with bootable emulated 1.44MB floppy disk image

void BackupSystemLoader ();

void CreateBootLoaderInMemory (byte *buffer, size_t bufferSize, bool rescueDisk, bool hiddenOSCreation = false);

void CreateVolumeHeader (uint64 volumeSize, uint64 encryptedAreaStart, Password *password, int ea, int mode, int pkcs5, int pim);

uint32 GetChecksum (byte *data, size_t size);

DISK_GEOMETRY GetDriveGeometry (int driveNumber);

PartitionList GetDrivePartitions (int driveNumber);

wstring GetRemarksOnHiddenOS ();

void RegisterFilter (bool registerFilter, FilterType filterType, const GUID *deviceClassGuid = nullptr);

void RestoreSystemLoader ();

void InstallVolumeHeader ();

#define MIN_HIDDENOS_DECOY_PARTITION_SIZE_RATIO_NTFS 2.1

#define MIN_HIDDENOS_DECOY_PARTITION_SIZE_RATIO_FAT 1.05

#endif // TC_HEADER_Common_BootEncryption

{

case WM_INITDIALOG:

{

argumentspec *as;

int i;

*tmp = 0;

#ifdef _WIN64

#else

#endif

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

#endif

for (i = 0; i < as->arg_cnt; i ++)

{

if (!as->args[i].Internal)

{

}

}

TCfree(tmp);

return 1;

return 0;

}

{

int argumentCount;

int i;

return 0;

}

if (!*lpszArgs)

AbortProcess ("OUTOFMEMORY");

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

{

if (!arg)

AbortProcess ("OUTOFMEMORY");

(*lpszArgs)[i] = arg;

}

return argumentCount;

}

{

return 1;

return 0;

}

{

int i;

for (i = 0; i < as->arg_cnt; i++)

{

{

return as->args[i].Id;

}

if (as->args[i].short_name[0] == 0)

continue;

{

return as->args[i].Id;

}

return -1;

}

{

*lpszValue = 0;

{

/* Handles the case of space between parameter code

and value */

lpszValue[nValueSize - 1] = 0;

(*nArgIdx)++;

return HAS_ARGUMENT;

typedef struct argument_t

{

int Id;

BOOL Internal;

} argument;

} argumentspec;

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

#ifdef __cplusplus

}

#define SIZEOF_MRU_LIST 20

{

LPARAM nIndex;

LPARAM MoveEditToCombo (HWND hComboBox, BOOL saveHistory)

{

if (!saveHistory)

{

SendMessage (hComboBox, CB_RESETCONTENT, 0, 0);

SetWindowText (hComboBox, szTmp);

return 0;

}

{

LPARAM nIndex = SendMessage (hComboBox, CB_FINDSTRINGEXACT, (WPARAM) - 1,

(LPARAM) & szTmp[0]);

i = 0;

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

{

if (i < count)

{

SendMessage (hComboBox, CB_GETLBTEXT, nComboIdx[i], (LPARAM) & szTmp[0]);

}

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

if (!bOnlyCheckModified)

*pbModified = TRUE;

xml++;

return;

}

if (f == NULL) return;

XmlWriteHeader (f);

/* combo list part:- get mru items */

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

/* combo list part:- write out mru items */

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

{

SendMessage (hComboBox, CB_GETLBTEXT, nComboIdx[i], (LPARAM) & szTmp[0]);

if (szTmp[0] != 0)

{

}

}

XmlWriteFooter (f);

fclose (f);

}

extern "C" {

#endif

LPARAM MoveEditToCombo (HWND hComboBox, BOOL saveHistory);

int GetOrderComboIdx ( HWND hComboBox , int *nIdxList , int nElems );

LPARAM UpdateComboOrder ( HWND hComboBox );

{

// Block Size Key Size Key Schedule Size

// ID Name (Bytes) (Bytes) (Bytes)

{ AES, "AES", 16, 32, AES_KS },

{ SERPENT, "Serpent", 16, 32, 140*4 },

{ TWOFISH, "Twofish", 16, 32, TWOFISH_KS },

{ 0, 0, 0, 0, 0 }

};

};

// Hash algorithms

static Hash Hashes[] =

{ // ID Name Deprecated System Encryption

{ 0, 0, 0 }

};

/* Return values: 0 = success, ERR_CIPHER_INIT_FAILURE (fatal), ERR_CIPHER_INIT_WEAK_KEY (non-fatal) */

int CipherInit (int cipher, unsigned char *key, unsigned __int8 *ks)

}

#ifndef TC_WINDOWS_BOOT

{

Cipher* pCipher = CipherGet (cipherId);

}

int CipherGetBlockSize (int cipherId)

{

return TRUE;

}

{

if (i = EAGetPreviousCipher(ea, i))

{

}

}

// Returns name of EA, cascaded cipher names are separated by hyphens

{

if (guiDisplay)

{

else

{

int i = EAGetLastCipher(ea);

while (i = EAGetPreviousCipher(ea, i))

{

}

}

return buf;

}

{

int ea = EAGetFirst ();

do

{

EAGetName (n, ea, 1);

return ea;

}

while (ea = EAGetNext (ea));

#ifndef TC_WINDOWS_BOOT

// Returns the name of the mode of operation of the whole EA

{

switch (mode)

{

case XTS:

}

}

#endif // TC_WINDOWS_BOOT

return FALSE;

}

Hash *HashGet (int id)

{

int i;

}

{

int i;

for (i = 0; Hashes[i].Id != 0; i++)

return Hashes[i].Id;

return 0;

}

{

Hash* pHash = HashGet(hashId);

}

{

Hash* pHash = HashGet(hashId);

if (pHash)

else

}

BOOL HashIsDeprecated (int hashId)

typedef struct

{

int Id; // Cipher ID

char *Name; // Name

int BlockSize; // Block size (bytes)

int KeySize; // Key size (bytes)

int KeyScheduleSize; // Scheduled key size (bytes)

int FormatEnabled;

} EncryptionAlgorithm;

typedef struct

{

int Id; // Hash ID

BOOL Deprecated;

BOOL SystemEncryption; // Available for system encryption

} Hash;

// Maxium length of scheduled key

#if !defined (TC_WINDOWS_BOOT) || defined (TC_WINDOWS_BOOT_AES)

BOOL CipherSupportsIntraDataUnitParallelization (int cipher);

#ifndef TC_WINDOWS_BOOT

#endif

int CipherInit (int cipher, unsigned char *key, unsigned char *ks);

#ifndef TC_WINDOWS_BOOT_SINGLE_CIPHER_MODE

int EAGetFirst ();

int EAGetCount (void);

int EAGetNext (int previousEA);

int EAGetKeySize (int ea);

int EAGetFirstMode (int ea);

int EAGetNextMode (int ea, int previousModeId);

int EAGetKeyScheduleSize (int ea);

int EAGetLargestKey ();

int EAGetLargestKeyForMode (int mode);

#ifndef TC_WINDOWS_BOOT

Hash *HashGet (int id);

BOOL HashIsDeprecated (int hashId);

BOOL HashForSystemEncryption (int hashId);

int GetMaxPkcs5OutSize (void);

LONG DriverVersion;

char *LastDialogId;

HFONT hFixedDigitFont = NULL;

HFONT hBoldFont = NULL;

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

char bCachedSysDevicePathsValid = FALSE;

BOOL bHyperLinkBeingTracked = FALSE;

typedef struct

{

int id;

unsigned __int64 encSpeed;

unsigned __int64 decSpeed;

unsigned __int64 meanBytesPerSec;

}

{

lpszDest[i - 1] = 0;

while (--i > 0)

{

}

}

{

if (lpszDest && cbDest)

{

if (i >= cbDest)

i = cbDest - 1;

i++;

while (--i > 0)

{

}

}

}

return u;

}

{

size_t out_size;

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

return 0;

// Trim leading space

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

{

}

// Trim trailing space

end++;

// Set output size to trimmed string length

out_size = (end - ptr);

// Copy trimmed string and add null terminator

str[out_size] = 0;

return out_size;

}

// check the validity of a file name

{

int i;

BOOL bNotDotOnly = FALSE;

while ((c = *str))

{

bNotDotOnly = TRUE;

if (c == invalidChars[i])

return FALSE;

str++;

return bNotDotOnly;

}

{

}

{

UpperCaseCopy (lpszDiskFile, cbDiskFile, lpszFileName);

*bDevice = FALSE;

{

*bDevice = TRUE;

}

#if _DEBUG

OutputDebugString (lpszDiskFile);

#endif

}

{

BOOL bDosLinkCreated = TRUE;

if (bNameOnly == FALSE)

bDosLinkCreated = DefineDosDevice (DDD_RAW_TARGET_PATH, lpszDosDevice, lpszDiskFile);

if (bDosLinkCreated == FALSE)

return ERR_OS_ERROR;

else

return 0;

}

{

BOOL bDosLinkRemoved = DefineDosDevice (DDD_RAW_TARGET_PATH | DDD_EXACT_MATCH_ON_REMOVE |

DDD_REMOVE_DEFINITION, lpszDosDevice, lpszDiskFile);

}

{

RECT rect;

rect.left = 0;

HDC hdc = GetDC (hwnd);

SelectObject (hdc, (HGDIOBJ) hFont);

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

newPath = pathBuf;

{

case WM_INITDIALOG:

{

RECT rec;

LocalizeDialog (hwndDlg, "IDD_ABOUT_DLG");

// Hyperlink

ToHyperlink (hwndDlg, IDC_HOMEPAGE);

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

// Version

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

#ifdef _WIN64

#else

#endif

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

#endif

SetDlgItemText (hwndDlg, IDT_ABOUT_VERSION, szTmp);

SetDlgItemText (hwndDlg, IDT_ABOUT_RELEASE, TC_STR_RELEASED_BY);

case WM_APP:

SetWindowText (GetDlgItem (hwndDlg, IDC_ABOUT_CREDITS),

return 1;

}

{

int i;

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

szTmp [i] = szTmp [i-(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)

if (!aboutMenuAppended)

{

hMenu = GetSystemMenu (hwndDlg, FALSE);

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

aboutMenuAppended = TRUE;

}

{

HBITMAP picture = LoadBitmap (hInstance, resource);

HDC viewDC = GetDC (hwnd), dcMem;

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

{

LRESULT lResult = 0;

}

}

{

{

*bIsPartition = TRUE;

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

}

{

*bIsPartition = TRUE;

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

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

{

if (*hMutex != NULL)

return TRUE; // This instance already has the mutex

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

{

if (name[0] == 0)

return FALSE;

{

DWORD configMap;

configMap = 0;

return configMap;

{

DWORD count;

count = 0;

return count;

void RemoveNonSysInPlaceEncNotifications (void)

{

if (FileExists (GetConfigPath (TC_APPD_FILENAME_NONSYS_INPLACE_ENC)))

if (FileExists (GetConfigPath (TC_APPD_FILENAME_NONSYS_INPLACE_ENC_WIPE)))

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

}

switch (command)

{

case TC_POST_INSTALL_CFG_REMOVE_ALL:

break;

case TC_POST_INSTALL_CFG_TUTORIAL:

break;

case TC_POST_INSTALL_CFG_RELEASE_NOTES:

break;

default:

if (f == NULL)

return;

{

// Error

fclose (f);

OSVERSIONINFOEX osEx;

osEx.dwOSVersionInfoSize = sizeof (OSVERSIONINFOEX);

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

nCurrentOS = WIN_SERVER_2003;

OSVERSIONINFOEX osEx;

osEx.dwOSVersionInfoSize = sizeof (OSVERSIONINFOEX);

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

nCurrentOS = WIN_SERVER_2008;

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

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

{

WNDCLASSW wc;

char langId[6];

/* Save the instance handle for later */

hInst = hInstance;

#ifndef SETUP

// Application ID

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

if (setAppId)

setAppId (TC_APPLICATION_ID);

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

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

{

WNDCLASSEXW wcex;

HWND hWnd;

{

Error ("UAC_INIT_ERROR", NULL);

exit (1);

SetLayeredWindowAttributes (hWnd, 0, 0, LWA_ALPHA);

ShowWindow (hWnd, SW_SHOWNORMAL);

exit (1);

Sleep (2000);

// Service pack check & warnings about critical MS issues

osEx.dwOSVersionInfoSize = sizeof (OSVERSIONINFOEX);

{

CurrentOSServicePack = osEx.wServicePackMajor;

switch (nCurrentOS)

DWORD val = 0, size = sizeof(val);

HKEY hkey;

{

|| val != 1)

{

Warning ("LARGE_IDE_WARNING_2K_REGISTRY", NULL);

{

HKEY k;

// PE environment does not report version of SP

Warning ("LARGE_IDE_WARNING_XP", NULL);

else

RegCloseKey (k);

}

if (GetSystemDirectory(dllPath, MAX_PATH))

else

// Required for RichEdit text fields to work

if ((hRichEditDll = LoadLibrary(dllPath)) == NULL)

{

void InitHelpFileName (void)

{

if (lpszTmp)

{

++lpszTmp;

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

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

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

{

}

else

{

}

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

if (lpszTmp)

{

++lpszTmp;

*lpszTmp = 0;

}

}

}

{

DWORD dwResult;

BOOL bResult;

wchar_t wszFileName[TC_MAX_PATH];

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

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

BOOL GetSysDevicePaths (HWND hwndDlg)

{

if (!bCachedSysDevicePathsValid

{

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

{

if (device.ContainsSystem)

}

if (IsOSAtLeast (WIN_7))

}

return (bCachedSysDevicePathsValid

}

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

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

{

if (!bCachedSysDevicePathsValid

&& bReliableRequired)

return -1;

}

return -1;

if (!path)

return -1;

return 1;

return 2;

else if (ExtraBootPartitionDevicePath == path)

return 3;

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

if (!GetSysDevicePaths (MainDlg))

return -1;

return -1;

{

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

return 0;

}

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

if (pos < 0)

return -1;

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

return -1;

tmpPath [pos + 1] = 0;

{

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

return 1;

switch (nID)

{

case TC_TBXID_SYS_ENCRYPTION_PRETEST:

break;

case TC_TBXID_SYS_ENC_RESCUE_DISK:

break;

case TC_TBXID_DECOY_OS_INSTRUCTIONS:

break;

case TC_TBXID_EXTRA_BOOT_PARTITION_REMOVAL_INSTRUCTIONS:

break;

}

return 1;

r = GetLegalNotices ();

if (r != NULL)

{

free (r);

}

break;

char *buf = NULL;

if (resource == NULL)

if (resource != NULL)

{

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

{

static vector <HostDevice> devices;

static map <int, HostDevice> itemToDeviceMap;

if (device.ContainsSystem)

{

if (device.IsPartition)

else

}

// Path

if (line > 1)

{

item.iItem = line++;

}

if (device.Floppy || device.DynamicVolume)

{

}

else

{

if (!device.Partitions.empty())

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

}

}

else

{

}

itemToDeviceMap[item.iItem] = device;

{

wchar_t size[100] = { 0 };

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

}

// Mount point

if (!device.MountPoint.empty())

// Label

if (!device.Name.empty())

#ifdef TCMOUNT

else

{

bool useInExplorer = false;

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

if (!favoriteLabel.empty())

}

#endif

return 1; // non-device line selected

const HostDevice selectedDevice = itemToDeviceMap[selectedItem];

#ifdef VOLFORMAT

if (selectedDevice.ContainsSystem && selectedDevice.IsPartition)

StatusMessage (hwndDlg, "INSTALLING_DRIVER");

#endif

SERVICE_ALL_ACCESS, SERVICE_KERNEL_DRIVER, SERVICE_SYSTEM_START, SERVICE_ERROR_NORMAL,

NULL, NULL, NULL, NULL, NULL);

if (hService == NULL)

else

CloseServiceHandle (hService);

if (hService == NULL)

goto error;

HANDLE file;

WIN32_FIND_DATA find;

SC_HANDLE hManager, hService = NULL;

BOOL res;

DWORD startType;

return ERR_PARAMETER_INCORRECT;

if (!tmp)

{

driverPath[1] = 0;

}

else

*tmp = 0;

file = FindFirstFile (driverPath, &find);

return ERR_OS_ERROR;

}

if (hService != NULL)

{

// Remove stale service (driver is not loaded but service exists)

Sleep (500);

}

SERVICE_ALL_ACCESS, SERVICE_KERNEL_DRIVER, SERVICE_DEMAND_START, SERVICE_ERROR_NORMAL,

driverPath, NULL, NULL, NULL, NULL, NULL);

if (hManager == NULL)

goto error;

if (hService == NULL)

goto error;

void ResetCurrentDirectory ()

{

if (!IsNonInstallMode () && SHGetFolderPath (NULL, CSIDL_PROFILE, NULL, 0, p) == ERROR_SUCCESS)

{

SetCurrentDirectory (p);

}

else

{

SetCurrentDirectory (p);

}

}

{

return BrowseFilesInDir (hwndDlg, stringId, NULL, lpszFileName, keepHistory, saveMode, browseFilter);

}

{

OPENFILENAMEW ofn;

wchar_t file[TC_MAX_PATH] = { 0 };

wchar_t filter[1024];

BOOL status = FALSE;

if (initialDir)

{

}

if (initialFileName)

ofn.lStructSize = sizeof (ofn);

ofn.hwndOwner = hwndDlg;

SystemFileSelectorCallPending = FALSE;

if (!keepHistory)

CleanLastVisitedMRU ();

}

static int SelectMultipleFilesOffset;

{

OPENFILENAMEW ofn;

wchar_t filter[1024];

BOOL status = FALSE;

GetString ("ALL_FILES"), 0, 0, GetString ("TC_VOLUMES"), 0, 0, 0);

ofn.lpstrFilter = filter;

ofn.nFilterIndex = 1;

ofn.lpstrTitle = GetString (stringId);

ofn.Flags = OFN_HIDEREADONLY

| OFN_EXPLORER

SystemFileSelectorCallPending = FALSE;

{

// Single file selected

SelectMultipleFilesOffset = 0;

}

else

{

// Multiple files selected

SelectMultipleFilesOffset = ofn.nFileOffset;

SelectMultipleFilesNext (lpszFileName, cbFileName);

}

}

{

if (SelectMultipleFilesOffset == 0)

return FALSE;

lpszFileName[TC_MAX_PATH - 1] = 0;

if (SelectMultipleFilesPath[SelectMultipleFilesOffset] == 0)

SelectMultipleFilesOffset = 0;

{

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

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

break;

}

case BFFM_SELCHANGED:

{

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

if (SHGetPathFromIDList((LPITEMIDLIST) lp ,szDir))

}

{

BROWSEINFOW bi;

LPITEMIDLIST pidl;

StringCbCatW (szTmp, sizeof(szTmp), GetString ("PASSWORD_WRONG_CAPSLOCK_ON"));

#ifdef TCMOUNT

if (TCBootLoaderOnInactiveSysEncDrive (szDevicePath))

{

}

{

if (ferror (file))

{

void OpenVolumeExplorerWindow (int driveNo)

{

SHFILEINFO fInfo;

// Force explorer to discover the drive

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

}

static BOOL explorerCloseSent;

return (ERROR_SUCCESS == lStatus)? TRUE : FALSE;

}

{

versionString.erase (versionString.length()-1, 1);

return (versionString);

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

benchmarkTable[benchmarkTotalItems].id = thid;

benchmarkTotalItems++;

}

WORD hw = HIWORD (wParam);

static unsigned char randPool [RNG_POOL_SIZE];

static unsigned char lastRandPool [RNG_POOL_SIZE];

static BOOL bDisplayPoolContents = TRUE;

static BOOL bRandPoolDispAscii = FALSE;

int hash_algo = RandGetHashFunction();

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

{

if (!HashIsDeprecated (hid))

}

SelectAlgo (hComboBox, &hash_algo);

case WM_TIMER:

{

unsigned char tmpByte;

int col, row;

{

tmpByte = randPool[row * RANDPOOL_DISPLAY_COLUMNS + col];

}

}

SetWindowText (GetDlgItem (hwndDlg, IDC_POOL_CONTENTS), outputDispBuffer);

{

if (!(bDisplayPoolContents = GetCheckBox (hwndDlg, IDC_DISPLAY_POOL_CONTENTS)))

{

tmp [RNG_POOL_SIZE] = 0;

SetWindowText (GetDlgItem (hwndDlg, IDC_POOL_CONTENTS), tmp);

}

case WM_CLOSE:

{

exit:

KillTimer (hwndDlg, 0xfd);

burn (outputDispBuffer, sizeof(outputDispBuffer));

// Attempt to wipe the pool contents in the GUI text area

tmp [RNG_POOL_SIZE] = 0;

SetWindowText (GetDlgItem (hwndDlg, IDC_POOL_CONTENTS), tmp);

WORD hw = HIWORD (wParam);

static unsigned char randPool [RNG_POOL_SIZE];

static unsigned char lastRandPool [RNG_POOL_SIZE];

static BOOL bDisplayPoolContents = TRUE;

static BOOL bRandPoolDispAscii = FALSE;

int hash_algo = RandGetHashFunction();

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

{

if (!HashIsDeprecated (hid))

}

SelectAlgo (hComboBox, &hash_algo);

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

// maximum keyfile size is 1048576, so limit the edit control to 7 characters

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

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

{

unsigned char tmpByte;

int col, row;

{

tmpByte = randPool[row * RANDPOOL_DISPLAY_COLUMNS + col];

}

}

SetWindowText (GetDlgItem (hwndDlg, IDC_POOL_CONTENTS), outputDispBuffer);

{

if (!(bDisplayPoolContents = GetCheckBox (hwndDlg, IDC_DISPLAY_POOL_CONTENTS)))

{

tmp [RNG_POOL_SIZE] = 0;

SetWindowText (GetDlgItem (hwndDlg, IDC_POOL_CONTENTS), tmp);

}

if (lw == IDC_GENERATE_AND_SAVE_KEYFILE)

{

unsigned char *keyfile = NULL;

int fhKeyfile = -1, status;

long keyfilesCount = 0, keyfilesSize = 0, i;

BOOL bRandomSize = GetCheckBox (hwndDlg, IDC_KEYFILES_RANDOM_SIZE);

szNumber[0] = 0;

if (keyfilesCount <= 0 || keyfilesCount == LONG_MAX)

{

Warning("KEYFILE_INCORRECT_NUMBER", hwndDlg);

if (!bRandomSize)

{

szNumber[0] = 0;

if (keyfilesSize < 64 || keyfilesSize > 1024*1024)

{

Warning("KEYFILE_INCORRECT_SIZE", hwndDlg);

return 1;

}

/* Select directory */

if (!BrowseDirectories (hwndDlg, "SELECT_KEYFILE_GENERATION_DIRECTORY", szDirName))

return 1;

WaitCursor();

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

{

if (i > 0)

{

// Append the counter to the name

if (fileExtensionPtr)

{

StringCbCat(szFileName, sizeof(szFileName), szSuffix);

StringCbCat(szFileName, sizeof(szFileName), fileExtensionPtr);

}

StringCbCat(szFileName, sizeof(szFileName), szFileBaseName);

// check if the file exists

{

WCHAR s[4*TC_MAX_PATH] = {0};

_close (fhKeyfile);

status = AskWarnNoYesString (s, hwndDlg);

if (status == IDNO)

{

}

/* Conceive the file */

{

TCfree(keyfile);

NormalCursor();

case WM_CLOSE:

{

exit:

WaitCursor();

KillTimer (hwndDlg, 0xfd);

burn (outputDispBuffer, sizeof(outputDispBuffer));

// Attempt to wipe the pool contents in the GUI text area

tmp [RNG_POOL_SIZE] = 0;

SetWindowText (GetDlgItem (hwndDlg, IDC_POOL_CONTENTS), tmp);

case WM_INITDIALOG:

{

int ea;

LocalizeDialog (hwndDlg, "IDD_CIPHER_TEST_DLG");

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

{

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

}

ResetCipherTest(hwndDlg, idTestCipher);

if (lw == IDOK || lw == IDC_ENCRYPT || lw == IDC_DECRYPT)

{

int ks, pt, n, tlen, blockNo = 0;

BOOL bEncrypt;

memset(key,0,sizeof(key));

memset(szTmp,0,sizeof(szTmp));

if (n != ks * 2)

{

Warning ("TEST_KEY_SIZE", hwndDlg);

for (n = 0; n < ks; n ++)

{

long x;

szTmp2[2] = 0;

szTmp2[0] = szTmp[n * 2];

szTmp2[1] = szTmp[n * 2 + 1];

key[n] = (char) x;

}

if (bEncrypt)

{

}

else

{

}

if (n != pt * 2)

for (n = 0; n < pt; n ++)

{

long x;

szTmp2[2] = 0;

szTmp2[0] = szTmp[n * 2];

szTmp2[1] = szTmp[n * 2 + 1];

inputtext[n] = (char) x;

}

{

// Secondary key

{

Warning ("TEST_INCORRECT_SECONDARY_KEY_SIZE", hwndDlg);

return 1;

for (n = 0; n < 64; n ++)

{

long x;

szTmp2[2] = 0;

szTmp2[0] = szTmp[n * 2];

szTmp2[1] = szTmp[n * 2 + 1];

secondaryKey[n] = (char) x;

}

// Data unit number

if (tlen > 16 || tlen < 1)

{

return 1;

}

for (n = 0; n < 16; n ++)

{

long x;

szTmp2[2] = 0;

szTmp2[0] = szTmp[n * 2];

szTmp2[1] = szTmp[n * 2 + 1];

dataUnitNo[n] = (char) x;

}

for (n = 0; n < pt; n ++)

{

}

if (bEncrypt)

SendMessage(GetDlgItem(hwndDlg, IDC_TEST_BLOCK_NUMBER), CB_SETCURSEL, 0, 0);

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

{

SendMessage(GetDlgItem(hwndDlg, IDC_KEY_SIZE), CB_SETITEMDATA, ndx,(LPARAM) 32);

SendMessage(GetDlgItem(hwndDlg, IDC_KEY_SIZE), CB_SETCURSEL, ndx,0);

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

SendMessage(GetDlgItem(hwndDlg, IDC_PLAINTEXT_SIZE), CB_SETITEMDATA, ndx,(LPARAM) 16);

SendMessage(GetDlgItem(hwndDlg, IDC_PLAINTEXT_SIZE), CB_SETCURSEL, ndx,0);

}

}

// Checks whether the file extension is not used for executable files or similarly problematic, which often

// causes Windows and antivirus software to interfere with the container.

{

int i = 0;

// These are protected by the Windows Resource Protection

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

if (!ext)

return FALSE;

while (problemFileExt[i])

{

return TRUE;

}

return FALSE;

}

{

/* replace '/' by '\' */

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

{

}

}

}

{

BOOL bResult = FALSE;

DWORD dwResult;

wchar_t msg[4096];

VolumeNotificationsList.bHidVolDamagePrevReported [nDosDriveNo] = TRUE;

SetForegroundWindow (hwndDlg);

MessageBoxW (hwndDlg, msg, lpszTitle, MB_ICONWARNING | MB_SETFOREGROUND | MB_TOPMOST);

}

{

if (driveMap & (1 << i))

{

SHChangeNotify (eventId, SHCNF_PATH, root, NULL);

}

}

}

// implementation of the generic wait dialog mechanism

typedef struct

{

int MountVolume (HWND hwndDlg,

int driveNo,

Password *password,

int pkcs5,

int pim,

MOUNT_STRUCT mount;

DWORD dwResult, dwLastError = ERROR_SUCCESS;

BOOL bResult, bDevice;

int favoriteMountOnArrivalRetryCount = 0;

#ifdef TCMOUNT

if (CurrentOSMajor == 5 && CurrentOSMinor == 0)

mount.bMountManager = FALSE;

{

// Remove \\?\ prefix

path = path.substr (4);

}

{

if (!resolvedPath.empty())

}

if (!bDevice)

{

// UNC path

{

}

{

DWORD bps, flags, d;

if (GetDiskFreeSpace (root, &d, &bps, &d, &d))

if (IsOSAtLeast (WIN_VISTA))

{

)

{

HANDLE dev = INVALID_HANDLE_VALUE;

VOLUME_DISK_EXTENTS extents = {0};

DWORD dwResult = 0;

}

}

if (mountOptions->PartitionInInactiveSysEncScope)

{

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

{

int driveNo;

{

OPEN_TEST_STRUCT openTestStruct;

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

if (mount.VolumeMountedReadOnlyAfterDeviceWriteProtected

&& !Silent

{

wchar_t msg[1024];

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

WarningDirect (msg, hwndDlg);

if (CurrentOSMajor >= 6

&& AskNoYes ("ASK_REMOVE_DEVICE_WRITE_PROTECTION", hwndDlg) == IDYES)

{

RemoveDeviceWriteProtection (hwndDlg, volumePath);

if (IsOSAtLeast (WIN_7))

{

// Undo SHCNE_DRIVEREMOVED

SHChangeNotify (SHCNE_DRIVEADD, SHCNF_PATH, root, NULL);

}

}

{

MOUNT_LIST_STRUCT mlist;

DWORD dwResult;

int i;

if (!resolvedPath.empty())

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

DeviceIoControl (hDriver, TC_IOCTL_GET_MOUNTED_VOLUMES, &mlist,

NULL);

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

return TRUE;

return FALSE;

}

{

MOUNT_LIST_STRUCT mlist;

DWORD dwResult;

int i;

if (volname == NULL)

return -1;

if (!resolvedPath.empty())

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

DeviceIoControl (hDriver, TC_IOCTL_GET_MOUNTED_VOLUMES, &mlist,

if (!IsOSAtLeast (WIN_VISTA))

return FALSE;

{

value = 1;

RegCloseKey (hkey);

}

{

BOOL bResult;

DWORD dwResult;

DISK_PARTITION_INFO_STRUCT dpi;

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

bResult = DeviceIoControl (hDriver, TC_IOCTL_GET_DRIVE_PARTITION_INFO, &dpi,

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

}

{

DWORD dwResult;

memset (info, 0, sizeof(*info));

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

}

{

BOOL bResult;

DWORD dwResult;

DISK_GEOMETRY_STRUCT dg;

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

bResult = DeviceIoControl (hDriver, TC_IOCTL_GET_DRIVE_GEOMETRY, &dg,

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

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

{

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

StringCchCatW (link, MAX_PATH, drive);

// WARNING: This function does NOT provide 100% reliable results -- do NOT use it for critical/dangerous operations!

// Return values: 0 - filesystem does not appear empty, 1 - filesystem appears empty, -1 - an error occurred

{

float percentFreeSpace = 0.0;

__int64 occupiedBytes = 0;

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

// 'percent' pointer is not NULL, % of free space is stored in the pointed location. If there's an error,

// returns -1.

{

WCHAR devPath [MAX_PATH];

int driveLetterNo = -1;

ULARGE_INTEGER freeSpaceSize;

ULARGE_INTEGER totalNumberOfBytes;

ULARGE_INTEGER totalNumberOfFreeBytes;

driveLetterNo = GetDiskDeviceDriveLetter (devPath);

if (!GetDiskFreeSpaceEx (szRootPath, &freeSpaceSize, &totalNumberOfBytes, &totalNumberOfFreeBytes))

// Returns -1 if there's an error.

{

PARTITION_INFORMATION partitionInfo;

}

{

DWORD dwResult;

HANDLE hVolume;

int driveLetterNo = -1;

WCHAR devPath [MAX_PATH];

driveLetterNo = GetDiskDeviceDriveLetter (devPath);

}

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

{

// Strip quotation marks (if any)

{

}

else

{

}

// Strip quotation marks (if any)

}

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

{

int bufSize = 64 * BYTES_PER_KB;

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

return res != 0;

}

{

HANDLE src, dst;

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

{

HANDLE dst;

DWORD bytesWritten;

dwLastError = GetLastError();

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

{

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

if (MoveFileEx (destinationFile, renamedPath, MOVEFILE_REPLACE_EXISTING))

CloseHandle (dst);

if (!res && !bAppend)

return res;

}

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

// textByteLen - length of the text in bytes

// title - printed as part of the page header and used as the filename for a temporary file

{

//strcat (filename, ".txt");

if (!FileExists (path))

{

return FALSE;

}

else

{

}

// Write the Unicode signature

if (!SaveBufferToFile ("\xFF\xFE", path, 2, FALSE, FALSE))

{

return FALSE;

}

// Write the actual text

if (!SaveBufferToFile ((char *) text, path, (DWORD) textByteLen, TRUE, FALSE))

{

return FALSE;

}

// Get the absolute path for notepad

if (GetWindowsDirectory(filename, MAX_PATH))

{

}

else

WaitCursor ();

Sleep (6000);

NormalCursor();

return TRUE;

}

{

// The driver was not found in the system path

// We can't use GetConfigPath() here because it would call us back (indirect recursion)

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

{

if (FileExists (path))

{

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

// Configuration" from the Windows boot menu).

{

RegCloseKey (hkey);

return FALSE;

{

if (!IsNonInstallMode ())

{

GetStartupRegKeyName (regk, sizeof(regk));

if (bStartOnLogon || bMountDevicesOnLogon || bMountFavoritesOnLogon)

{

#ifdef VOLFORMAT

{

{

*tmp = 0;

}

}

#endif

}

else

}

}

// Adds or removes the VeraCrypt Volume Creation Wizard to/from the system startup sequence

{

GetStartupRegKeyName (regk, sizeof(regk));

if (!bRemove)

{

GetModuleFileName (NULL, exe + 1, (DWORD) (exeSize - 1));

#ifndef VOLFORMAT

{

{

*tmp = 0;

}

}

#endif

{

}

free(exe);

}

else

}

WCHAR *strToMatch;

WCHAR strTmp[4096];

int id, len;

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

{

*strTmp = 0;

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

{

int *pout = (int *)bufout;

int l;

while (l > 0)

{

l -= sizeof (int);

*pout++ = *p++;

}

}

else

{

while (*p)

{

if (*p == id)

}

*pout++ = 0;

}

break;

#endif // #ifndef SETUP

{

LVITEM li;

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

li.mask = LVIF_TEXT;

li.iItem = index;

li.iSubItem = 0;

return ListView_InsertItem (list, &li);

}

{

LVITEM li;

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

li.mask = LVIF_TEXT;

li.iItem = index;

li.iSubItem = subIndex;

return ListView_SetItem (list, &li);

}

BOOL GetMountList (MOUNT_LIST_STRUCT *list)

{

DWORD dwResult;

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

{

DWORD bufSize = sizeof(__int32);

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

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

{

DWORD bufSize = sizeof(__int16);

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

}

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

{

char *buf;

DWORD fileSize = INVALID_FILE_SIZE;

// Returns NULL if there's any error.

{

char *buf;

DWORD bytesRead = 0;

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

{

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

LARGE_INTEGER size;

}

{

GetModuleFileName (NULL, path, maxSize);

if (ptr)

ptr[1] = 0;

return path;

}

{

if (IsNonInstallMode ())

{

return path;

}

if (SUCCEEDED(SHGetFolderPath (NULL, CSIDL_APPDATA | CSIDL_FLAG_CREATE, NULL, 0, path)))

{

CreateDirectory (path, NULL);

}

else

path[0] = 0;

}

{

if (SUCCEEDED (SHGetFolderPath (NULL, CSIDL_COMMON_APPDATA | CSIDL_FLAG_CREATE, NULL, 0, path)))

{

CreateDirectory (path, NULL);

}

else

path[0] = 0;

}

{

if (Is64BitOs() && useLegacy)

{

}

else

}

// Returns 0 if an error occurs or the drive letter (as an upper-case char) of the system partition (e.g. 'C');

{

else

return 0;

}

if (ConfigBuffer == NULL)

ConfigBuffer = LoadFile (GetConfigPath (TC_APPD_FILENAME_CONFIGURATION), &size);

if (ConfigFileHandle == NULL)

{

free (ConfigBuffer);

return FALSE;

}

XmlWriteHeader (ConfigFileHandle);

return TRUE;

}

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

XmlGetNodeText (xml, value, sizeof (value));

xml++;

}

XmlWriteFooter (ConfigFileHandle);

TCFlushFile (ConfigFileHandle);

c[1] = '!';

}

configKey, configValue);

}

BOOL ConfigWriteInt (char *configKey, int configValue)

{

void OpenPageHelp (HWND hwndDlg, int nPage)

{

if (r == ERROR_FILE_NOT_FOUND)

{

// Try the secondary help file

if (r == ERROR_FILE_NOT_FOUND)

{

kf = (KeyFile *) malloc (sizeof (KeyFile));

if (kf)

{

defaultKeyFilesParam.FirstKeyFile = KeyFileAdd (defaultKeyFilesParam.FirstKeyFile, kf);

else

free (kf);

}

StringCbVPrintfA (buf, sizeof (buf), format, val);

va_end(val);

}

StringCbVPrintfA (buf, sizeof (buf), format, val);

va_end(val);

}

if (valid)

return isWow64;

if (fnIsWow64Process != NULL)

if (!fnIsWow64Process (GetCurrentProcess(), &isWow64))

BOOL EnableWow64FsRedirection (BOOL enable)

{

typedef BOOLEAN (__stdcall *Wow64EnableWow64FsRedirection_t) (BOOL enable);

if (!wow64EnableWow64FsRedirection)

return FALSE;

}

{

osVer.dwOSVersionInfoSize = sizeof (OSVERSIONINFOEXA);

BOOL home = (osVer.wSuiteMask & VER_SUITE_PERSONAL);

BOOL server = (osVer.wProductType == VER_NT_SERVER || osVer.wProductType == VER_NT_DOMAIN_CONTROLLER);

HKEY hkey;

DWORD productNameSize = sizeof (productName);

{

productName[0] = 0;

RegCloseKey (hkey);

switch (nCurrentOS)

{

case WIN_2000:

break;

case WIN_XP:

case WIN_XP64:

break;

case WIN_SERVER_2003:

break;

case WIN_VISTA:

break;

case WIN_SERVER_2008:

break;

case WIN_7:

break;

case WIN_SERVER_2008_R2:

break;

default:

osname += s.str();

break;

}

if (server)

if (IsOSAtLeast (WIN_VISTA))

{

if (home)

}

if (GetSystemMetrics (SM_STARTER))

if (Is64BitOs())

if (CurrentOSServicePack > 0)

{

osname += s.str();

}

{

StringCbCopyA (url, sizeof (url),TC_APPLINK);

}

Sleep (200);

NormalCursor ();

}

{

{

GetCurrentDirectory (MAX_PATH, path);

}

return szFileName;

HKEY hkey = 0;

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

0, KEY_READ, &hkey) != ERROR_SUCCESS)

return;

&& value != 0)

{

Warning ("SYS_AUTOMOUNT_DISABLED", hwnd);

LONG_PTR userDataVal = GetWindowLongPtrW (hwnd, GWLP_USERDATA);

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

{

{

PostMessage (hwnd, TC_APPMSG_CLOSE_BKG_TASK, 0, 0);

LONG_PTR userDataVal = GetWindowLongPtrW (hwnd, GWLP_USERDATA);

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

{

{

if (lParam != 0)

*((HWND *)lParam) = hwnd;

}

{

HGLOBAL hResL;

HRSRC hRes;

#ifndef SETUP

{

int status = ERR_PARAMETER_INCORRECT;

int volumeType;

char buffer[TC_VOLUME_HEADER_EFFECTIVE_SIZE];

LARGE_INTEGER headerOffset;

DWORD dwResult;

}

}

else

if (preserveTimestamps)

write = TRUE;

{

// GlobalMemoryStatusEx() cannot be used to determine if a paging file is active

DWORD size = sizeof (data);

if (IsPagingFileWildcardActive())

return TRUE;

return TRUE;

if (!IsAdmin())

AbortProcess ("UAC_INIT_ERROR");

{

// Query geometry of the drive first to prevent "no medium" pop-ups

drivePath[4] = drive;

if (checkNonWindowsPartitionsOnly)

{

continue;

}

CloseHandle (handle);

// Test if a paging file exists and is locked by another process

path[0] = drive;

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

BOOL IsPagingFileWildcardActive ()

{

DWORD size = sizeof (pagingFiles);

{

size = sizeof (pagingFiles);

size = 0;

}

}

BOOL DisablePagingFile ()

{

}

}

// Attempt to wipe password stored in the input field buffer

tmp[SecurityToken::MaxPasswordLength] = 0;

SetWindowText (GetDlgItem (hwndDlg, IDC_TOKEN_PASSWORD), tmp);

lvItem.mask = LVIF_TEXT;

lvItem.iItem = line++;

s << keyfile.SlotId;

}

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

case IDC_IMPORT_KEYFILE:

{

if (BrowseFiles (hwndDlg, "SELECT_KEYFILE", keyfilePath, bHistory, FALSE, NULL))

{

if (keyfileSize != 0)

{

NewSecurityTokenKeyfileDlgProcParams newParams;

size_t lastBackSlash = newParams.Name.find_last_of ('\\');

if (lastBackSlash != string::npos)

{

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

{

if (!BrowseFiles (hwndDlg, "OPEN_TITLE", keyfilePath, bHistory, TRUE, NULL))

break;

{

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

{

OPEN_TEST_STRUCT openTest = {0};

if (!OpenDevice (devPath, &openTest, detectUnencryptedFilesystems && partNumber != 0))

{

DISK_GEOMETRY geometry;

if (driveNumber >= 0)

{

wchar_t name[64];

if (GetDriveLabel (driveNumber, name, sizeof (name)))

device.Name = name;

device.ContainsSystem = true;

}

{

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

{

OPEN_TEST_STRUCT openTest = {0};

if (!OpenDevice (devPath, &openTest, detectUnencryptedFilesystems))

if (!noDeviceProperties)

{

if (driveNumber >= 0)

{

wchar_t name[64];

if (GetDriveLabel (driveNumber, name, sizeof (name)))

device.Name = name;

device.ContainsSystem = true;

}

}

}

{

DWORD attributes = GetFileAttributes (path);

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

}

{

return FALSE;

DWORD flags, d;

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

{

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

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

return;

StringCbPrintfW (msg, sizeof(msg), GetString (fixErrors ? "REPAIRING_FS" : "CHECKING_FS"), driveRoot);

if (GetSystemDirectoryW(cmdPath, MAX_PATH))

{

#endif // !SETUP

{

int driveNumber;

int partitionNumber;

return FALSE;

return FALSE;

if (!f)

{

handleWin32Error (hwndDlg, SRC_POS);

return FALSE;

}

CheckFileStreamWriteErrors (hwndDlg, f, cmdBatch);

fclose (f);

if (!f)

{

handleWin32Error (hwndDlg, SRC_POS);

return FALSE;

}

if (partitionNumber != 0)

CheckFileStreamWriteErrors (hwndDlg, f, diskpartScript);

fclose (f);

return TRUE;

}

}

{

OPEN_TEST_STRUCT openTest = {0};

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

return OpenDevice (volumePath, &openTest, FALSE);

{

if (QueryDosDevice (path.substr (4, path.size() - 5).c_str(), devicePath, TC_MAX_PATH) != 0)

return TRUE;

}

return TRUE;

else

{

BOOL IsWindowsIsoBurnerAvailable ()

{

if (!IsOSAtLeast (WIN_7))

{

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

{

return (FileExists (path));

}

}

{

int r;

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

else

if (r <= 32)

{

}

{

volumeGuidPath = volumeGuidPath.substr (4);

if (QueryDosDevice (volumeGuidPath.substr (0, volumeGuidPath.size() - 1).c_str(), volDevPath, TC_MAX_PATH) == 0)

return partitionPath.empty() ? volDevPath : partitionPath;

}

{

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

{

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

{

wchar_t partitionPath[TC_MAX_PATH];

wchar_t resolvedPath[TC_MAX_PATH];

if (ResolveSymbolicLink (partitionPath, resolvedPath, sizeof(resolvedPath)))

{

}

else if (partNumber == 0)

break;

}

}

}

{

BOOL installed = FALSE;

HKEY unistallKey;

LONG res = RegOpenKeyEx (HKEY_LOCAL_MACHINE, uninstallRegName, 0, KEY_READ | b32bitApp? KEY_WOW64_32KEY: KEY_WOW64_64KEY, &unistallKey);

return FALSE;

}

DWORD regNameSize = sizeof (regName);

DWORD index = 0;

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

{

{

regNameSize = sizeof (regName);

regName[0] = 0;

}

{

installed = TRUE;

break;

}

{

ULARGE_INTEGER latestTime;

latestTime.QuadPart = 0;

WIN32_FIND_DATA findData;

if (find != INVALID_HANDLE_VALUE)

{

do

{

continue;

ULARGE_INTEGER writeTime;

if (name.empty())

return name;

}

int GetPim (HWND hwndDlg, UINT ctrlId)

HWND hCtrl = GetDlgItem (hwndDlg, ctrlId);

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

{

if (GetDlgItemText (hwndDlg, ctrlId, szTmp, MAX_PIM + 1) > 0)

{

pim = 0;

}

}

{

if (pim > 0)

{

SetDlgItemText (hwndDlg, ctrlId, szTmp);

}

else

}

void HandleShowPasswordFieldAction (HWND hwndDlg, UINT checkBoxId, UINT edit1Id, UINT edit2Id)

#define TC_APPLICATION_ID L"IDRIX.VeraCrypt"

#define IDC_ABOUT 0x7fff /* ID for AboutBox on system menu in wm_user range */

#define MAX_MULTI_CHOICES 10 /* Maximum number of options for mutliple-choice dialog */

#ifndef USER_DEFAULT_SCREEN_DPI

#define USER_DEFAULT_SCREEN_DPI 96

extern char *LastDialogId;

extern char *ConfigBuffer;

extern HFONT hFixedDigitFont;

extern HFONT hBoldFont;

extern HFONT hTitleFont;

extern BOOL bSysPartitionSelected;

extern BOOL bSysDriveSelected;

extern char bCachedSysDevicePathsValid;

extern BOOL bHyperLinkBeingTracked;

#define ICON_HAND MB_ICONHAND

#define YES_NO MB_YESNO

void cleanup ( void );

void AbortProcessDirect ( wchar_t *abortMsg );

void AbortProcess ( char *stringId );

void AbortProcessSilent ( void );

void CloseStaticModelessWaitDlg (void);

BOOL IsButtonChecked ( HWND hButton );

void CheckButton ( HWND hButton );

void InitDialog ( HWND hwndDlg );

void ProcessPaintMessages (HWND hwnd, int maxMessagesToProcess);

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

BOOL RegisterRedTick ( HINSTANCE hInstance );

BOOL UnregisterRedTick ( HINSTANCE hInstance );

void SelectAlgo ( HWND hComboBox , int *nCipher );

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

wchar_t *GetWipeModeName (WipeAlgorithmId modeId);

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

void TCCloseMutex (volatile HANDLE *hMutex);

BOOL CreateSysEncMutex (void);

BOOL InstanceHasSysEncMutex (void);

void CloseSysEncMutex (void);

void SavePostInstallTasksSettings (int command);

void DoPostInstallTasks (HWND hwndDlg);

void InitOSVersionInfo ();

void FinalizeApp (void);

void InitHelpFileName (void);

void NotifyDriverOfPortableMode (void);

int GetAvailableFixedDisks ( HWND hComboBox , char *lpszRootPath );

int GetAvailableRemovables ( HWND hComboBox , char *lpszRootPath );

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

INT_PTR TextInfoDialogBox (int nID);

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

BOOL CALLBACK CipherTestDialogProc ( HWND hwndDlg , UINT uMsg , WPARAM wParam , LPARAM lParam );

void ResetCipherTest ( HWND hwndDlg , int idTestCipher );

void ResetCurrentDirectory ();

void handleError ( HWND hwndDlg , int code, const char* srcPos );

void LocalizeDialog ( HWND hwnd, char *stringId );

void OpenVolumeExplorerWindow (int driveNo);

static BOOL CALLBACK CloseVolumeExplorerWindowsEnum( HWND hwnd, LPARAM driveNo);

BOOL CloseVolumeExplorerWindows (HWND hwnd, int driveNo);

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

BOOL CheckCapsLock (HWND hwnd, BOOL quiet);

void IncreaseWrongPwdRetryCount (int count);

void ResetWrongPwdRetryCount (void);

BOOL WrongPwdRetryCountOverLimit (void);

int GetFirstAvailableDrive ();

int GetLastAvailableDrive ();

BOOL IsDriveAvailable (int driveNo);

int DriverUnmountVolume (HWND hwndDlg, int nDosDriveNo, BOOL forced);

void BroadcastDeviceChange (WPARAM message, int nDosDriveNo, DWORD driveMap);

BOOL UnmountVolume (HWND hwndDlg , int nDosDriveNo, BOOL forceUnmount);

BOOL UnmountVolumeAfterFormatExCall (HWND hwndDlg, int nDosDriveNo);

BOOL IsPasswordCacheEmpty (void);

BOOL IsAdmin (void);

BOOL IsBuiltInAdmin ();

BOOL IsUacSupported ();

BOOL ResolveSymbolicLink (const wchar_t *symLinkName, PWSTR targetName, size_t cbTargetName);

int GetDiskDeviceDriveLetter (PWSTR deviceName);

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

BOOL TCFlushFile (FILE *f);

void GetSpeedString (unsigned __int64 speed, wchar_t *str, size_t cbStr);

BOOL IsNonInstallMode ();

BOOL DriverUnload ();

BOOL GetCheckBox (HWND hwndDlg, int dlgItem);

void SetListScrollHPos (HWND hList, int topMostVisibleItem);

void ManageStartupSeq (void);

void CleanLastVisitedMRU (void);

void ClearHistory (HWND hwndDlgItem);

BOOL GetMountList (MOUNT_LIST_STRUCT *list);

int GetDriverRefCount ();

void GetSizeString (unsigned __int64 size, wchar_t *str, size_t cbStr);

void OpenPageHelp (HWND hwndDlg, int nPage);

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

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

BOOL ConfigWriteBegin ();

BOOL ConfigWriteEnd (HWND hwnd);

BOOL ConfigWriteString (char *configKey, char *configValue);

BOOL ConfigWriteInt (char *configKey, int configValue);

int ConfigReadInt (char *configKey, int defaultValue);

char *ConfigReadString (char *configKey, char *defaultValue, char *str, int maxLen);

BOOL EnableWow64FsRedirection (BOOL enable);

BOOL RestartComputer (void);

void Applink (char *dest, BOOL bSendOS, char *extraOutput);

void HandleDriveNotReadyError (HWND hwnd);

BOOL CALLBACK CloseTCWindowsEnum( HWND hwnd, LPARAM lParam);

BOOL CALLBACK FindTCWindowEnum (HWND hwnd, LPARAM lParam);

void InconsistencyResolved (char *msg);

void ReportUnexpectedState (char *techInfo);

void OpenOnlineHelp ();

int CompensateXDPI (int val);

int CompensateYDPI (int val);

int CompensateDPIFont (int val);

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

BOOL GetSysDevicePaths (HWND hwndDlg);

BOOL DoDriverInstall (HWND hwndDlg);

void CloseVolume (OpenVolumeContext *context);

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

BOOL IsPagingFileActive (BOOL checkNonWindowsPartitionsOnly);

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

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

BOOL InitSecurityTokenLibrary (HWND hwndDlg);

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

BOOL BufferContainsString (const byte *buffer, size_t bufferSize, const char *str);

int AskNonSysInPlaceEncryptionResume (HWND hwndDlg, BOOL* pbDecrypt);

void EnableElevatedCursorChange (HWND parent);

BOOL DisableFileCompression (HANDLE file);

BOOL IsWindowsIsoBurnerAvailable ();

int GetPim (HWND hwndDlg, UINT ctrlId);

void SetPim (HWND hwndDlg, UINT ctrlId, int pim);

void HandleShowPasswordFieldAction (HWND hwndDlg, UINT checkBoxId, UINT edit1Id, UINT edit2Id);

#ifdef __cplusplus

bool IsPartition;

bool IsVirtualPartition;

bool HasUnencryptedFilesystem;

std::wstring Name;

bool Removable;

uint64 Size;

uint32 SystemNumber;

struct RawDevicesDlgParam

{

std::vector <HostDevice> devices;

};

std::wstring SingleStringToWide (const std::string &singleString);

std::wstring Utf8StringToWide (const std::string &utf8String);

std::string WideToSingleString (const std::wstring &wideString);

std::string StringToUpperCase (const std::string &str);

std::vector <HostDevice> GetAvailableHostDevices (bool noDeviceProperties = false, bool singleList = false, bool noFloppy = true, bool detectUnencryptedFilesystems = false);

std::string ToUpperCase (const std::string &str);

std::wstring GetWrongPasswordErrorMessage (HWND hwndDlg);

std::string IntToString (int val);

std::wstring IntToWideString (int val);

inline std::wstring AppendSrcPos (const wchar_t* msg, const char* srcPos)

void Show (HWND parent) const

{

string msgBody = "Parameter incorrect.\n\n\n(If you report a bug in connection with this, please include the following technical information in the bug report:\n" + string (SrcPos) + ")";

}

const char *SrcPos;

void Show (HWND parent) const

{

char szErrCode[16];

string msgBody = "The Random Generator initialization failed.\n\n\n(If you report a bug in connection with this, please include the following technical information in the bug report:\n" + string (SrcPos) + "\nLast Error = " + string (szErrCode) + ")";

}

const char *SrcPos;

void Show (HWND parent) const

{

char szErrCode[16];

string msgBody = "Windows Crypto API failed.\n\n\n(If you report a bug in connection with this, please include the following technical information in the bug report:\n" + string (SrcPos) + "\nLast Error = " + string (szErrCode) + ")";

}

const char *SrcPos;

FILETIME ftLastAccessTime;

BOOL bTimeStampValid = FALSE;

BOOL bInstantRetryOtherFilesys = FALSE;

int driveLetter = -1;

WCHAR deviceName[MAX_PATH];

uint64 dataOffset, dataAreaSize;

if (volParams->bDevice)

{

driveLetter = GetDiskDeviceDriveLetter (deviceName);

}

// to which no drive letter has been assigned under the system. This problem can be worked

// around by assigning a drive letter to the partition temporarily.

int tmpDriveLetter = -1;

BOOL bResult = FALSE;

if (tmpDriveLetter != -1)

{

if (DefineDosDevice (DDD_RAW_TARGET_PATH, szDriveLetter, volParams->volumePath))

{

BOOL FormatNtfs (int driveNo, int clusterSize)

{

PFORMATEX FormatEx;

HMODULE hModule;

int i;

if (GetSystemDirectory (dllPath, MAX_PATH))

{

}

else

hModule = LoadLibrary (dllPath);

if (hModule == NULL)

return FALSE;

{

FreeLibrary (hModule);

return FALSE;

{

BOOL bDevice;

BOOL hiddenVol;

unsigned __int64 size;

unsigned __int64 hiddenVolHostSize;

int ea;

clone = (KeyFile *) malloc (sizeof (KeyFile));

if (clone)

{

clone->Next = NULL;

}

return clone;

CloseHandle (finally_arg);

});

if (f == NULL) return FALSE;

while ((bytesRead = fread (buffer, 1, sizeof (buffer), f)) > 0)

}

{

BOOL status = TRUE;

KeyFile kfSubStruct;

static unsigned __int8 keyPool [KEYFILE_POOL_SIZE];

size_t i;

struct stat statStruct;

intptr_t searchHandle;

HiddenFilesPresentInKeyfilePath = FALSE;

// Determine whether it's a security token path

try

{

{

// Apply security token keyfile

vector <byte> keyfileData;

if (keyfileData.empty())

{

}

// Determine whether it's a path or a file

{

handleWin32Error (hwndDlg, SRC_POS);

Error ("ERR_PROCESS_KEYFILE", hwndDlg);

/* Find and process all keyfiles in the directory */

int keyfileCount = 0;

{

handleWin32Error (hwndDlg, SRC_POS);

Error ("ERR_PROCESS_KEYFILE_PATH", hwndDlg);

{

WIN32_FILE_ATTRIBUTE_DATA fileAttributes;

fBuf.name

);

// Determine whether it's a path or a file

{

handleWin32Error (hwndDlg, SRC_POS);

Error ("ERR_PROCESS_KEYFILE", hwndDlg);

}

// Skip hidden files

&& (fileAttributes.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0)

{

HiddenFilesPresentInKeyfilePath = TRUE;

}

CorrectFileName (kfSub->FileName);

{

// skip if it is the current container file name

continue;

status = FALSE;

}

_findclose (searchHandle);

burn (&kfSubStruct, sizeof (kfSubStruct));

if (keyfileCount == 0)

{

status = FALSE;

}

}

do

{

CorrectFileName (kf->FileName);

containerFileSkipped = true;

else

{

KeyFile *kf = (KeyFile *) malloc (sizeof (KeyFile));

if (kf)

{

param->FirstKeyFile = KeyFileAdd (param->FirstKeyFile, kf);

LoadKeyList (hwndDlg, param->FirstKeyFile);

KeyFile *kf = (KeyFile *) malloc (sizeof (KeyFile));

if (kf)

{

param->FirstKeyFile = KeyFileAdd (param->FirstKeyFile, kf);

param->EnableKeyFiles = TRUE;

typedef struct KeyFileStruct

{

struct KeyFileStruct *Next;

} KeyFile;

typedef struct

{

BOOL EnableKeyFiles;

KeyFile *FirstKeyFile;

} KeyFilesDlgParam;

void KeyFileRemoveAll (KeyFile **firstKeyFile);

KeyFile *KeyFileClone (KeyFile *keyFile);

KeyFile *KeyFileCloneAll (KeyFile *firstKeyFile);

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

BOOL KeyfilesPopupMenu (HWND hwndDlg, POINT popupPosition, KeyFilesDlgParam *dialogParam);

if (LanguageResource == NULL)

{

DWORD size;

if (LanguageResource)

LanguageResourceSize = size;

}

case 't': *out++ = '\t'; break;

case 'n': *out++ = 13; *out++ = 10; break;

default:

return FALSE;

}

}

len = MultiByteToWideChar (CP_UTF8, 0, attr, -1, wattr, sizeof (wattr) / sizeof(wattr[0]));

if (len == 0)

{

return FALSE;

}

{

if (HeaderResource[i] == NULL)

{

if (HeaderResource[i])

HeaderResourceSize[i] = size;

}

<string lang="en" key="CIPHER_TITLE">Encryption Options</string>

<string lang="en" key="CLEAN_WINMRU_FAILED">WARNING: Failed to clear the path of the last selected volume/keyfile (remembered by file selector)!</string>

<string lang="en" key="COMPRESSION_NOT_SUPPORTED">Error: The container has been compressed at the filesystem level. VeraCrypt does not support compressed containers (note that compression of encrypted data is ineffective and redundant).\n\nPlease disable compression for the container by following these steps:\n1) Right-click the container in Windows Explorer (not in VeraCrypt).\n2) Select 'Properties'.\n3) In the 'Properties' dialog box, click 'Advanced'.\n4) In the 'Advanced Attributes' dialog box, disable the option 'Compress contents to save disk space' and click 'OK'.\n5) In the 'Properties' dialog box, click 'OK'.</string>

<string lang="en" key="DEVICE_IN_USE_FORMAT">WARNING: The device/partition is in use by the operating system or applications. Formatting the device/partition might cause data corruption and system instability.\n\nContinue?</string>

<string lang="en" key="DEVICE_IN_USE_INPLACE_ENC">Warning: The partition is in use by the operating system or applications. You should close any applications that might be using the partition (including antivirus software).\n\nContinue?</string>

<string lang="en" key="FORMAT_CANT_DISMOUNT_FILESYS">Error: The device/partition contains a file system that could not be dismounted. The file system may be in use by the operating system. Formatting the device/partition would very likely cause data corruption and system instability.\n\nTo solve this issue, we recommend that you first delete the partition and then recreate it without formatting. To do so, follow these steps:\n1) Right-click the 'Computer' (or 'My Computer') icon in the 'Start Menu' and select 'Manage'. The 'Computer Management' window should appear.\n2) In the 'Computer Management' window, select 'Storage' > 'Disk Management'.\n3) Right-click the partition you want to encrypt and select either 'Delete Partition', or 'Delete Volume', or 'Delete Logical Drive'.\n4) Click 'Yes'. If Windows asks you to restart the computer, do so. Then repeat the steps 1 and 2 and continue from the step 5.\n5) Right-click the unallocated/free space area and select either 'New Partition', or 'New Simple Volume', or 'New Logical Drive'.\n6) The 'New Partition Wizard' or 'New Simple Volume Wizard' window should appear now; follow its instructions. On the wizard page entitled 'Format Partition', select either 'Do not format this partition' or 'Do not format this volume'. In the same wizard, click 'Next' and then 'Finish'.\n7) Note that the device path you have selected in VeraCrypt may be wrong now. Therefore, exit the VeraCrypt Volume Creation Wizard (if it is still running) and then start it again.\n8) Try encrypting the device/partition again.\n\nIf VeraCrypt repeatedly fails to encrypt the device/partition, you may want to consider creating a file container instead.</string>

<string lang="en" key="INPLACE_ENC_INVALID_PATH">Error: VeraCrypt can in-place encrypt only a partition, a dynamic volume, or an entire system drive. Please make sure the specified path is valid.</string>

<string lang="en" key="CANNOT_RESIZE_FILESYS">Error: Cannot shrink the filesystem (the filesystem needs to be shrunk to make space for the volume header and backup header).\n\nPossible causes and solutions:\n\n- Not enough free space on the volume. Please make sure no other application is writing to the filesystem.\n\n- Corrupted file system. Try to check it and fix any errors (right-click the corresponding drive letter in the 'Computer' list, then select Properties > Tools > 'Check Now', make sure the option 'Automatically fix file system errors' is enabled and click Start).\n\nIf the above steps do not help, please follow the below steps.</string>

<string lang="en" key="NOT_ENOUGH_FREE_FILESYS_SPACE_FOR_SHRINK">Error: There is not enough free space on the volume and so the filesystem cannot be shrunk (the filesystem needs to be shrunk to make space for the volume header and backup header).\n\nPlease delete any redundant files and empty the Recycle Bin so as to free at least 256 KB of space and then try again. Note that due to a Windows issue, the amount of free space reported by the Windows Explorer may be incorrect until the operating system is restarted. If restarting the system does not help, the file system may be corrupted. Try to check it and fix any errors (right-click the corresponding drive letter in the 'Computer' list, then select Properties > Tools > 'Check Now', make sure the option 'Automatically fix file system errors' is enabled and click Start).\n\nIf the above steps do not help, please follow the below steps.</string>

<string lang="en" key="DRIVELETTERS">Could not get available drive letters.</string>

<string lang="en" key="DRIVER_NOT_FOUND">Error: VeraCrypt driver not found.\n\nPlease copy the files 'veracrypt.sys' and 'veracrypt-x64.sys' to the directory where the main VeraCrypt application (VeraCrypt.exe) is located.</string>

<string lang="en" key="DRIVER_VERSION">Error: An incompatible version of the VeraCrypt driver is currently running.\n\nIf you are trying to run VeraCrypt in portable mode (i.e. without installing it) and a different version of VeraCrypt is already installed, you must uninstall it first (or upgrade it using the VeraCrypt installer). To uninstall it, follow these steps: On Windows Vista or later, select 'Start Menu' > Computer > 'Uninstall or change a program' > VeraCrypt > Uninstall; on Windows XP, select 'Start Menu' > Settings > 'Control Panel' > 'Add Or Remove Programs' > VeraCrypt > Remove.\n\nSimilarly, if you are trying to run VeraCrypt in portable mode (i.e. without installing it) and a different version of VeraCrypt is already running in portable mode, you must restart the system first and then run only this new version.</string>

<string lang="en" key="SELECT_PKCS11_MODULE">Select PKCS #11 Library</string>

<string lang="en" key="OUTOFMEMORY">Out of Memory</string>

<string lang="en" key="FORMAT_DEVICE_FOR_ADVANCED_ONLY">IMPORTANT: We strongly recommend that inexperienced users create a VeraCrypt file container on the selected device/partition, instead of attempting to encrypt the entire device/partition.\n\nWhen you create a VeraCrypt file container (as opposed to encrypting a device or partition) there is, for example, no risk of destroying a large number of files. Note that a VeraCrypt file container (even though it contains a virtual encrypted disk) is actually just like any normal file. For more information, see the chapter Beginner's Tutorial in the VeraCrypt User Guide.\n\nAre you sure you want to encrypt the entire device/partition?</string>

<string lang="en" key="NONSYS_INPLACE_ENC_CONFIRM_BACKUP">WARNING: Please note that if power supply is suddenly interrupted while encrypting/decrypting existing data in place, or when the operating system crashes due to a software error or hardware malfunction while VeraCrypt is encrypting/decrypting existing data in place, portions of the data will be corrupted or lost. Therefore, before you start encrypting/decrypting, please make sure that you have backup copies of the files you want to encrypt/decrypt.\n\nDo you have such a backup?</string>

<string lang="en" key="OVERWRITEPROMPT_DEVICE_SECOND_WARNING_LOTS_OF_DATA">WARNING: THE SELECTED PARTITION CONTAINS A LARGE AMOUNT OF DATA! Any files stored on the partition will be erased and lost (they will NOT be encrypted)!</string>

<string lang="en" key="ERASE_FILES_BY_CREATING_VOLUME">Erase any files stored on the partition by creating a VeraCrypt volume within it</string>

<string lang="en" key="PASSWORD">Password</string>

<string lang="en" key="PASSWORD_WRONG_AUTOMOUNT">Auto-mount failed due to one or more of the following:\n - Incorrect password.\n - Incorrect Volume PIM number.\n - Incorrect PRF (hash).\n - No valid volume found.</string>

<string lang="en" key="PASSWORD_OR_KEYFILE_WRONG_AUTOMOUNT">Auto-mount failed due to one or more of the following:\n - Incorrect keyfile(s).\n - Incorrect password.\n - Incorrect Volume PIM number.\n - Incorrect PRF (hash).\n - No valid volume found.</string>

<string lang="en" key="PASSWORD_WRONG_CAPSLOCK_ON">\n\nWarning: Caps Lock is on. This may cause you to enter your password incorrectly.</string>

<string lang="en" key="PIM_CHANGE_WARNING">Remember Number to Mount Volume</string>

<string lang="en" key="PIM_HIDVOL_HOST_TITLE">Outer Volume PIM</string>

<string lang="en" key="PIM_HIDVOL_TITLE">Hidden Volume PIM</string>

<string lang="en" key="CANT_DECRYPT_PARTITION_ON_ENTIRELY_ENCRYPTED_SYS_DRIVE_UNSURE">Warning: As the drive contains the VeraCrypt Boot Loader, it may be an entirely encrypted system drive. If it is, please note that VeraCrypt cannot decrypt an individual partition on an entirely encrypted system drive (you can decrypt only the entire system drive). If that is the case, you will be able to continue now but you will receive the 'Incorrect password' error message later.</string>

<string lang="en" key="PREV">&lt; &amp;Back</string>

<string lang="en" key="RAWDEVICES">Unable to list raw devices installed on your system!</string>

<string lang="en" key="SELECT_DEST_DIR">Select destination directory</string>

<string lang="en" key="SELECT_KEYFILE">Select Keyfile</string>

<string lang="en" key="SELECT_KEYFILE_PATH">Select a keyfile search path. WARNING: Note that only the path will be remembered, not the filenames!</string>

<string lang="en" key="TEST_CIPHERTEXT_SIZE">The test ciphertext you have supplied is too long or short.</string>

<string lang="en" key="TEST_KEY_SIZE">The test key you have supplied is too long or short.</string>

<string lang="en" key="TEST_PLAINTEXT_SIZE">The test plaintext you have supplied is too long or short.</string>

<string lang="en" key="AUTORUN_MAY_NOT_ALWAYS_WORK">Note that, depending on the operating system configuration, these auto-run and auto-mount features may work only when the traveler disk files are created on a non-writable CD/DVD-like medium. Also note that this is not a bug in VeraCrypt (it is a limitation of Windows).</string>

<string lang="en" key="TRAVELER_DISK_CREATED">VeraCrypt traveler disk has been successfully created.\n\nNote that you need administrator privileges to run VeraCrypt in portable mode. Also note that, after examining the registry file, it may be possible to tell that VeraCrypt was run on a Windows system even if it is run in portable mode.</string>

<string lang="en" key="TC_TRAVELER_DISK">VeraCrypt Traveler Disk</string>

<string lang="en" key="TWOFISH_HELP">Designed by Bruce Schneier, John Kelsey, Doug Whiting, David Wagner, Chris Hall, and Niels Ferguson. Published in 1998. 256-bit key, 128-bit block. Mode of operation is XTS. Twofish was one of the AES finalists.</string>

<string lang="en" key="UNKNOWN">Unknown</string>

<string lang="en" key="ERR_UNKNOWN">An unspecified or unknown error occurred (%d).</string>

<string lang="en" key="UNMOUNTALL_LOCK_FAILED">Some volumes contain files or folders being used by applications or system.\n\nForce dismount?</string>

<string lang="en" key="INSTALL_FAILED">Installation failed.</string>

<string lang="en" key="UNINSTALL_FAILED">Uninstallation failed.</string>

<string lang="en" key="DIST_PACKAGE_CORRUPTED">This distribution package is damaged. Please try downloading it again (preferably from the official VeraCrypt website at https://veracrypt.codeplex.com).</string>

<string lang="en" key="EXTRACTING_VERB">Extracting</string>

<string lang="en" key="CANNOT_READ_FROM_PACKAGE">Cannot read data from the package.</string>

<string lang="en" key="CANT_VERIFY_PACKAGE_INTEGRITY">Cannot verify the integrity of this distribution package.</string>

<string lang="en" key="SETUP_UPDATE_OK">VeraCrypt has been successfully updated.</string>

<string lang="en" key="UPGRADE_OK_REBOOT_REQUIRED">VeraCrypt has been successfully upgraded. However, before you can start using it, the computer must be restarted.\n\nDo you want to restart it now?</string>

<string lang="en" key="SYS_ENC_UPGRADE_FAILED">Failed to upgrade VeraCrypt!\n\nIMPORTANT: Before you shut down or restart the system, we strongly recommend that you use System Restore (Windows Start menu > All programs > Accessories > System Tools > System Restore) to restore your system to the restore point named 'VeraCrypt installation'. If System Restore is not available, you should try installing the original or the new version of VeraCrypt again before you shut down or restart the system.</string>

<string lang="en" key="REMOVING_REG">Removing VeraCrypt registry entries</string>

<string lang="en" key="ADDING_REG">Adding registry entry</string>

<string lang="en" key="REMOVING_APPDATA">Removing application-specific data</string>

<string lang="en" key="CREATING_SYS_RESTORE">Creating System Restore point</string>

<string lang="en" key="FAILED_SYS_RESTORE">Failed to create System Restore point!</string>

<string lang="en" key="INSTALLER_UPDATING_BOOT_LOADER">Updating boot loader</string>

<string lang="en" key="INSTALL_COMPLETED">Installation completed.</string>

<string lang="en" key="CLOSE_TC_FIRST">The VeraCrypt device driver cannot be unloaded.\n\nPlease close all open VeraCrypt windows first. If it does not help, please restart Windows and then try again.</string>

<string lang="en" key="DISMOUNT_ALL_FIRST">All VeraCrypt volumes must be dismounted before installing or uninstalling VeraCrypt.</string>

<string lang="en" key="UNINSTALL_OLD_VERSION_FIRST">An obsolete version of VeraCrypt is currently installed on this system. It needs to be uninstalled before you can install this new version of VeraCrypt.\n\nAs soon as you close this message box, the uninstaller of the old version will be launched. Note that no volume will be decrypted when you uninstall VeraCrypt. After you uninstall the old version of VeraCrypt, run the installer of the new version of VeraCrypt again.</string>

<string lang="en" key="FAVORITE_LABEL_DEVICE_PATH_ERR">The device displayed below is neither a partition nor a dynamic volume. Therefore, no label can be assigned to it.</string>

<string lang="en" key="FAVORITE_LABEL_PARTITION_TYPE_ERR">Please set the type of the partition displayed below to a type recognized by Windows (use the SETID command of the Windows 'diskpart' tool). Then remove the partition from favorites and add it again. This will enable VeraCrypt to assign a label to the partition.</string>

<string lang="en" key="SYSTEM_FAVORITE_NETWORK_PATH_ERR">Due to a Windows limitation, a container stored in a remote filesystem shared over a network cannot be mounted as a system favorite volume (however, it can be mounted as a non-system favorite volume when a user logs on).</string>

<string lang="en" key="ENTER_PASSWORD_FOR_LABEL">Enter password for '%s'</string>

<string lang="en" key="ENTER_NORMAL_VOL_PASSWORD">Enter password for the normal/outer volume</string>

<string lang="en" key="ENTER_HIDDEN_VOL_PASSWORD">Enter password for the hidden volume</string>

<string lang="en" key="VOL_HEADER_BACKED_UP">Volume header backup has been successfully created.\n\nIMPORTANT: Restoring the volume header using this backup will also restore the current volume password. Moreover, if keyfile(s) are/is necessary to mount the volume, the same keyfile(s) will be necessary to mount the volume again when the volume header is restored.\n\nWARNING: This volume header backup may be used to restore the header ONLY of this particular volume. If you use this header backup to restore a header of a different volume, you will be able to mount the volume, but you will NOT be able to decrypt any data stored in the volume (because you will change its master key).</string>

<string lang="en" key="VOL_HEADER_RESTORED">The volume header has been successfully restored.\n\nIMPORTANT: Please note that an old password may have been restored as well. Moreover, if keyfile(s) were/was necessary to mount the volume when the backup was created, the same keyfile(s) are now necessary to mount the volume again.</string>

<string lang="en" key="EXTERNAL_VOL_HEADER_BAK_FIRST_INFO">For security reasons, you will have to enter the correct password (and/or supply the correct keyfiles) for the volume.\n\nNote: If the volume contains a hidden volume, you will have to enter the correct password (and/or supply the correct keyfiles) for the outer volume first. Afterwards, if you choose to back up the header of the hidden volume, you will have to enter the correct password (and/or supply the correct keyfiles) for the hidden volume.</string>

<string lang="en" key="DOES_VOLUME_CONTAIN_HIDDEN">Does the volume contain a hidden volume?</string>

<string lang="en" key="VOLUME_CONTAINS_HIDDEN">The volume contains a hidden volume</string>

<string lang="en" key="VOLUME_DOES_NOT_CONTAIN_HIDDEN">The volume does not contain a hidden volume</string>

<string lang="en" key="BACKUP_HEADER_NOT_FOR_SYS_DEVICE">You are attempting to back up the header of the system partition/drive. This is not allowed. Backup/restore operations pertaining to the system partition/drive can be performed only using the VeraCrypt Rescue Disk.\n\nDo you want to create a VeraCrypt Rescue Disk?</string>

<string lang="en" key="RESTORE_HEADER_NOT_FOR_SYS_DEVICE">You are attempting to restore the header of a virtual VeraCrypt volume but you selected the system partition/drive. This is not allowed. Backup/restore operations pertaining to the system partition/drive can be performed only using the VeraCrypt Rescue Disk.\n\nDo you want to create a VeraCrypt Rescue Disk?</string>

<string lang="en" key="RESCUE_DISK_NON_WIZARD_CREATION_SELECT_PATH">After you click OK, you will select a filename for the new VeraCrypt Rescue Disk ISO image and the location where you wish to place it.</string>

<string lang="en" key="RESCUE_DISK_NON_WIZARD_CHECK_INSERT">Please insert your VeraCrypt Rescue Disk into your CD/DVD drive and click OK to verify it.</string>

<string lang="en" key="RESCUE_DISK_NON_WIZARD_CHECK_PASSED">The VeraCrypt Rescue Disk has been successfully verified.</string>

<string lang="en" key="RESCUE_DISK_NON_WIZARD_CHECK_FAILED">Cannot verify that the Rescue Disk has been correctly burned.\n\nIf you have burned the Rescue Disk, please eject and reinsert the CD/DVD; then try again. If this does not help, please try other CD/DVD recording software and/or medium.\n\nIf you attempted to verify a VeraCrypt Rescue Disk created for a different master key, password, salt, etc., please note that such Rescue Disk will always fail this verification. To create a new Rescue Disk fully compatible with your current configuration, select 'System' > 'Create Rescue Disk'.</string>

<string lang="en" key="NO_SYS_ENC_PROCESS_TO_RESUME">There is no interrupted process of encryption/decryption of the system partition/drive to resume.\n\nNote: If you want to resume an interrupted process of encryption/decryption of a non-system partition/volume, select 'Volumes' &gt; 'Resume Interrupted Process'.</string>

<string lang="en" key="HIDVOL_PROT_BKG_TASK_WARNING">WARNING: VeraCrypt Background Task is disabled. After you exit VeraCrypt, you will not be notified if damage to hidden volume is prevented.\n\nNote: You may shut down the Background Task anytime by right-clicking the VeraCrypt tray icon and selecting 'Exit'.\n\nEnable VeraCrypt Background Task?</string>

<string lang="en" key="LANG_PACK_VERSION">Language pack version: %s</string>

<string lang="en" key="WARN_64_BIT_BLOCK_CIPHER">Warning: This volume is encrypted with a legacy encryption algorithm.\n\nAll 64-bit-block encryption algorithms (e.g., Blowfish, CAST-128, or Triple DES) are deprecated. It will be possible to mount this volume using future versions of VeraCrypt. However, there will be no further enhancements to the implementations of these legacy encryption algorithms. We recommend that you create a new VeraCrypt volume encrypted with a 128-bit-block encryption algorithm (e.g., AES, Serpent, Twofish, etc.) and that you move all files from this volume to the new volume.</string>

<string lang="en" key="SYS_AUTOMOUNT_DISABLED">Your system is not configured to auto-mount new volumes. It may be impossible to mount device-hosted VeraCrypt volumes. Auto-mounting can be enabled by executing the following command and restarting the system.\n\nmountvol.exe /E</string>

<string lang="en" key="SYS_ASSIGN_DRIVE_LETTER">Please assign a drive letter to the partition/device before proceeding ('Control Panel' > 'System and Maintenance' > 'Administrative Tools' - 'Create and format hard disk partitions').\n\nNote that this is a requirement of the operating system.</string>

<string lang="en" key="KEYB_LAYOUT_SYS_ENC_EXPLANATION">Note: The password will need to be typed in the pre-boot environment (before Windows starts) where non-US Windows keyboard layouts are not available. Therefore, the password must always be typed using the standard US keyboard layout. However, it is important to note that you do NOT need a real US keyboard. VeraCrypt automatically ensures that you can safely type the password (right now and in the pre-boot environment) even if you do NOT have a real US keyboard.</string>

<string lang="en" key="RESCUE_DISK_INFO">Before you can encrypt the partition/drive, you must create a VeraCrypt Rescue Disk (VRD), which serves the following purposes:\n\n- If the VeraCrypt Boot Loader, master key, or other critical data gets damaged, the VRD allows you to restore it (note, however, that you will still have to enter the correct password then).\n\n- If Windows gets damaged and cannot start, the VRD allows you to permanently decrypt the partition/drive before Windows starts.\n\n- The VRD will contain a backup of the present content of the first drive track (which typically contains a system loader or boot manager) and will allow you to restore it if necessary.\n\nThe VeraCrypt Rescue Disk ISO image will be created in the location specified below.</string>

<string lang="en" key="RESCUE_DISK_WIN_ISOBURN_PRELAUNCH_NOTE">After you click OK, Microsoft Windows Disc Image Burner will be launched. Please use it to burn the VeraCrypt Rescue Disk ISO image to a CD or DVD.\n\nAfter you do so, return to the VeraCrypt Volume Creation Wizard and follow its instructions.</string>

<string lang="en" key="RESCUE_DISK_BURN_INFO_NONWIN_ISO_BURNER">IMPORTANT: Note that the file must be written to the CD/DVD as an ISO disk image (not as an individual file). For information on how to do so, please refer to the documentation of your CD/DVD recording software. If you do not have any CD/DVD recording software that can write the ISO disk image to a CD/DVD, click the link below to download such free software.\n\n</string>

<string lang="en" key="LAUNCH_WIN_ISOBURN">Launch Microsoft Windows Disc Image Burner</string>

<string lang="en" key="RESCUE_DISK_BURN_NO_CHECK_WARN">WARNING: If you already created a VeraCrypt Rescue Disk in the past, it cannot be reused for this system partition/drive because it was created for a different master key! Every time you encrypt a system partition/drive, you must create a new VeraCrypt Rescue Disk for it even if you use the same password.</string>

char *szVerify,

BOOL keyFilesEnabled)

{

int k = GetWindowTextLength (hPassword);

BOOL bEnable = FALSE;

UNREFERENCED_PARAMETER (hwndDlg); /* Remove warning */

GetWindowText (hPassword, szTmp1, sizeof (szTmp1));

GetWindowText (hVerify, szTmp2, sizeof (szTmp2));

bEnable = FALSE;

else

{

}

if (szPassword != NULL)

if (szVerify != NULL)

burn (szTmp1, sizeof (szTmp1));

burn (szTmp2, sizeof (szTmp2));

EnableWindow (hButton, bEnable);

}

return TRUE;

}

{

int nDosLinkCreated = 1, nStatus = ERR_OS_ERROR;

char buffer[TC_VOLUME_HEADER_EFFECTIVE_SIZE];

PCRYPTO_INFO cryptoInfo = NULL, ci = NULL;

void *dev = INVALID_HANDLE_VALUE;

if (bDevice == FALSE)

{

}

else

{

void VerifyPasswordAndUpdate ( HWND hwndDlg , HWND hButton , HWND hPassword , HWND hVerify , unsigned char *szPassword , char *szVerify, BOOL keyFilesEnabled );

BOOL CheckPasswordLength (HWND hwndDlg, unsigned __int32 passwordLength, int pim, BOOL bForBoot, BOOL bSkipPasswordWarning, BOOL bSkipPimWarning);

BOOL CheckPasswordCharEncoding (HWND hPassword, Password *ptrPw);

#endif // defined(_WIN32) && !defined(TC_WINDOWS_DRIVER)

}

{

switch (pkcs5_prf_id)

{

case SHA512:

case SHA256:

case RIPEMD160:

case WHIRLPOOL:

default:

}

}

extern "C"

{

#endif

/* output written to d which must be at lease 32 bytes long */

void hmac_sha256 (char *k, int lk, char *d, int ld);

void derive_key_sha256 (char *pwd, int pwd_len, char *salt, int salt_len, uint32 iterations, char *dk, int dklen);

/* output written to d which must be at lease 64 bytes long */

void hmac_sha512 (char *k, int lk, char *d, int ld);

void derive_key_sha512 (char *pwd, int pwd_len, char *salt, int salt_len, uint32 iterations, char *dk, int dklen);

/* output written to d which must be at lease 64 bytes long */

void hmac_whirlpool (char *k, int lk, char *d, int ld);

void derive_key_whirlpool (char *pwd, int pwd_len, char *salt, int salt_len, uint32 iterations, char *dk, int dklen);

int get_pkcs5_iteration_count (int pkcs5_prf_id, int pim, BOOL truecryptMode, BOOL bBoot);

#if defined(__cplusplus)

}

HKEY hKey;

if (RegOpenKeyEx (HKEY_LOCAL_MACHINE,

0, KEY_READ, &hKey) == ERROR_SUCCESS)

{

dwSize = sizeof (szValue);

isWorkstation = TRUE;

/* Note: There are (at least) three cases for

ProductType: WinNT = NT Workstation,

ServerNT = NT Server, LanmanNT = NT Server

{

/* Obtain a handle to the module containing the Lan Manager

functions */

if (GetSystemDirectory (dllPath, MAX_PATH))

{

}

else

hNetAPI32 = LoadLibrary (dllPath);

if (hNetAPI32 != NULL)

for (nDrive = 0;; nDrive++)

{

DISK_PERFORMANCE diskPerformance;

/* Check whether we can access this device */

hDevice = CreateFile (szDevice, 0, FILE_SHARE_READ | FILE_SHARE_WRITE,

NULL, OPEN_EXISTING, 0, NULL);

if (hDevice == INVALID_HANDLE_VALUE)

#include "Registry.h"

#include <Strsafe.h>

{

HKEY hkey = 0;

DWORD size = sizeof (*value);

return type == REG_DWORD;

}

{

HKEY hkey = 0;

DWORD type;

return type == REG_MULTI_SZ;

}

{

HKEY hkey = 0;

DWORD type;

return type == REG_SZ;

}

{

HKEY hkey = 0;

DWORD type;

return type == REG_SZ;

}

{

HKEY hkey = 0;

DWORD value, size = sizeof (DWORD);

return value;

}

{

HKEY hkey = 0;

DWORD size = sizeof (value);

ZeroMemory (value, sizeof value);

if (RegOpenKeyEx (HKEY_CURRENT_USER, subKey,

0, KEY_READ, &hkey) == ERROR_SUCCESS)

if (RegQueryValueEx (hkey, name, 0, 0, (LPBYTE) value, &size) == ERROR_SUCCESS)

if (hkey)

RegCloseKey (hkey);

return str;

}

{

HKEY hkey = 0;

DWORD size = maxLen;

return success ? size : 0;

}

{

HKEY hkey = 0;

DWORD disp;

RegCloseKey (hkey);

}

{

HKEY hkey = 0;

DWORD disp;

return TRUE;

}

{

HKEY hkey = 0;

DWORD disp;

return TRUE;

}

{

HKEY hkey = 0;

DWORD disp;

return FALSE;

}

{

RegCloseKey (hkey);

SetLastError (status);

return TRUE;

}

{

HKEY hkey = 0;

DWORD disp;

0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hkey, &disp) != ERROR_SUCCESS)

return;

RegCloseKey (hkey);

}

{

HKEY hkey = 0;

DWORD disp;

return res == ERROR_SUCCESS;

}

{

LONG status;

HKEY hkey = 0;

return TRUE;

}

{

HKEY hkey = 0;

}

{

// The string is split in order to prevent some antivirus packages from falsely reporting

// VeraCrypt.exe to contain a possible Trojan horse because of this string (heuristic scan).

}

{

// The string is split in order to prevent some antivirus packages from falsely reporting

// VeraCrypt.exe to contain a possible Trojan horse because of this string (heuristic scan).

} \ No newline at end of file

extern "C" {

#endif

#ifdef __cplusplus

}

SlotId = slotId;

size_t keyIdPos = pathStr.find (L"/" TC_SECURITY_TOKEN_KEYFILE_URL_FILE L"/");

throw InvalidSecurityTokenKeyfilePath();

Id = pathStr.substr (keyIdPos + wstring (L"/" TC_SECURITY_TOKEN_KEYFILE_URL_FILE L"/").size());

}

}

void SecurityToken::InitLibrary (const string &pkcs11LibraryPath, auto_ptr <GetPinFunctor> pinCallback, auto_ptr <SendExceptionFunctor> warningCallback)

{

if (Initialized)

CloseLibrary();

#ifdef TC_WINDOWS

#else

Pkcs11LibraryHandle = dlopen (pkcs11LibraryPath.c_str(), RTLD_NOW | RTLD_LOCAL);

#endif

static void GetKeyfileData (const SecurityTokenKeyfile &keyfile, vector <byte> &keyfileData);

static list <SecurityTokenInfo> GetAvailableTokens ();

static SecurityTokenInfo GetTokenInfo (CK_SLOT_ID slotId);

static void InitLibrary (const string &pkcs11LibraryPath, auto_ptr <GetPinFunctor> pinCallback, auto_ptr <SendExceptionFunctor> warningCallback);

static bool IsInitialized () { return Initialized; }

static bool IsKeyfilePathValid (const wstring &securityTokenKeyfilePath);

#include <process.h> /* Process control */

#include <winioctl.h>

#include <stdio.h> /* For sprintf */

#endif /* _WIN32 */

#define TC_MAX_PATH 260 /* Includes the null terminator */

#endif

#define MAX_URL_LENGTH 2084 /* Internet Explorer limit. Includes the terminating null character. */

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

{

if (ci->ea == 0)

return FALSE;

{

unsigned char buf [ENCRYPTION_DATA_UNIT_SIZE * 4];

unsigned int i;

unsigned __int32 crc;

UINT64_STRUCT unitNo;

uint32 nbrUnits;

crc = GetCrc32 (buf, sizeof (buf));

{

// Verify the ciphertext of the "moving" data unit using the IEEE test vector #14

if (memcmp (XTS_vectors[XTS_TEST_COUNT-1].ciphertext,

break;

}

}

{

switch (testCase)

{

break;

}

}

{

switch (testCase)

{

break;

}

}

{

switch (testCase)

{

break;

}

}

{

switch (testCase)

{

break;

}

}

{

switch (testCase)

{

break;

}

}

{

switch (testCase)

{

break;

}

}

{

switch (testCase)

{

crc = GetCrc32 (buf, sizeof (buf));

{

if (crc != 0x33b91fab)

return FALSE;

nTestsPerformed++;

}

{

if (crc != 0x3494d480)

return FALSE;

nTestsPerformed++;

}

{

if (crc != 0xc4d65b46)

return FALSE;

nTestsPerformed++;

}

{

if (crc != 0x14ce7385)

return FALSE;

nTestsPerformed++;

}

{

if (crc != 0x0ec81bf7)

return FALSE;

nTestsPerformed++;

}

{

if (crc != 0x42f919ad)

return FALSE;

nTestsPerformed++;

}

{

if (crc != 0x208d5c58)

return FALSE;

nTestsPerformed++;

}

{

if (crc != 0xbe78cec1)

return FALSE;

return textDst;

}

{

}

{

}

{

return fputws (L"\n</VeraCrypt>", file);

}

char *XmlGetAttributeText (char *xmlNode, char *xmlAttrName, char *xmlAttrValue, int xmlAttrValueSize);

char *XmlGetNodeText (char *xmlNode, char *xmlText, int xmlTextSize);

int XmlWriteHeader (FILE *file);

int XmlWriteFooter (FILE *file);

char *XmlFindElementByAttributeValue (char *xml, char *nodeName, char *attrName, char *attrValue);

char *XmlQuoteText (const char *textSrc, char *textDst, int textDstMaxSize);

#ifdef __cplusplus

}