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;

}