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

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

return ERROR_SUCCESS;

}

DWORD BaseCom::RegisterFilterDriver (BOOL registerDriver, int filterType)

{

return ERROR_SUCCESS;

}

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

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

{

public:

RefCount (1), ServerLockCount (0), MessageThreadId (messageThreadId) { }

~TrueCryptFactory () { }

virtual ULONG STDMETHODCALLTYPE AddRef ()

{

return InterlockedIncrement (&RefCount) - 1;

AddRef ();

return S_OK;

}

virtual HRESULT STDMETHODCALLTYPE CreateInstance (IUnknown *pUnkOuter, REFIID riid, void **ppvObject)

{

if (pUnkOuter != NULL)

static DWORD RegisterSystemFavoritesService (BOOL registerService);

static DWORD SetDriverServiceStartType (DWORD startType);

static DWORD WriteLocalMachineRegistryDwordValue (BSTR keyPath, BSTR valueName, DWORD value);

};

#include "Random.h"

#include "Registry.h"

#include "Volumes.h"

#ifdef VOLFORMAT

#include "Format/FormatCom.h"

class Elevator

{

public:

static void AddReference ()

{

++ReferenceCount;

memcpy (buffer, (BYTE *) bufferBstr.m_str, size);

}

static BOOL IsPagingFileActive (BOOL checkNonWindowsPartitionsOnly)

{

Elevate();

}

}

static void Release ()

{

if (--ReferenceCount == 0 && ElevatedComInstance)

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,

}

}

void File::Write (byte *buffer, DWORD size)

{

DWORD bytesWritten;

}

}

void Show (HWND parent, const wstring &str)

{

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

FilePointerPosition = 0;

IsDevice = true;

Path = path;

}

BootEncryption::BootEncryption (HWND parent)

: DriveConfigValid (false),

bool activePartitionFound = false;

bool candidateForHiddenOSFound = false;

{

{

{

{

{

{

}

}

}

}

}

}

