try

{

auto_ptr <File> file (device ? new Device (string (szFilePathA.m_psz), !write) : new File (string (szFilePathA.m_psz), !write));

file->SeekAt (offset);

if (write)

if (result != ERROR_SUCCESS)

{

SetLastError (result);

}

}

if (result != ERROR_SUCCESS)

{

SetLastError (result);

}

}

if (result != ERROR_SUCCESS)

{

SetLastError (result);

}

}

if (result != ERROR_SUCCESS)

{

SetLastError (result);

}

if (!write)

if (result != ERROR_SUCCESS)

{

SetLastError (result);

}

}

if (result != ERROR_SUCCESS)

{

SetLastError (result);

}

}

if (result != ERROR_SUCCESS)

{

SetLastError (result);

}

}

if (result != ERROR_SUCCESS)

{

SetLastError (result);

}

}

if (IsAdmin())

{

SetLastError (ERROR_ACCESS_DENIED);

}

if (!ElevatedComInstance || ElevatedComInstanceThreadId != GetCurrentThreadId())

if (!FileOpen)

{

SetLastError (LastError);

}

if (Elevated)

if (!FileOpen)

{

SetLastError (LastError);

}

FilePointerPosition = position;

if (!FileOpen)

{

SetLastError (LastError);

}

try

}

throw ErrorException (wstring (GetString ("SYSTEM_PARTITION_NOT_ACTIVE"))

}

activePartitionFound = true;

if (!candidateForHiddenOSFound)

{

throw ErrorException (wstring (GetString ("NO_PARTITION_FOLLOWS_BOOT_PARTITION"))

}

if (config.SystemPartition.Info.PartitionLength.QuadPart > TC_MAX_FAT_SECTOR_COUNT * TC_SECTOR_SIZE_BIOS)

if ((double) candidatePartition.Info.PartitionLength.QuadPart / config.SystemPartition.Info.PartitionLength.QuadPart < MIN_HIDDENOS_DECOY_PARTITION_SIZE_RATIO_NTFS)

{

throw ErrorException (wstring (GetString ("PARTITION_TOO_SMALL_FOR_HIDDEN_OS_NTFS"))

}

}

else if ((double) candidatePartition.Info.PartitionLength.QuadPart / config.SystemPartition.Info.PartitionLength.QuadPart < MIN_HIDDENOS_DECOY_PARTITION_SIZE_RATIO_FAT)

{

throw ErrorException (wstring (GetString ("PARTITION_TOO_SMALL_FOR_HIDDEN_OS"))

}

}

else

{

// No active partition on the system drive

}

HiddenOSCandidatePartition = candidatePartition;

bool BootEncryption::SystemDriveContainsPartitionType (byte type)

{

Device device (GetSystemDriveConfiguration().DevicePath, true);

byte mbrBuf[TC_SECTOR_SIZE_BIOS];

device.SeekAt (0);

if (hiddenOSCreation)

{

Device device (GetSystemDriveConfiguration().DevicePath);

byte headerSector[TC_SECTOR_SIZE_BIOS];

device.SeekAt (HiddenOSCandidatePartition.Info.StartingOffset.QuadPart + HiddenOSCandidatePartition.Info.PartitionLength.QuadPart - TC_VOLUME_HEADER_GROUP_SIZE + TC_VOLUME_HEADER_EFFECTIVE_SIZE);

void BootEncryption::WriteBootSectorConfig (const byte newConfig[])

{

Device device (GetSystemDriveConfiguration().DevicePath);

byte mbr[TC_SECTOR_SIZE_BIOS];

device.SeekAt (0);

device.Read (mbrVerificationBuf, sizeof (mbr));

if (memcmp (mbr, mbrVerificationBuf, sizeof (mbr)) != 0)

}

void BootEncryption::WriteBootSectorUserConfig (byte userConfig, const string &customUserMessage)

{

Device device (GetSystemDriveConfiguration().DevicePath);

byte mbr[TC_SECTOR_SIZE_BIOS];

device.SeekAt (0);

device.Read (mbrVerificationBuf, sizeof (mbr));

if (memcmp (mbr, mbrVerificationBuf, sizeof (mbr)) != 0)

}

}

Device device (GetSystemDriveConfiguration().DevicePath);

byte mbr[TC_SECTOR_SIZE_BIOS];

device.SeekAt (0);

// Write MBR

Device device (GetSystemDriveConfiguration().DevicePath);

byte mbr[TC_SECTOR_SIZE_BIOS];

device.SeekAt (0);

device.Read (mbrVerificationBuf, sizeof (mbr));

if (memcmp (mbr, mbrVerificationBuf, sizeof (mbr)) != 0)

// Write boot loader

device.SeekAt (TC_SECTOR_SIZE_BIOS);

else

{

Device bootDevice (GetSystemDriveConfiguration().DevicePath, true);

bootDevice.SeekAt (TC_BOOT_VOLUME_HEADER_SECTOR_OFFSET);

bootDevice.Read (image + TC_CD_BOOTSECTOR_OFFSET + TC_BOOT_VOLUME_HEADER_SECTOR_OFFSET, TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE);

}

try

{

File sysBakFile (GetSystemLoaderBackupPath(), true);

sysBakFile.Read (image + TC_CD_BOOTSECTOR_OFFSET + TC_ORIG_BOOT_LOADER_BACKUP_SECTOR_OFFSET, TC_BOOT_LOADER_AREA_SIZE);

image[TC_CD_BOOTSECTOR_OFFSET + TC_BOOT_SECTOR_CONFIG_OFFSET] |= TC_BOOT_CFG_FLAG_RESCUE_DISK_ORIG_SYS_LOADER;

path[0] = drive;

Device driveDevice (path, true);

size_t verifiedSectorCount = (TC_CD_BOOTSECTOR_OFFSET + TC_ORIG_BOOT_LOADER_BACKUP_SECTOR_OFFSET + TC_BOOT_LOADER_AREA_SIZE) / 2048;

Buffer buffer ((verifiedSectorCount + 1) * 2048);

throw ParameterIncorrect (SRC_POS);

Device device (GetSystemDriveConfiguration().DevicePath);

device.SeekAt (TC_BOOT_VOLUME_HEADER_SECTOR_OFFSET);

device.Write ((byte *) VolumeHeader, sizeof (VolumeHeader));

void BootEncryption::BackupSystemLoader ()

{

Device device (GetSystemDriveConfiguration().DevicePath, true);

byte bootLoaderBuf[TC_BOOT_LOADER_AREA_SECTOR_COUNT * TC_SECTOR_SIZE_BIOS];

device.SeekAt (0);

byte bootLoaderBuf[TC_BOOT_LOADER_AREA_SECTOR_COUNT * TC_SECTOR_SIZE_BIOS];

File backupFile (GetSystemLoaderBackupPath(), true);

if (backupFile.Read (bootLoaderBuf, sizeof (bootLoaderBuf)) != sizeof (bootLoaderBuf))

throw ParameterIncorrect (SRC_POS);

Device device (GetSystemDriveConfiguration().DevicePath);

// Preserve current partition table

byte mbr[TC_SECTOR_SIZE_BIOS];

void BootEncryption::CheckRequirements ()

{

if (nCurrentOS == WIN_2000)

if (CurrentOSMajor == 6 && CurrentOSMinor == 0 && CurrentOSServicePack < 1)

if (IsNonInstallMode())

SystemDriveConfiguration config = GetSystemDriveConfiguration ();

if (config.SystemPartition.IsGPT)

if (SystemDriveIsDynamic())

if (config.InitialUnallocatedSpace < TC_BOOT_LOADER_AREA_SIZE)

DISK_GEOMETRY geometry = GetDriveGeometry (config.DriveNumber);

if (geometry.BytesPerSector != TC_SECTOR_SIZE_BIOS)

bool activePartitionFound = false;

if (!config.SystemPartition.IsGPT)

}

throw ErrorException (wstring (GetString ("PAGING_FILE_NOT_ON_SYS_PARTITION"))

}

// User profile

if (configPath && toupper (configPath[0]) != windowsDrive)

{

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

}

// Temporary files

if (toupper (GetTempPath()[0]) != windowsDrive)

{

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

}

}

{

// Verify CRC of header salt

Device device (config.DevicePath, true);

byte header[TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE];

device.SeekAt (TC_BOOT_VOLUME_HEADER_SECTOR_OFFSET);

catch (Exception &e)

{

e.Show (ParentWindow);

}

}

char header[TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE];

Device device (config.DevicePath);

// Only one algorithm is currently supported

if (pkcs5 != 0)

if (status != 0)

{

return status;

}

if (status != 0)

{

return status;

}

Buffer sector (geometry.BytesPerSector);

Device device (config.DevicePath);

try

{

if (!IsUacSupported())

{

SetLastError (ERROR_ACCESS_DENIED);

}

else

Elevator::CopyFile (sourceFile, destinationFile);

File (string path,bool readOnly = false, bool create = false);

virtual ~File () { Close(); }

void Close ();

DWORD Read (byte *buffer, DWORD size);

void Write (byte *buffer, DWORD size);

#include "Language.h"

#include <Strsafe.h>

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

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

not. - see DialogProc */

LPWSTR *arguments = CommandLineToArgvW (GetCommandLineW(), &argumentCount);

if (!arguments)

{

return 0;

}

int len = WideCharToMultiByte (CP_ACP, 0, arguments[i + 1], -1, arg, (int) argLen + 1, NULL, NULL);

if (len == 0)

{

AbortProcessSilent();

}

}

}

{

PWSTR lpMsgBuf;

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

return dwError;

// Access denied

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

{

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

return dwError;

}

NULL

);

LocalFree (lpMsgBuf);

// User-friendly hardware error explanation

hFixedDigitFont = CreateFontIndirectW (&lf);

if (hFixedDigitFont == NULL)

{

AbortProcess ("NOFONT");

}

hBoldFont = CreateFontIndirectW (&lf);

if (hBoldFont == NULL)

{

AbortProcess ("NOFONT");

}

hTitleFont = CreateFontIndirectW (&lf);

if (hTitleFont == NULL)

{

AbortProcess ("NOFONT");

}

hFixedFont = CreateFontIndirectW (&lf);

if (hFixedFont == NULL)

{

AbortProcess ("NOFONT");

}

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

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

{

AbortProcess ("INIT_REGISTER");

}

hDlgClass = RegisterClass (&wc);

if (hDlgClass == 0)

{

AbortProcess ("INIT_REGISTER");

}

hSplashClass = RegisterClass (&wc);

if (hSplashClass == 0)

{

AbortProcess ("INIT_REGISTER");

}

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

{

// This error is fatal e.g. because legal notices could not be displayed

AbortProcess ("INIT_RICHEDIT");

}

#ifndef SETUP

if (!EncryptionThreadPoolStart (ReadEncryptionThreadPoolFreeCpuCountLimit()))

{

if (hRichEditDll)

{

FreeLibrary (hRichEditDll);

error:

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

{

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

}

else

}

{

WCHAR szTmp[4096];

switch (code & 0x0000FFFF)

{

case ERR_OS_ERROR:

break;

case ERR_OUTOFMEMORY:

break;

case ERR_PASSWORD_WRONG:

break;

case ERR_DRIVE_NOT_FOUND:

break;

case ERR_FILES_OPEN:

break;

case ERR_FILES_OPEN_LOCK:

break;

case ERR_VOL_SIZE_WRONG:

break;

case ERR_COMPRESSION_NOT_SUPPORTED:

break;

case ERR_PASSWORD_CHANGE_VOL_TYPE:

break;

case ERR_VOL_SEEKING:

break;

case ERR_CIPHER_INIT_FAILURE:

break;

case ERR_CIPHER_INIT_WEAK_KEY:

break;

case ERR_VOL_ALREADY_MOUNTED:

break;

case ERR_FILE_OPEN_FAILED:

break;

case ERR_VOL_MOUNT_FAILED:

break;

case ERR_NO_FREE_DRIVES:

break;

case ERR_ACCESS_DENIED:

break;

case ERR_DRIVER_VERSION:

break;

case ERR_NEW_VERSION_REQUIRED:

break;

case ERR_SELF_TESTS_FAILED:

case ERR_UNSUPPORTED_TRUECRYPT_FORMAT:

StringCbPrintfW (szTmp, sizeof(szTmp), GetString ("UNSUPPORTED_TRUECRYPT_FORMAT"), (code >> 24), (code >> 16) & 0x000000FF);

break;

#ifndef SETUP

case ERR_RAND_INIT_FAILED:

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

break;

case ERR_CAPI_INIT_FAILED:

StringCbPrintfW (szTmp, sizeof(szTmp), GetString ("CAPI_RAND"), SRC_POS, CryptoAPILastError);

break;

#endif

default:

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

}

}

#ifndef VOLFORMAT

if (Randinit ())

{

EndDialog (hwndDlg, IDCLOSE);

}

#endif

{

TCfree(keyfile);

NormalCursor();

return 1;

}

{

TCfree(keyfile);

NormalCursor();

return 1;

}

}

if ((tmpRetVal = EAInit (ci->ea, (unsigned char *) key, ci->ks)) != ERR_SUCCESS)

{

crypto_close (ci);

return 1;

}

if (bResult == FALSE)

{

return 1;

}

}

if (!quiet && (!MultipleMountOperationInProgress || GetLastError() != ERROR_NOT_READY))

return -1;

}