/* WARNING: Note that the partition number at the end of a device path (\Device\HarddiskY\PartitionX) must

NOT be used to find the first partition physically located behind the active one. The reason is that the

user may have deleted and created partitions during this session and e.g. the second partition could have

int ea = 0;

int pkcs5_prf = 0;

if (GetStatus().DriveMounted)

{

try

pkcs5_prf = SelectedPrfAlgorithmId;

}

throw ParameterIncorrect (SRC_POS);

int bootSectorId = 0;

}

}

{

throw ParameterIncorrect (SRC_POS);

try

{

}

}

catch (...)

{

if (config)

*config = 0;

if (userConfig)

*userConfig = 0;

if (customUserMessage)

customUserMessage->clear();

if (bootLoaderVersion)

*bootLoaderVersion = 0;

}

}

throw ErrorException ("ERROR_MBR_PROTECTED", SRC_POS);

}

{

{

}

{

}

{

}

else

}

ZeroMemory (&request, sizeof (request));

request.WipeAlgorithm = wipeAlgorithm;

if (Randinit() != ERR_SUCCESS)

{

if (CryptoAPILastError == ERROR_SUCCESS)

CallDriver (TC_IOCTL_ABORT_DECOY_SYSTEM_WIPE);

}

DecoySystemWipeStatus BootEncryption::GetDecoyOSWipeStatus ()

{

DecoySystemWipeStatus status;

device.SeekAt (0);

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

finally_do_arg (BootEncryption *, this,

{

try

#endif // !SETUP

{

Device device (GetSystemDriveConfiguration().DevicePath);

device.CheckOpened (SRC_POS);

}

{

{

{

{

}

}

}

}

#ifndef SETUP

bool BootEncryption::CheckBootloaderFingerprint (bool bSilent)

{

byte bootLoaderBuf[TC_BOOT_LOADER_AREA_SIZE - TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE] = {0};

byte fingerprint[WHIRLPOOL_DIGESTSIZE + SHA512_DIGESTSIZE];

byte expectedFingerprint[WHIRLPOOL_DIGESTSIZE + SHA512_DIGESTSIZE];

WCHAR pathBuf[MAX_PATH];

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

wstring path = wstring (pathBuf) + L"\\" _T(TC_APP_NAME);

CreateDirectory (path.c_str(), NULL);

throw ParameterIncorrect (SRC_POS);

Buffer imageBuf (RescueIsoImageSize);

byte *image = imageBuf.Ptr();

memset (image, 0, RescueIsoImageSize);

File sysBakFile (GetSystemLoaderBackupPath(), true);

sysBakFile.CheckOpened (SRC_POS);

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;

}

catch (Exception &e)

e.Show (ParentWindow);

Warning ("SYS_LOADER_UNAVAILABLE_FOR_RESCUE_DISK", ParentWindow);

}

// Boot loader backup

CreateBootLoaderInMemory (image + TC_CD_BOOTSECTOR_OFFSET + TC_BOOT_LOADER_BACKUP_RESCUE_DISK_SECTOR_OFFSET, TC_BOOT_LOADER_AREA_SIZE, false);

UINT driveType = GetDriveType (rootPath);

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

{

rootPath[2] = 0; // remove trailing backslash

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

DWORD bytesRead = isoFile.Read (buffer.Ptr(), (DWORD) buffer.Size());

&& (memcmp (buffer.Ptr(), RescueIsoImage, buffer.Size()) == 0)

)

{

}

void BootEncryption::BackupSystemLoader ()

{

{

}

}

}

void BootEncryption::RestoreSystemLoader ()

{

}

#endif // SETUP

RegisterSystemFavoritesService (registerService, FALSE);

}

void BootEncryption::CheckRequirements ()

{

if (nCurrentOS == WIN_2000)

throw ErrorException ("SYS_ENCRYPTION_UNSUPPORTED_ON_CURRENT_OS", SRC_POS);

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

throw ErrorException ("SYS_ENCRYPTION_UNSUPPORTED_ON_VISTA_SP0", SRC_POS);

SystemDriveConfiguration config = GetSystemDriveConfiguration ();

throw ErrorException ("GPT_BOOT_DRIVE_UNSUPPORTED", SRC_POS);

if (SystemDriveIsDynamic())

throw ErrorException ("SYSENC_UNSUPPORTED_SECTOR_SIZE_BIOS", SRC_POS);

bool activePartitionFound = false;

{

// Determine whether there is an Active partition on the system drive

foreach (const Partition &partition, config.Partitions)

if (!pagingFilesOk)

{

+ GetString ("LEAKS_OUTSIDE_SYSPART_UNIVERSAL_EXPLANATION")

+ L"\n\n\n"

+ GetString ("RESTRICT_PAGING_FILES_TO_SYS_PARTITION")

AbortProcessSilent();

}

+ GetString ("LEAKS_OUTSIDE_SYSPART_UNIVERSAL_EXPLANATION"), SRC_POS);

}

wchar_t *configPath = GetConfigPath (L"dummy");

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

{

+ GetString ("LEAKS_OUTSIDE_SYSPART_UNIVERSAL_EXPLANATION"), SRC_POS);

}

// Temporary files

if (towupper (GetTempPathString()[0]) != windowsDrive)

{

+ GetString ("LEAKS_OUTSIDE_SYSPART_UNIVERSAL_EXPLANATION"), SRC_POS);

}

}

SystemDriveConfiguration config = GetSystemDriveConfiguration ();

try

{

device.Read ((byte *) header, sizeof (header));

PCRYPTO_INFO cryptoInfo = NULL;

int status = ReadVolumeHeader (!encStatus.HiddenSystem, header, oldPassword, old_pkcs5, old_pim, FALSE, &cryptoInfo, NULL);

finally_do_arg (PCRYPTO_INFO, cryptoInfo, { if (finally_arg) crypto_close (finally_arg); });

UserEnrichRandomPool (hwndDlg);

WaitCursor();

techniques such as magnetic force microscopy or magnetic force scanning tunnelling microscopy

to recover the overwritten header. According to Peter Gutmann, data should be overwritten 22

times (ideally, 35 times) using non-random patterns and pseudorandom data. However, as users might

try

{

// check if PIM is stored in MBR

storedPimUpdateNeeded = true;

}

catch (...)

}

try

{

// force update of bootloader if fingerprint doesn't match or if the stored PIM changed

if (storedPimUpdateNeeded || !CheckBootloaderFingerprint (true))

}

catch (...)

{}

}

{

BootEncryptionStatus encStatus = GetStatus();

if (encStatus.DriveMounted)

try

{

if (!hiddenSystem)

InstallVolumeHeader ();

SelectedEncryptionAlgorithmId = ea;

SelectedPrfAlgorithmId = pkcs5;

CreateVolumeHeader (volumeSize, encryptedAreaStart, &password, ea, mode, pkcs5, pim);

if (!rescueIsoImagePath.empty())

CreateRescueIsoImage (true, rescueIsoImagePath);

}

BootEncryptionSetupRequest request;

ZeroMemory (&request, sizeof (request));

request.SetupMode = SetupDecryption;

request.DiscardUnreadableEncryptedSectors = discardUnreadableEncryptedSectors;

BootEncryptionSetupRequest request;

ZeroMemory (&request, sizeof (request));

request.SetupMode = SetupEncryption;

request.WipeAlgorithm = wipeAlgorithm;

request.ZeroUnreadableSectors = zeroUnreadableSectors;

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

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

#include "Exception.h"

#include "Platform/PlatformBase.h"

#include "Volumes.h"

using namespace std;

class File

{

public:

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

virtual ~File () { Close(); }

DWORD Read (byte *buffer, DWORD size);

void Write (byte *buffer, DWORD size);

void SeekAt (int64 position);

protected:

bool Elevated;

bool FileOpen;

uint64 FilePointerPosition;

HANDLE Handle;

bool IsDevice;

bool SystemLoaderPresent;

};

class BootEncryption

{

public:

BootEncryptionStatus GetStatus ();

void GetVolumeProperties (VOLUME_PROPERTIES_STRUCT *properties);

SystemDriveConfiguration GetSystemDriveConfiguration ();

bool CheckBootloaderFingerprint (bool bSilent = false);

void InvalidateCachedSysDriveProperties ();

bool IsCDRecorderPresent ();

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

void PrepareInstallation (bool systemPartitionOnly, Password &password, int ea, int mode, int pkcs5, int pim, const wstring &rescueIsoImagePath);

void ProbeRealSystemDriveSize ();

uint32 ReadDriverConfigurationFlags ();

void RegisterBootDriver (bool hiddenSystem);

void RegisterFilterDriver (bool registerDriver, FilterType filterType);

void RegisterSystemFavoritesService (BOOL registerService);

void WipeHiddenOSCreationConfig ();

void WriteBootDriveSector (uint64 offset, byte *data);

void WriteBootSectorConfig (const byte newConfig[]);

void WriteLocalMachineRegistryDwordValue (wchar_t *keyPath, wchar_t *valueName, DWORD value);

protected:

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

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

wstring GetSystemLoaderBackupPath ();

PartitionList GetDrivePartitions (int driveNumber);

wstring GetRemarksOnHiddenOS ();

wstring GetWindowsDirectory ();

void InstallVolumeHeader ();

HWND ParentWindow;

/*

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

governed by the TrueCrypt License 3.0, also from the source code of

Encryption for the Masses 2.02a, which is Copyright (c) 1998-2000 Paul Le Roux

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

BOOL bHistory = FALSE;

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

OSVersionEnum nCurrentOS = WIN_UNKNOWN;

int CurrentOSMajor = 0;

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

BOOL PimEnable = FALSE;

BOOL KeyFilesEnable = FALSE;

KeyFile *FirstKeyFile = NULL;

HANDLE hDriver = INVALID_HANDLE_VALUE;

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

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

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

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

(others may still read it though). */

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

WipeAlgorithmId nWipeMode = TC_WIPE_NONE;

BENCHMARK_SORT_BY_SPEED

};