if (DeviceIoControl (hDriver, TC_IOCTL_OPEN_TEST, &openTestStruct, sizeof (OPEN_TEST_STRUCT), &openTestStruct, sizeof (OPEN_TEST_STRUCT), &dwResult, NULL) && openTestStruct.TCBootLoaderDetected)

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

else

}

}

else

}

return 0;

}

if (!quiet)

return 0;

}

{

if (!silent)

{

Error ("CANNOT_CALC_SPACE", MainDlg);

}

{

if (!silent)

{

Error ("CANT_GET_VOLSIZE", MainDlg);

}

return -1;

if (dst == INVALID_HANDLE_VALUE)

{

SetLastError (dwLastError);

return FALSE;

}

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

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

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

}

CloseHandle (dst);

if (GetWindowTextW (GetDlgItem (hwndDlg, IDC_TOKEN_PASSWORD), passwordWide, SecurityToken::MaxPasswordLength + 1) == 0)

{

break;

}

byte *keyfileData = (byte *) LoadFile (keyfilePath, &keyfileSize);

if (!keyfileData)

{

return 1;

}

else

{

SetLastError (ERROR_HANDLE_EOF);

}

burn (keyfileData, keyfileSize);

if (keyfileData.empty())

{

SetLastError (ERROR_HANDLE_EOF);

return 1;

}

finally_do_arg (vector <byte> *, &keyfileData, { burn (&finally_arg->front(), finally_arg->size()); });

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

}

Info ("KEYFILE_EXPORTED", hwndDlg);

FILE *f = fopen (cmdBatch, "w");

if (!f)

{

return FALSE;

}

f = fopen (diskpartScript, "w");

if (!f)

{

DeleteFile (cmdBatch);

return FALSE;

}

if (r <= 32)

{

SetLastError (r);

return FALSE;

}

void AbortProcessSilent ( void );

void *err_malloc ( size_t size );

char *err_strdup ( char *lpszText );

BOOL IsDiskReadError (DWORD error);

BOOL IsDiskWriteError (DWORD error);

BOOL IsDiskError (DWORD error);

void ResetCurrentDirectory ();

BOOL BrowseFiles (HWND hwndDlg, char *stringId, char *lpszFileName, BOOL keepHistory, BOOL saveMode, wchar_t *browseFilter);

BOOL BrowseDirectories (HWND hWnd, char *lpszTitle, char *dirName);

BOOL CheckFileStreamWriteErrors (HWND hwndDlg, FILE *file, const char *fileName);

void LocalizeDialog ( HWND hwnd, char *stringId );

void OpenVolumeExplorerWindow (int driveNo);

std::string GetUserFriendlyVersionString (int version);

std::string IntToString (int val);

std::wstring IntToWideString (int val);

// Display a wait dialog while calling the provided callback with the given parameter

typedef void (CALLBACK* WaitThreadProc)(void* pArg, HWND hWaitDlg);

#include "Platform/PlatformBase.h"

#include "Dlgcode.h"

#include <strsafe.h>

namespace VeraCrypt

struct SystemException : public Exception

{

void Show (HWND parent) const

{

SetLastError (ErrorCode);

}

DWORD ErrorCode;

};

struct ErrorException : public Exception

{

void Show (HWND parent) const

{

if (ErrMsg.empty())

else

}

char *ErrLangId;

wstring ErrMsg;

};

struct TimeOut : public Exception

{

};