{

int id;

wchar_t name[100];

#endif // #ifndef SETUP

{

void *strings;

BOOL bold;

DWORD handleWin32Error (HWND hwndDlg, const char* srcPos)

{

PWSTR lpMsgBuf;

wchar_t szErrorValue[32];

wchar_t* pszDesc;

{

SIZE sizes;

TEXTMETRIC textMetrics;

SelectObject(hdc, (HGDIOBJ) hFont);

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

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

}

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

{

SIZE sizes;

SelectObject(hdc, (HGDIOBJ) hFont);

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

return ((int) sizes.cy);

}

rect.right = width;

rect.bottom = LONG_MAX;

SelectObject (hdc, (HGDIOBJ) hFont);

wchar_t pathBuf[TC_MAX_PATH];

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

newPath = pathBuf;

return newPath;

}

width = GetTextGfxWidth (hwndCtrl, text, hFont);

height = GetTextGfxHeight (hwndCtrl, text, hFont);

origWidth = rec.right;

origHeight = rec.bottom;

if (width >= 0

{

horizSubOffset = origWidth - width;

vertSubOffset = origHeight - height;

alignPosDiff = horizSubOffset / 2;

else if (windowInfo.dwStyle & SS_RIGHT)

alignPosDiff = horizSubOffset;

// Resize/move

if (alignPosDiff > 0)

{

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

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

void ToBootPwdField (HWND hwndDlg, UINT ctrlId)

{

if (hDC)

{

ScreenDPI = GetDeviceCaps (hDC, LOGPIXELSY);

}

DPIScaleFactorX = 1;

if (ScreenDPI != USER_DEFAULT_SCREEN_DPI)

{

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

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

// sizes of a hidden calibration text field.

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

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

if (ScreenDPI != USER_DEFAULT_SCREEN_DPI)

{

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

void ProcessPaintMessages (HWND hwnd, int maxMessagesToProcess)

{

MSG paintMsg;

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

{

}

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

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

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

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

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

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

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

{

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

if (hdcRescaled)

{

SelectObject (hdcRescaled, hbmpRescaled);

hdcSrc,

0,

0,

bitmap.bmHeight,

SRCCOPY);

wc.hCursor = NULL;

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

wc.lpszClassName = L"VCREDTICK";

rc = (ULONG) RegisterClassW (&wc);

return rc == 0 ? FALSE : TRUE;

{

if (!bHeaderWipe)

{

}

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

else

lpack[0] = 0;

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

, lpack

, GetWindowsEdition().c_str()

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

}

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

BOOL CreateSysEncMutex (void)

{

return TCCreateMutex (&hSysEncMutex, TC_MUTEX_NAME_SYSENC);

}

BOOL CreateNonSysInplaceEncMutex (void)

{

return TCCreateMutex (&hNonSysInplaceEncMutex, TC_MUTEX_NAME_NONSYS_INPLACE_ENC);

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

BOOL NonSysInplaceEncInProgressElsewhere (void)

{

&& MutexExistsOnSystem (TC_MUTEX_NAME_NONSYS_INPLACE_ENC));

}

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

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

BOOL CreateDriverSetupMutex (void)

{

return TCCreateMutex (&hDriverSetupMutex, TC_MUTEX_NAME_DRIVER_SETUP);

}

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

{

if (*hMutex != NULL)

}

BOOL MutexExistsOnSystem (wchar_t *name)

{

if (name[0] == 0)

return FALSE;

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

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

return FALSE;

void InitApp (HINSTANCE hInstance, wchar_t *lpszCommandLine)

{

WNDCLASSW wc;

/* remove current directory from dll search path */

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

if (SetDefaultDllDirectoriesFn)

SetDefaultDllDirectoriesFn (LOAD_LIBRARY_SEARCH_SYSTEM32);

VirtualLock (&CmdTokenPin, sizeof (CmdTokenPin));

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

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

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

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

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

}

if (IsOSAtLeast (WIN_VISTA))

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

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

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

}

if (IsOSAtLeast (WIN_VISTA))

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

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

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

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

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

}

#else

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

#endif

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

// call InitCommonControls function

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

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

// Language

langId[0] = 0;

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

if (langId[0] == 0)

{

if (IsNonInstallMode ())

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

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

{

if (wcsstr (lpszCommandLine, L"/q UAC ") == lpszCommandLine)

{

exit (1);

}

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

exit (1);

}

#endif

break;

}

}

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

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

{

&dwResult, NULL);

// check variable driver

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

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

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

else

return FALSE;

}

return TRUE;

}

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

in SysDriveDevicePath.

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

selected the system partition/device.

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

BOOL GetSysDevicePaths (HWND hwndDlg)

{

if (!bCachedSysDevicePathsValid

|| wcslen (SysDriveDevicePath) <= 1)

{

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

{

if (device.ContainsSystem)

}

if (IsOSAtLeast (WIN_7))

bCachedSysDevicePathsValid = 1;

}

&& wcslen (SysDriveDevicePath) > 1);

}

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

results are reliable.

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

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

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

user selected the system partition/device).

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

Return codes:

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

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

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

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

Return codes:

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

int IsNonSysPartitionOnSysDrive (const wchar_t *path)

{

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

{

return 1;

}

{

return 0;

}

}

LocalizeDialog (hwndDlg, "IDD_RAWDEVICES_DLG");

SendMessage (hList,LVM_SETEXTENDEDLISTVIEWSTYLE,0,

LvCol.pszText = GetString ("DEVICE");

LvCol.cx = CompensateXDPI (186);

LvCol.fmt = LVCFMT_LEFT;

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

LvCol.cx = CompensateXDPI (38);

LvCol.fmt = LVCFMT_LEFT;

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

// Path

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

{

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

)

continue;

if (line > 1)

{

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

}

if (device.Floppy || device.DynamicVolume)

}

#endif

}

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

{

BOOL bEnableOkButton = FALSE;

LVITEM LvItem;

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

LvItem.pszText = lpszFileName;

LvItem.cchTextMax = TC_MAX_PATH;

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

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

const HostDevice selectedDevice = itemToDeviceMap[selectedItem];

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

}

}

if (!selectedDevice.IsVirtualPartition

&& !bHiddenVolDirect)

{

#endif // #ifdef VOLFORMAT

}

bSysDriveSelected = FALSE;

#ifdef VOLFORMAT

if (hDriver == INVALID_HANDLE_VALUE)

return TRUE;

try

{

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

}

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

}

else

{

if (SystemEncryptionStatus != SYSENC_STATUS_NONE)

{

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

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

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

return res;

bPortableModeConfirmed = TRUE;

if (hDriver != INVALID_HANDLE_VALUE)

CloseHandle (hDriver);

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

| OFN_PATHMUSTEXIST

| OFN_ALLOWMULTISELECT

| (keepHistory ? 0 : OFN_DONTADDTORECENT);

if (!keepHistory)

CleanLastVisitedMRU ();

CleanLastVisitedMRU ();

status = TRUE;

ret:

SystemFileSelectorCallPending = FALSE;

ResetCurrentDirectory();

}

{

switch(uMsg) {

{

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

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

break;

}

{

wchar_t szDir[TC_MAX_PATH];

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

{

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

}

CoInitialize (NULL);

{

ZeroMemory (&bi, sizeof(bi));

bi.hwndOwner = hwndDlg;

bi.lParam = (LPARAM)dirName;

pidl = SHBrowseForFolderW (&bi);

{

{

bOK = TRUE;

}

// Font

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

return TRUE;

}

SetWindowTextW (hwnd, L"VeraCrypt");

else

SetWindowTextW (hwnd, GetString (stringId));

if (hUserFont != 0)

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

}

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

BOOL bToBeDeleted = FALSE;

if (bSetValue)

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

else

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

if (bToBeDeleted)

{

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

if (ERROR_SUCCESS == lStatus)

{

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

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

return (versionString);

}

arr.clear();

if (len %2)

return false;

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

{

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

{

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

static int serNo;

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

{

serNo = LocalizationSerialNo;

}

break;

}

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

{

ea = benchmarkTable[i].id;

typedef struct

{

HWND hBenchDlg;

} BenchmarkThreadParam;

static BOOL PerformBenchmark(HWND hBenchDlg, HWND hwndDlg);

if (thid == SHA256)

{

#ifdef _WIN64

#else

benchmarkTable[benchmarkTotalItems].meanBytesPerSec = (benchmarkTable[benchmarkTotalItems].meanBytesPerSec * 24);

#endif

else

{

#ifdef _WIN64

#else

benchmarkTable[benchmarkTotalItems].meanBytesPerSec = (benchmarkTable[benchmarkTotalItems].meanBytesPerSec * 18) / 5;

#endif

return TRUE;

counter_error:

if (ci)

crypto_close (ci);

benchmarkGPT = FALSE;

SendMessage (hList,LVM_SETEXTENDEDLISTVIEWSTYLE,0,

LvCol.pszText = GetString ("ALGORITHM");

LvCol.cx = CompensateXDPI (114);

LvCol.fmt = LVCFMT_LEFT;

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

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

hEntropyBar = GetDlgItem (hwndDlg, IDC_ENTROPY_BAR);

SendMessage (hEntropyBar, PBM_SETRANGE32, 0, maxEntropyLevel);

SendMessage (hEntropyBar, PBM_SETSTEP, 1, 0);

else if (bUseMask)

{

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

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

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

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

SendMessage (hEntropyBar, PBM_SETSTEP, 1, 0);

SendMessage (hEntropyBar, PBM_SETSTATE, PBST_ERROR, 0);

{

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

EndDialog (hwndDlg, IDCLOSE);

else if (bUseMask)

{

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

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

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

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

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

{

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

if (i > 0)

{

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

NormalCursor();

return 1;

}

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

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

keyfilesSize += 64;

}

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

{

_close (fhKeyfile);

TCfree(keyfile);

NormalCursor();

return 1;

/* Write the keyfile */

status = _write (fhKeyfile, keyfile, keyfilesSize);

NormalCursor();

handleWin32Error (hwndDlg, SRC_POS);

return 1;

}

TCfree(keyfile);

WaitCursor();

KillTimer (hwndDlg, 0xfd);

RandStop (FALSE);

#endif

/* Cleanup */

{

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

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

else

{

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

inputtext[n] = (char) x;

}

// XTS

if (bXTSTestEnabled)

{

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

} // if (bXTSTestEnabled)

/* Perform the actual tests */

{

char tmp[128];

int tmpRetVal;

return 0;

}

ResetCipherTest(HWND hwndDlg, int idTestCipher)

{

int ndx;

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

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

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

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

pStr++;

pwStr++;

{

if (*pStr != 0)

{

hUserFont),

nLongestButtonCaptionWidth);

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

}

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

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

&& nMainTextLenInChars / nLongestButtonCaptionCharLen >= 10)

{

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

nLongestButtonCaptionWidth = CompensateXDPI (max (

min (350, nMainTextLenInChars)));

}

do

{

(char *) L"\n",

offset + 1);

newLineSeqCount++;

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

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

|| vertOffset > 0)

{

// Resize/move each button if necessary

trec.right + 2 + horizSubOffset,

trec.bottom + 2,

TRUE);

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

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

MoveWindow (GetDlgItem(hwndDlg, IDC_MC_DLG_HR2),

BOOL CheckCapsLock (HWND hwnd, BOOL quiet)

{

{

if (!quiet)

{

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

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

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

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

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

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

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

bDriverSetLabel = prop.bDriverSetLabel;

}

unmount.nDosDriveNo = nDosDriveNo;

unmount.ignoreOpenFiles = forced;

}

}

dbv.dbcv_reserved = 0;

dbv.dbcv_unitmask = driveMap;

UINT timeOut = 1000;

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

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

}

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

// if it is enabled in the future

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

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

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

LocalizeDialog (hwndDlg, NULL);

_beginthread(WaitThread, 0, thParam);

void BringToForeground(HWND hWnd)

{

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

DWORD lockTimeOut = 0;

HWND hCurrWnd = ::GetForegroundWindow();

DWORD dwThisTID = ::GetCurrentThreadId(),

dwCurrTID = ::GetWindowThreadProcessId(hCurrWnd,0);

if (hCurrWnd != hWnd)

{

if(dwThisTID != dwCurrTID)

{

::AttachThreadInput(dwThisTID, dwCurrTID, TRUE);

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

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

::AllowSetForegroundWindow(ASFW_ANY);

}

::SetForegroundWindow(hWnd);

if(dwThisTID != dwCurrTID)

{

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

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

}

}

return DeviceIoControl (hDriver, TC_IOCTL_MOUNT_VOLUME, pmount,

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

}

// in wait dialog mechanism

typedef struct

path = path.substr (4);

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

}

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

{

wstring resolvedPath = VolumeGuidPathToDevicePath (path);

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

{

std::vector<byte> arr;

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

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

)

mount.BytesPerSector = bps;

mount.BytesPerPhysicalSector = bps;

}

if (IsOSAtLeast (WIN_VISTA))

{

if ( (wcslen(root) >= 2)

goto retry;

}

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

{

mount.bExclusiveAccess = FALSE;

{

if (mount.nReturnCode == ERR_PASSWORD_WRONG)

{

if (bReportWrongPassword)

{

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

&& !mount.UseBackupHeader)

{

// Retry using embedded header backup (if any)

if (bReportWrongPassword && !Silent)

Warning ("HEADER_DAMAGED_AUTO_USED_HEADER_BAK", hwndDlg);

}

LastMountedVolumeDirty = mount.FilesystemDirty;

if (mount.FilesystemDirty)

return bRet;

}

BOOL IsRepeatedByteArray (byte value, const byte* buffer, size_t bufferSize);

BOOL TranslateVolumeID (HWND hwndDlg, wchar_t* pathValue, size_t cchPathValue);

BOOL CopyTextToClipboard (const wchar_t* txtValue);

#ifdef __cplusplus

}

<string lang="en" key="SYS_ENCRYPTION_UPGRADE_UNSUPPORTED_ON_VISTA_SP0">VeraCrypt no longer supports encryption of the system partition/drive on Windows Vista with no Service Pack installed. Before upgrading VeraCrypt, please install Service Pack 1 or higher for Windows Vista.</string>

<string lang="en" key="FEATURE_REQUIRES_INSTALLATION">Error: This feature requires VeraCrypt to be installed on the system (you are running VeraCrypt in portable mode).\n\nPlease install VeraCrypt and then try again.</string>

<string lang="en" key="WINDOWS_NOT_ON_BOOT_DRIVE_ERROR">WARNING: Windows does not appear to be installed on the drive from which it boots. This is not supported.\n\nYou should continue only if you are sure that Windows is installed on the drive from which it boots.\n\nDo you want to continue?</string>

<string lang="en" key="TC_BOOT_LOADER_ALREADY_INSTALLED">CAUTION: The VeraCrypt Boot Loader is already installed on your system drive!\n\nIt is possible that another system on your computer is already encrypted.\n\nWARNING: PROCEEDING WITH ENCRYPTION OF THE CURRENTLY RUNNING SYSTEM MAY MAKE OTHER SYSTEM(S) IMPOSSIBLE TO START AND RELATED DATA INACCESSIBLE.\n\nAre you sure you want to continue?</string>

<string lang="en" key="SYS_LOADER_RESTORE_FAILED">Failed to restore the original system loader.\n\nPlease use your VeraCrypt Rescue Disk ('Repair Options' > 'Restore original system loader') or Windows installation medium to replace the VeraCrypt Boot Loader with the Windows system loader.</string>

<string lang="en" key="SYS_LOADER_UNAVAILABLE_FOR_RESCUE_DISK">The original system loader will not be stored on the Rescue Disk (probable cause: missing backup file).</string>

<string lang="en" key="PIM_TOO_BIG">Personal Iterations Multiplier (PIM) maximum value is 2147468.</string>

<control lang="en" key="IDC_SKIP_RESCUE_VERIFICATION">Skip Rescue Disk verification</control>

<control lang="en" key="IDC_HIDE_WAITING_DIALOG">Don't show wait message dialog when performing operations</control>

<string lang="en" key="CAMELLIA_HELP">Jointly developed by Mitsubishi Electric and NTT of Japan. First published on 2000. 256-bit key, 128-bit block. Mode of operation is XTS. It has been approved for use by the ISO/IEC, the European Union's NESSIE project and the Japanese CRYPTREC project.</string>

<string lang="en" key="TIME">Time</string>

<string lang="en" key="ITERATIONS">Iterations</string>

int i, nIndex = SendMessageW (hComboBox, CB_ADDSTRING, 0, (LPARAM) GetString ("AUTODETECTION"));

SendMessage (hComboBox, CB_SETITEMDATA, nIndex, (LPARAM) 0);

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

{

{

nIndex = SendMessage (hComboBox, CB_ADDSTRING, 0, (LPARAM) get_pkcs5_prf_name(i));

SendMessage (hComboBox, CB_SETITEMDATA, nIndex, (LPARAM) i);

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

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

AddRef ();

return S_OK;

}

virtual DWORD STDMETHODCALLTYPE CallDriver (DWORD ioctl, BSTR input, BSTR *output)

{

return BaseCom::CallDriver (ioctl, input, output);

return ::FormatFs (driveNo, clusterSize, fsType);

}

protected:

DWORD MessageThreadId;

LONG RefCount;

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

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

[

uuid(56327DDA-F1A7-4e13-B128-520D129BDEF6),

helpstring("VeraCrypt Format UAC Support Library"),

]

library TrueCryptFormatCom

{

DWORD SetDriverServiceStartType (DWORD startType);

DWORD WriteLocalMachineRegistryDwordValue (BSTR keyPath, BSTR valueName, DWORD value);

BOOL FormatFs (int driveNo, int clusterSize, int fsType);

};

[

BOOL SwitchWizardToSysEncMode (void)

{

WaitCursor ();

try

{

BootEncStatus = BootEncObj->GetStatus();

bWholeSysDrive = BootEncObj->SystemPartitionCoversWholeDrive();

}

catch (Exception &e)

{

SetWindowTextW (GetDlgItem (hwndDlg, IDC_BOX_HELP), GetString ("TWOFISH_HELP"));

}

else if (wcscmp (name, L"Camellia") == 0)

{

StringCbPrintfW (hyperLink, sizeof(hyperLink) / 2, GetString ("MORE_INFO_ABOUT"), name);

}

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

SendMessage (GetDlgItem (hwndDlg, IDC_SYSENC_HIDDEN), WM_SETFONT, (WPARAM) hUserBoldFont, (LPARAM) TRUE);

SendMessage (GetDlgItem (hwndDlg, IDC_SYSENC_NORMAL), WM_SETFONT, (WPARAM) hUserBoldFont, (LPARAM) TRUE);

CheckButton (GetDlgItem (hwndDlg, bHiddenOS ? IDC_SYSENC_HIDDEN : IDC_SYSENC_NORMAL));

SetWindowTextW (GetDlgItem (hwndDlg, IDC_BOX_HELP), GetString ("SYSENC_HIDDEN_TYPE_HELP"));

SetWindowTextW (GetDlgItem (hwndDlg, IDT_WHOLE_SYS_DRIVE), GetString ("SYS_ENCRYPTION_SPAN_WHOLE_SYS_DRIVE_HELP"));

CheckButton (GetDlgItem (hwndDlg, bWholeSysDrive ? IDC_WHOLE_SYS_DRIVE : IDC_SYS_PARTITION));

SetWindowTextW (GetDlgItem (GetParent (hwndDlg), IDC_NEXT), GetString ("NEXT"));

SetWindowTextW (GetDlgItem (GetParent (hwndDlg), IDC_PREV), GetString ("PREV"));

SetWindowTextW (GetDlgItem (GetParent (hwndDlg), IDCANCEL), GetString ("CANCEL"));

RefreshMultiBootControls (hwndDlg);

EnableWindow (GetDlgItem (GetParent (hwndDlg), IDC_NEXT), nMultiBoot > 0);

EnableWindow (GetDlgItem (GetParent (hwndDlg), IDC_PREV), TRUE);

EnableWindow (GetDlgItem (GetParent (hwndDlg), IDCANCEL), TRUE);

if (SysEncInEffect ())

{

RandSetHashFunction (hash_algo);

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

{

// For now, we keep RIPEMD160 for system encryption

AddComboPair (GetDlgItem (hwndDlg, IDC_COMBO_BOX_HASH_ALGO), HashGetName(hid), hid);

}

}

SetDlgItemText (hwndDlg, IDC_RESCUE_DISK_ISO_PATH, szRescueDiskISO);

EnableWindow (GetDlgItem (GetParent (hwndDlg), IDC_NEXT), (GetWindowTextLength (GetDlgItem (hwndDlg, IDC_RESCUE_DISK_ISO_PATH)) > 1));

EnableWindow (GetDlgItem (GetParent (hwndDlg), IDC_PREV), TRUE);

break;

case SYSENC_RESCUE_DISK_BURN_PAGE:

if (lw == IDC_BENCHMARK && nCurPageNo == CIPHER_PAGE)

{

// Reduce CPU load

bFastPollEnabled = FALSE;

bRandmixEnabled = FALSE;

DialogBoxParamW (hInst,

MAKEINTRESOURCEW (IDD_BENCHMARK_DLG), hwndDlg,

bFastPollEnabled = TRUE;

bRandmixEnabled = TRUE;

Applink ("serpent", FALSE, "");

else if (wcscmp (name, L"Twofish") == 0)

Applink ("twofish", FALSE, "");

else if (wcscmp (name, L"Camellia") == 0)

Applink ("camellia", FALSE, "");

else if (EAGetCipherCount (nIndex) > 1)

{

HWND hHashAlgoItem = GetDlgItem (hwndDlg, IDC_COMBO_BOX_HASH_ALGO);

int selectedAlgo = (int) SendMessage (hHashAlgoItem, CB_GETITEMDATA, SendMessage (hHashAlgoItem, CB_GETCURSEL, 0, 0), 0);

{

hash_algo = DEFAULT_HASH_ALGORITHM_BOOT;

RandSetHashFunction (DEFAULT_HASH_ALGORITHM_BOOT);

else if (nCurPageNo == CIPHER_PAGE)

{

LPARAM nIndex;

nIndex = SendMessage (GetDlgItem (hCurPage, IDC_COMBO_BOX), CB_GETCURSEL, 0, 0);

nVolumeEA = (int) SendMessage (GetDlgItem (hCurPage, IDC_COMBO_BOX), CB_GETITEMDATA, nIndex, 0);

&& EAGetCipherCount (nVolumeEA) > 1) // Cascade?

{

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

}

#endif

}

catch (Exception &e)

{

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

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

return ::ChangePwd (volumePath, oldPassword, old_pkcs5, old_pim, truecryptMode, newPassword, pkcs5, pim, wipePassCount, (HWND) hWnd);

}

protected:

DWORD MessageThreadId;

LONG RefCount;

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

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

[

uuid(9ACF6176-5FC4-4690-A025-B3306A50EB6A),

helpstring("VeraCrypt Main UAC Support Library"),

]

library TrueCryptMainCom

{

int ChangePasswordEx (BSTR volumePath, Password *oldPassword, int old_pkcs5, Password *newPassword, int pkcs5, int wipePassCount, LONG_PTR hWnd);

int ChangePasswordEx2 (BSTR volumePath, Password *oldPassword, int old_pkcs5, BOOL truecryptMode, Password *newPassword, int pkcs5, int wipePassCount, LONG_PTR hWnd);

int ChangePasswordEx3 (BSTR volumePath, Password *oldPassword, int old_pkcs5, int old_pim, BOOL truecryptMode, Password *newPassword, int pkcs5, int pim, int wipePassCount, LONG_PTR hWnd);

};

[

SetMenuItemInfoW (GetMenu (hwndDlg), i, TRUE, &info);

}

// Disable menu item for changing system header key derivation algorithm until it's implemented

EnableMenuItem (GetMenu (hwndDlg), IDM_CHANGE_SYS_HEADER_KEY_DERIV_ALGO, MF_GRAYED);

static void PopulateSysEncContextMenu (HMENU popup, BOOL bToolsOnly)

{

try

{

BootEncStatus = BootEncObj->GetStatus();

}

catch (Exception &e)

{

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

AppendMenuW (popup, MF_STRING, IDM_SYS_ENC_SETTINGS, GetString ("IDM_SYS_ENC_SETTINGS"));

{

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

AppendMenuW (popup, MF_STRING, IDM_CREATE_RESCUE_DISK, GetString ("IDM_CREATE_RESCUE_DISK"));

}

{

wchar_t t[TC_MAX_PATH + 1024] = {L'"',0};

wchar_t *tmp;

if (!FileExists(t))

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

else

{

}

}

}

case IDC_PKCS5_PRF_ID:

if (bSysEncPwdChangeDlgMode)

{

SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETCURSEL, 0, 0), 0);

{

int new_hash_algo_id = DEFAULT_HASH_ALGORITHM_BOOT;

Info ("ALGO_NOT_SUPPORTED_FOR_SYS_ENCRYPTION", hwndDlg);

int i, defaultPrfIndex = 0, nIndex = (int) SendMessageW (hComboBox, CB_ADDSTRING, 0, (LPARAM) GetString ("AUTODETECTION"));

SendMessage (hComboBox, CB_SETITEMDATA, nIndex, (LPARAM) 0);

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

{

{

nIndex = (int) SendMessage (hComboBox, CB_ADDSTRING, 0, (LPARAM) get_pkcs5_prf_name(i));

SendMessage (hComboBox, CB_SETITEMDATA, nIndex, (LPARAM) i);

// Initiates or resumes encryption of the system partition/drive

static void EncryptSystemDevice (HWND hwndDlg)

{

try

{

BootEncStatus = BootEncObj->GetStatus();

}

catch (Exception &e)

{

e.Show (MainDlg);

}

&& !BootEncStatus.DriveMounted

&& !SysEncryptionOrDecryptionRequired ())

{

if (!MutexExistsOnSystem (TC_MUTEX_NAME_SYSENC)) // If no instance of the wizard is currently taking care of system encryption

{

}

else

Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE", hwndDlg);

if (!MutexExistsOnSystem (TC_MUTEX_NAME_SYSENC)) // If no instance of the wizard is currently taking care of system encryption

{

}

else

Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE", hwndDlg);

// Initiates decryption of the system partition/drive

static void DecryptSystemDevice (HWND hwndDlg)

{

try

{

BootEncStatus = BootEncObj->GetStatus();

}

catch (Exception &e)

{

return;

}

}

else

Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE", hwndDlg);

// such information, but will exit (displaying only an error meessage).

Info("HIDDEN_OS_PREINFO", hwndDlg);

}

static void DecryptNonSysDevice (HWND hwndDlg, BOOL bResolveAmbiguousSelection, BOOL bUseDriveListSel)

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

return;

}

// Blindly attempts (without any checks) to instruct the wizard to resume whatever system encryption process

{

if (!MutexExistsOnSystem (TC_MUTEX_NAME_SYSENC)) // If no instance of the wizard is currently taking care of system encryption

{

}

else

Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE", hwndDlg);

// IMPORTANT: This function must not check any config files! Otherwise, if a config file was lost or corrupt,

// the user would not be able resume encryption and the data on the volume would be inaccessible.

}

BOOL SelectContainer (HWND hwndDlg)

static void Benchmark (HWND hwndDlg)

{

DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_BENCHMARK_DLG), hwndDlg,

}

{

// The wizard was not launched during the system startup seq, or the user may have forgotten

// to resume the encryption/decryption process.

}

}

}

if (lw == IDC_CREATE_VOLUME || lw == IDM_CREATE_VOLUME || lw == IDM_VOLUME_WIZARD)

{

return 1;

}

if (lw == IDM_SYSENC_SETTINGS || lw == IDM_SYS_ENC_SETTINGS)

{

return 1;

}

try

{

VOLUME_PROPERTIES_STRUCT prop;

try

{

BootEncStatus = BootEncObj->GetStatus();

BootEncObj->GetVolumeProperties (&prop);

}

catch (...)

{

}

{

byte userConfig;

string customUserMessage;

uint16 bootLoaderVersion;

if (bootLoaderVersion != VERSION_NUM)

Warning ("BOOT_LOADER_VERSION_INCORRECT_PREFERENCES", hwndDlg);

else

userConfig &= ~TC_BOOT_USER_CFG_FLAG_DISABLE_HW_ENCRYPTION;

}

SetDriverConfigurationFlag (TC_DRIVER_CONFIG_DISABLE_HARDWARE_ENCRYPTION, disableHW);

{

case WM_INITDIALOG:

{

{

Warning ("SYS_DRIVE_NOT_ENCRYPTED", hwndDlg);

EndDialog (hwndDlg, IDCANCEL);

return 1;

}

try

{

LocalizeDialog (hwndDlg, "IDD_SYSENC_SETTINGS");

uint32 driverConfig = ReadDriverConfigurationFlags();

byte userConfig;

string customUserMessage;

BOOL bPasswordCacheEnabled = (driverConfig & TC_DRIVER_CONFIG_CACHE_BOOT_PASSWORD)? TRUE : FALSE;

BOOL bPimCacheEnabled = (driverConfig & TC_DRIVER_CONFIG_CACHE_BOOT_PIM)? TRUE : FALSE;

if (bootLoaderVersion != VERSION_NUM)

Warning ("BOOT_LOADER_VERSION_INCORRECT_PREFERENCES", hwndDlg);

CheckDlgButton (hwndDlg, IDC_DISABLE_BOOT_LOADER_PIM_PROMPT, (userConfig & TC_BOOT_USER_CFG_FLAG_DISABLE_PIM) ? BST_CHECKED : BST_UNCHECKED);

CheckDlgButton (hwndDlg, IDC_BOOT_LOADER_CACHE_PASSWORD, bPasswordCacheEnabled ? BST_CHECKED : BST_UNCHECKED);

EnableWindow (GetDlgItem (hwndDlg, IDC_BOOT_LOADER_CACHE_PIM), bPasswordCacheEnabled);

CheckDlgButton (hwndDlg, IDC_BOOT_LOADER_CACHE_PIM, (bPasswordCacheEnabled && bPimCacheEnabled)? BST_CHECKED : BST_UNCHECKED);

}

catch (Exception &e)

{

case IDOK:

{

VOLUME_PROPERTIES_STRUCT prop;

if (!BootEncObj->GetStatus().DriveMounted)

{

try

{

BootEncObj->GetVolumeProperties (&prop);

}

catch (Exception &e)

{

return 1;

}

byte userConfig;

try

{

}

catch (Exception &e)

{

else

userConfig &= ~TC_BOOT_USER_CFG_FLAG_DISABLE_PIM;

userConfig |= TC_BOOT_USER_CFG_FLAG_SILENT_MODE;

else

userConfig &= ~TC_BOOT_USER_CFG_FLAG_SILENT_MODE;

userConfig |= TC_BOOT_USER_CFG_FLAG_DISABLE_ESC;

else

userConfig &= ~TC_BOOT_USER_CFG_FLAG_DISABLE_ESC;

try

{

BOOL bPasswordCacheEnabled = IsDlgButtonChecked (hwndDlg, IDC_BOOT_LOADER_CACHE_PASSWORD);

BOOL bPimCacheEnabled = IsDlgButtonChecked (hwndDlg, IDC_BOOT_LOADER_CACHE_PIM);

SetDriverConfigurationFlag (TC_DRIVER_CONFIG_CACHE_BOOT_PASSWORD, bPasswordCacheEnabled);

SetDriverConfigurationFlag (TC_DRIVER_CONFIG_CACHE_BOOT_PIM, (bPasswordCacheEnabled && bPimCacheEnabled)? TRUE : FALSE);

SetDriverConfigurationFlag (TC_DRIVER_CONFIG_DISABLE_EVIL_MAID_ATTACK_DETECTION, IsDlgButtonChecked (hwndDlg, IDC_DISABLE_EVIL_MAID_ATTACK_DETECTION));

/*

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

governed by the TrueCrypt License 3.0, also from the source code of

Encryption for the Masses 2.02a, which is Copyright (c) 1998-2000 Paul Le Roux

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

int GetCipherBlockSizeByDriveNo (int nDosDriveNo);

int GetModeOfOperationByDriveNo (int nDosDriveNo);

void ChangeMainWindowVisibility ();

BOOL WholeSysDriveEncryption (BOOL bSilent);

BOOL CheckSysEncMountWithoutPBA (HWND hwndDlg, const wchar_t *devicePath, BOOL quiet);

BOOL TCBootLoaderOnInactiveSysEncDrive (wchar_t *szDevicePath);

LTEXT "",IDT_PKCS11_LIB_HELP,16,63,286,65

END

STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | DS_CENTER | WS_POPUP | WS_CAPTION | WS_SYSMENU

CAPTION "VeraCrypt - System Encryption Settings"

FONT 8, "MS Shell Dlg", 400, 0, 0x1

BEGIN

CONTROL "&Cache pre-boot authentication password in driver memory (for mounting of non-system volumes)",IDC_BOOT_LOADER_CACHE_PASSWORD,

CONTROL "Include PIM when caching pre-boot authentication password",IDC_BOOT_LOADER_CACHE_PIM,

CONTROL "Do not request PIM in the pre-boot authentication screen (PIM value is stored unencrypted on disk)",IDC_DISABLE_BOOT_LOADER_PIM_PROMPT,

"Button",BS_AUTOCHECKBOX | WS_TABSTOP,18,20,339,9

END

IDD_PERFORMANCE_SETTINGS DIALOGEX 0, 0, 370, 248

CONTROL "TrueCrypt Mode",IDC_TRUECRYPT_MODE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,7,7,76,10

END

/////////////////////////////////////////////////////////////////////////////

//

//

#ifdef APSTUDIO_INVOKED

BEGIN

IDD_PREFERENCES_DLG, DIALOG

BEGIN

BOTTOMMARGIN, 192

END

BEGIN

LEFTMARGIN, 7

RIGHTMARGIN, 363

TOPMARGIN, 7

END

IDD_PERFORMANCE_SETTINGS, DIALOG

TOPMARGIN, 7

BOTTOMMARGIN, 58

END

END

#endif // APSTUDIO_INVOKED

// TEXTINCLUDE

//

BEGIN

"resource.h\0"

END

BEGIN

"#include ""afxres.h""\r\n"

"#include ""..\\\\common\\\\resource.h""\r\n"

"\0"

END

BEGIN

"#include ""..\\\\common\\\\common.rc""\r\n"

"\0"

// Menu

//

BEGIN

POPUP "&Volumes"

BEGIN

// String Table

//

BEGIN

IDS_UACSTRING "VeraCrypt"

END

#define IDD_SYSENC_SETTINGS 116

#define IDD_FAVORITE_VOLUMES 117

#define IDD_DEFAULT_MOUNT_PARAMETERS 118

#define IDC_PREF_MOUNT_READONLY 1000

#define IDC_PREF_MOUNT_REMOVABLE 1001

#define IDC_VERIFY 1002

#define IDT_VOLUME_ID 1157

#define IDC_FAVORITE_VOLUME_ID 1158

#define IDC_FAVORITE_USE_VOLUME_ID 1159

#define IDC_HIDE_WAITING_DIALOG 1161

#define IDM_HELP 40001

#define IDM_ABOUT 40002

#define IDM_UNMOUNT_VOLUME 40003

#define IDM_VERIFY_RESCUE_DISK_ISO 40068

// Next default values for new objects

#ifdef APSTUDIO_INVOKED

#ifndef APSTUDIO_READONLY_SYMBOLS

#define _APS_NO_MFC 1

#define _APS_NEXT_COMMAND_VALUE 40069

#define _APS_NEXT_SYMED_VALUE 101

#endif

#endif

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

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

*/

#define TC_MAIN_COM_VERSION_MAJOR 2

#define TC_FORMAT_COM_VERSION_MAJOR 2

#include <atlbase.h>

#include <comdef.h>

UnRegisterTypeLib (LIBID_TrueCryptMainCom, TC_MAIN_COM_VERSION_MAJOR, TC_MAIN_COM_VERSION_MINOR, 0, SYS_WIN32);

UnRegisterTypeLib (LIBID_TrueCryptFormatCom, TC_FORMAT_COM_VERSION_MAJOR, TC_FORMAT_COM_VERSION_MINOR, 0, SYS_WIN32);

// unregister older versions that may still exist

UnRegisterTypeLib (LIBID_TrueCryptMainCom, TC_MAIN_COM_VERSION_MAJOR, TC_MAIN_COM_VERSION_MINOR-3, 0, SYS_WIN32);

UnRegisterTypeLib (LIBID_TrueCryptMainCom, TC_MAIN_COM_VERSION_MAJOR, TC_MAIN_COM_VERSION_MINOR-2, 0, SYS_WIN32);

UnRegisterTypeLib (LIBID_TrueCryptMainCom, TC_MAIN_COM_VERSION_MAJOR, TC_MAIN_COM_VERSION_MINOR-1, 0, SYS_WIN32);

UnRegisterTypeLib (LIBID_TrueCryptFormatCom, TC_FORMAT_COM_VERSION_MAJOR, TC_FORMAT_COM_VERSION_MINOR-1, 0, SYS_WIN32);

wchar_t setupModule[MAX_PATH];

return FALSE;

// unregister older versions that may still exist

UnRegisterTypeLib (LIBID_TrueCryptMainCom, TC_MAIN_COM_VERSION_MAJOR, TC_MAIN_COM_VERSION_MINOR-3, 0, SYS_WIN32);

UnRegisterTypeLib (LIBID_TrueCryptMainCom, TC_MAIN_COM_VERSION_MAJOR, TC_MAIN_COM_VERSION_MINOR-2, 0, SYS_WIN32);

UnRegisterTypeLib (LIBID_TrueCryptMainCom, TC_MAIN_COM_VERSION_MAJOR, TC_MAIN_COM_VERSION_MINOR-1, 0, SYS_WIN32);

UnRegisterTypeLib (LIBID_TrueCryptFormatCom, TC_FORMAT_COM_VERSION_MAJOR, TC_FORMAT_COM_VERSION_MINOR-1, 0, SYS_WIN32);

wchar_t module[1024];