struct UserAbort : public Exception

};

}

#endif // TC_HEADER_Common_Exception

#include <Strsafe.h>

int FormatWriteBufferSize = 1024 * 1024;

static uint32 FormatSectorSize = 0;

}

else

{

Error ("CANT_ACCESS_VOL", hwndDlg);

nStatus = ERR_DONT_REPORT;

goto error;

{

if (WaitForSingleObject (WriteBufferFullEvent, INFINITE) == WAIT_FAILED)

{

break;

}

if (!SetEvent (WriteBufferEmptyEvent))

{

break;

}

}

if (keyfileData.empty())

{

SetLastError (ERROR_HANDLE_EOF);

Error ("ERR_PROCESS_KEYFILE", hwndDlg);

status = FALSE;

continue;

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

if (stat (kf->FileName, &statStruct) != 0)

{

Error ("ERR_PROCESS_KEYFILE", hwndDlg);

status = FALSE;

continue;

StringCbPrintfA (searchPath, sizeof (searchPath), "%s\\*.*", kf->FileName);

if ((searchHandle = _findfirst (searchPath, &fBuf)) == -1)

{

Error ("ERR_PROCESS_KEYFILE_PATH", hwndDlg);

status = FALSE;

continue;

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

if (stat (kfSub->FileName, &statStruct) != 0)

{

Error ("ERR_PROCESS_KEYFILE", hwndDlg);

status = FALSE;

continue;

// Apply keyfile to the pool

if (!KeyFileProcess (keyPool, kfSub))

{

Error ("ERR_PROCESS_KEYFILE", hwndDlg);

status = FALSE;

}

// Apply keyfile to the pool

else if (!KeyFileProcess (keyPool, kf))

{

Error ("ERR_PROCESS_KEYFILE", hwndDlg);

status = FALSE;

}

packages.

*/

#include <windows.h>

#ifdef __cplusplus

#include <io.h>

void VerifyPasswordAndUpdate (HWND hwndDlg, HWND hButton, HWND hPassword,

HWND hVerify, unsigned char *szPassword,

char *szVerify,

if ((wipePassCount <= 0) || (truecryptMode && (old_pkcs5 == SHA256)))

{

nStatus = ERR_PARAMETER_INCORRECT;

return nStatus;

}

if (!lpszVolume)

{

nStatus = ERR_OUTOFMEMORY;

return nStatus;

}

return nStatus;

if (nStatus != 0)

return nStatus;

}

#include <tlhelp32.h>

#include "Dlgcode.h"

HHOOK hMouse = NULL; /* Mouse hook for the random number generator */

HHOOK hKeyboard = NULL; /* Keyboard hook for the random number generator */

}

hKeyboard = SetWindowsHookEx (WH_KEYBOARD, (HOOKPROC)&KeyboardProc, NULL, GetCurrentThreadId ());

hMouse = SetWindowsHookEx (WH_MOUSE, (HOOKPROC)&MouseProc, NULL, GetCurrentThreadId ());

if (hMouse == 0)

{

goto error;

}

{

if (!SlowPoll ())

{

ret = FALSE;

}

else

if (!FastPoll ())

{

ret = FALSE;

}

pProgressDlgParam->hwndDlg = hwndDlg;

if ( _beginthread (volTransformThreadFunction, 0, pProgressDlgParam) == -1L )

{

EndDialog (hwndDlg, lw);

}

WaitCursor();

NormalCursor();

}

WaitCursor();

error:

if (nStatus != 0)

burn (&VolumePassword, sizeof (VolumePassword));

#include "ExpandVolume.h"

#include "Resource.h"

#define DEBUG_EXPAND_VOLUME

#ifdef DEBUG_EXPAND_VOLUME

pParam->VolumePkcs5, pParam->VolumePin, pParam->newSize, pParam->bInitFreeSpace );

if (nStatus!=ERR_SUCCESS && nStatus!=ERR_USER_ABORT)

bVolTransformThreadCancel = FALSE;

#include "InitDataArea.h"

int FormatWriteBufferSize = 1024 * 1024;

static uint32 FormatSectorSize = 0;

{

if (WaitForSingleObject (WriteBufferFullEvent, INFINITE) == WAIT_FAILED)

{

break;

}

if (!SetEvent (WriteBufferEmptyEvent))

{

break;

}

}

if (status != 0)

{

if (status == ERR_OS_ERROR)

else

AbortProcess ("NODRIVER");

}

NULL))

{

if (!silent)

return -1;

}

{

SetLastError (ERROR_INTERNAL_ERROR);

if (!silent)

return -1;

}

{

if (!silent)

{

Error ("INPLACE_ENC_CANT_ACCESS_OR_GET_INFO_ON_VOL", hwndDlg);

}

return FALSE;

&dwResult,

NULL))

{

ShowInPlaceEncErrMsgWAltSteps (hwndDlg, "INPLACE_ENC_CANT_ACCESS_OR_GET_INFO_ON_VOL_ALT", TRUE);

nStatus = ERR_DONT_REPORT;

goto closing_seq;

&dwResult,

NULL))

{

ShowInPlaceEncErrMsgWAltSteps (hwndDlg, "CANNOT_RESIZE_FILESYS", TRUE);

nStatus = ERR_DONT_REPORT;

goto closing_seq;

continue;

}

}

}

else

ShowInPlaceEncErrMsgWAltSteps (hwndDlg, "CANNOT_RESIZE_FILESYS", TRUE);

nStatus = ERR_DONT_REPORT;

if (driveLetter == -1

|| !UnmountVolume (hwndDlg, driveLetter, TRUE))

{

AbortProcess ("CANT_DISMOUNT_VOLUME");

}

}

{

if (!bSilent)

{

if (bShowAlternativeSteps)

ShowInPlaceEncErrMsgWAltSteps (hwndDlg, "INPLACE_ENC_CANT_ACCESS_OR_GET_INFO_ON_VOL_ALT", TRUE);

{

if (!bSilent)

{

if (bShowAlternativeSteps)

ShowInPlaceEncErrMsgWAltSteps (hwndDlg, "INPLACE_ENC_CANT_ACCESS_OR_GET_INFO_ON_VOL_ALT", TRUE);

}

else

{

}

break;

if (f == NULL)

{

Error ("CANNOT_SAVE_SYS_ENCRYPTION_SETTINGS", hwndDlg);

return FALSE;

}

|| XmlWriteFooter (f) < 0)

{

fclose (f);

Error ("CANNOT_SAVE_SYS_ENCRYPTION_SETTINGS", hwndDlg);

return FALSE;

wchar_t szMsg[8192];

if (bInPlaceEncNonSys)

{

if (!GetVolumePathName (szFileName, root, sizeof (root)))

{

return FALSE;

}

nVolumeSize = GetDeviceSize (szDiskFile);

if (nVolumeSize == -1)

{

return 1;

}

if (!ComServerFormat ())

{

exit (1);

}

exit (0);

if (nVolumeSize == -1)

{

return 1;

}

nVolumeSize = GetDeviceSize (szDiskFile);

if (nVolumeSize == -1)

{

NormalCursor();

return 1;

}

if (driveNo == -1

|| !UnmountVolume (hwndDlg, driveNo, TRUE))

{

AbortProcess ("CANT_DISMOUNT_VOLUME");

}

}

volProp.driveNo = driveNo;

if (!DeviceIoControl (hDriver, TC_IOCTL_GET_VOLUME_PROPERTIES, &volProp, sizeof (volProp), &volProp, sizeof (volProp), &dwResult, NULL) || dwResult == 0)

{

UnmountVolume (hwndDlg, driveNo, TRUE);

AbortProcess ("CANT_GET_VOL_INFO");

}

if (!UnmountVolume (hwndDlg, driveNo, TRUE))

{

AbortProcess ("CANT_DISMOUNT_VOLUME");

}

if (!UnmountVolume (hwndDlg, driveNo, TRUE))

{

AbortProcess ("CANT_DISMOUNT_VOLUME");

}

nVolumeSize = GetDeviceSize (szDiskFile);

if (nVolumeSize == -1)

{

AbortProcessSilent ();

}

volProp.driveNo = *driveNo;

if (!DeviceIoControl (hDriver, TC_IOCTL_GET_VOLUME_PROPERTIES, &volProp, sizeof (volProp), &volProp, sizeof (volProp), &dwResult, NULL) || dwResult == 0)

{

Error ("CANT_ACCESS_OUTER_VOL", hwndDlg);

goto efsf_error;

}

if (SetFilePointerEx (hDevice, offset, &offsetNew, FILE_BEGIN) == 0)

{

goto efs_error;

}

if (result == 0)

{

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

goto efs_error;

}

&dwNumberOfFreeClusters,

&dwTotalNumberOfClusters))

{

Error ("CANT_GET_OUTER_VOL_INFO", hwndDlg);

return -1;

};

&lBytesReturned,

NULL))

{

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

goto vcm_error;

if (status != 0)

{

if (status == ERR_OS_ERROR)

else

AbortProcess ("NODRIVER");

}

if (!GetDriveGeometry (szDiskFile, &geometry))

{

AbortProcessSilent();

}

if (!DeviceIoControl (hDriver, TC_IOCTL_GET_VOLUME_PROPERTIES, &prop, sizeof (prop), &prop, sizeof (prop), &bytesReturned, NULL))

{

return FALSE;

}

BootEncryptionStatus bootEncStatus = BootEncryption (hwndDlg).GetStatus();

if (!bootEncStatus.DriveMounted)

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

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

f = fopen (GetConfigPath (systemFavorites ? TC_APPD_FILENAME_SYSTEM_FAVORITE_VOLUMES : TC_APPD_FILENAME_FAVORITE_VOLUMES), "w,ccs=UTF-8");

if (f == NULL)

{

return false;

}

#include <Strsafe.h>

#define MAX_KEY_COMB_NAME_LEN 260

TCHOTKEY Hotkeys [NBR_HOTKEYS];

if (!bOwnActiveShortcut

&& !RegisterHotKey (hwndDlg, nSelectedHotkeyId, modifiers, currentVKeyCode))

{

return 1;

}

else

{

if (!bOwnActiveShortcut && !UnregisterHotKey (hwndDlg, nSelectedHotkeyId))

tmpHotkeys[nSelectedHotkeyId].vKeyCode = currentVKeyCode;

tmpHotkeys[nSelectedHotkeyId].vKeyModifiers = modifiers;

if (!CreateProcess (NULL, (LPSTR) t, NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS, NULL, NULL, &si, &pi))

{

}

else

{

Error ("VOL_EXPANDER_NOT_FOUND", hwndDlg); // Display a user-friendly error message and advise what to do

else if (((int)ShellExecuteA (NULL, (!IsAdmin() && IsUacSupported()) ? "runas" : "open", t, NULL, NULL, SW_SHOW)) <= 32)

{

}

}

}

if (bResult == FALSE)

{

KillTimer (MainDlg, TIMER_ID_MAIN);

AbortProcessSilent();

}

StringCbPrintfA (dstPath, sizeof(dstPath), "%s\\VeraCrypt\\VeraCrypt.exe", dstDir);

if (!TCCopyFile (srcPath, dstPath))

{

goto stop;

}

StringCbPrintfA (dstPath, sizeof(dstPath), "%s\\VeraCrypt\\VeraCrypt Format.exe", dstDir);

if (!TCCopyFile (srcPath, dstPath))

{

goto stop;

}

}

StringCbPrintfA (dstPath, sizeof(dstPath), "%s\\VeraCrypt\\veracrypt.sys", dstDir);

if (!TCCopyFile (srcPath, dstPath))

{

goto stop;

}

StringCbPrintfA (dstPath, sizeof(dstPath), "%s\\VeraCrypt\\veracrypt-x64.sys", dstDir);

if (!TCCopyFile (srcPath, dstPath))

{

goto stop;

}

if (!VolumePathExists (szFileName))

{

if (!MultipleMountOperationInProgress)

status = FALSE;

goto ret;

if (bResult == FALSE)

{

NormalCursor();

return FALSE;

}

if (!VolumePathExists (szFileName))

{

return;

}

if (!DeviceIoControl (hDriver, TC_IOCTL_GET_VOLUME_PROPERTIES, &prop, sizeof (prop), &prop, sizeof (prop), &bytesReturned, NULL))

{

return;

}

return;

if (bResult == FALSE)

else

{

EnableDisableButtons (hwndDlg);

if (!ComServerMain ())

{

exit (1);

}

exit (0);

if (!VolumePathExists (szFileName))

{

}

else

{

if (status != 0)

{

if (status == ERR_OS_ERROR)

else

AbortProcess ("NODRIVER");

}

f = fopen (GetConfigPath (TC_APPD_FILENAME_DEFAULT_KEYFILES), "w");

if (f == NULL)

{

return;

}

if (!lpszVolume)

{

nStatus = ERR_OUTOFMEMORY;

return nStatus;

}

if (!VolumePathExists (lpszVolume))

{

goto ret;

}

|| (type == TC_VOLUME_TYPE_HIDDEN && !askVol->CryptoInfo->hiddenVolume))

{

CloseVolume (askVol);

continue;

}

if (nStatus != ERR_PASSWORD_WRONG)

goto error;

}

}

noHidden:

SetLastError (dwError);

if (nStatus != 0)

burn (&VolumePassword, sizeof (VolumePassword));

burn (&VolumePkcs5, sizeof (VolumePkcs5));

if (!lpszVolume)

{

nStatus = ERR_OUTOFMEMORY;

return nStatus;

}

if (!VolumePathExists (lpszVolume))

{

return 0;

}

if (nStatus != ERR_PASSWORD_WRONG)

goto error;

}

if (volume.CryptoInfo->LegacyVolume)

if (nStatus != ERR_PASSWORD_WRONG)

goto error;

}

BOOL hiddenVol = restoredCryptoInfo->hiddenVolume;

SetLastError (dwError);

if (nStatus != 0)

burn (&VolumePassword, sizeof (VolumePassword));

burn (&VolumePkcs5, sizeof (VolumePkcs5));

DWORD bytesReturned;

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

EnableHwEncryption (!disableHW);

#include "Resource.h"

#include <Strsafe.h>

#define OutputPackageFile "VeraCrypt Setup " VERSION_STRING ".exe"

#define MAG_START_MARKER "TCINSTRT"

if (!TCCopyFile (inputFile, outputFile))

{

PkgError ("Cannot copy 'VeraCrypt Setup.exe' to the package");

goto err;

}

if (tmpBuffer == NULL)

{

if (remove (outputFile))

PkgError ("Cannot load the package to compute CRC.\nFailed also to delete package file");

else

{

wchar_t szTmp[TC_MAX_PATH];

StringCbPrintfW (szTmp, sizeof(szTmp), GetString ("CANT_CREATE_FOLDER"), DestExtractPath);

MessageBoxW (hwndDlg, szTmp, lpszTitle, MB_ICONHAND);

bSuccess = FALSE;

// Dump filter driver cannot be installed to SysWOW64 directory

if (driver64 && !EnableWow64FsRedirection (FALSE))

{

bResult = FALSE;

goto err;

}

{

if (!EnableWow64FsRedirection (TRUE))

{

bResult = FALSE;

goto err;

}

if (bOK == FALSE)

{

Error ("REG_INSTALL_FAILED", hwndDlg);

}

RemoveMessage (hwndDlg, path);

if (!StatRemoveDirectory (path))

{

bOK = FALSE;

}

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

{

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

}

else

{

if (status == ERR_OS_ERROR && GetLastError () != ERROR_FILE_NOT_FOUND)

{

AbortProcess ("NODRIVER");

}

if (status != ERR_OS_ERROR)

{

AbortProcess ("NODRIVER");

}

}

else

{

bOK = FALSE;

}

}

// Start menu group

RemoveMessage ((HWND) hwndDlg, szLinkDir);

if (StatRemoveDirectory (szLinkDir) == FALSE)

// Desktop icon

{

wchar_t szTmpW[TC_MAX_PATH];

StringCbPrintfW (szTmpW, sizeof(szTmpW), GetString ("CANT_CREATE_FOLDER"), szLinkDir);

MessageBoxW (hwndDlg, szTmpW, lpszTitle, MB_ICONHAND);

goto error;

{

wchar_t szTmp[TC_MAX_PATH];

StringCbPrintfW (szTmp, sizeof(szTmp), GetString ("CANT_CREATE_FOLDER"), InstallationPath);

MessageBoxW (hwndDlg, szTmp, lpszTitle, MB_ICONHAND);

Error ("INSTALL_FAILED", hwndDlg);

{

if (!DisablePagingFile())

{

Error ("FAILED_TO_DISABLE_PAGING_FILES", hwndDlg);

}

else