Password ProtectedHidVolPassword; /* Password to the hidden volume to be protected against overwriting */

BOOL UseBackupHeader;

BOOL RecoveryMode;

} MOUNT_STRUCT;

typedef struct

typedef struct

{

Password VolumePassword;

} ReopenBootVolumeHeaderRequest;

// Initial rescue disk assumes encryption of the drive has been completed (EncryptedAreaLength == volumeSize)

memcpy (RescueVolumeHeader, VolumeHeader, sizeof (RescueVolumeHeader));

DecryptBuffer (RescueVolumeHeader + HEADER_ENCRYPTED_DATA_OFFSET, HEADER_ENCRYPTED_DATA_SIZE, cryptoInfo);

}

{

BootEncryptionStatus encStatus = GetStatus();

PCRYPTO_INFO cryptoInfo = NULL;

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

if (status != 0)

{

ReopenBootVolumeHeaderRequest reopenRequest;

reopenRequest.VolumePassword = *newPassword;

finally_do_arg (ReopenBootVolumeHeaderRequest*, &reopenRequest, { burn (finally_arg, sizeof (*finally_arg)); });

CallDriver (TC_IOCTL_REOPEN_BOOT_VOLUME_HEADER, &reopenRequest, sizeof (reopenRequest));

void AbortSetup ();

void AbortSetupWait ();

void CallDriver (DWORD ioctl, void *input = nullptr, DWORD inputSize = 0, void *output = nullptr, DWORD outputSize = 0);

void CheckDecoyOSWipeResult ();

void CheckEncryptionSetupResult ();

void CheckRequirements ();

int cacheEmpty = 1;

static int nPasswordIdx = 0;

{

int nReturnCode = ERR_PASSWORD_WRONG;

int i;

/* Attempt to recognize volume using mount password */

if (password->Length > 0)

{

/* Save mount passwords back into cache if asked to do so */

if (bCache && (nReturnCode == 0 || nReturnCode == ERR_CIPHER_INIT_WEAK_KEY))

{

if (CachedPasswords[i].Length > 0)

{

if (nReturnCode != ERR_PASSWORD_WRONG)

break;

extern int cacheEmpty;

void AddPasswordToCache (Password *password);

void WipeCache (void);

Password ProtectedHidVolPassword; /* Password of hidden volume to protect against overwriting */

BOOL UseBackupHeader;

BOOL RecoveryMode;

} MountOptions;

#endif

PUSHBUTTON "Cancel",IDCANCEL,248,190,50,14

END

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

CAPTION "VeraCrypt - Mount Options"

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

CONTROL "&Protect hidden volume against damage caused by writing to outer volume",IDC_PROTECT_HIDDEN_VOL,

"Button",BS_AUTOCHECKBOX | WS_TABSTOP,16,86,252,10

EDITTEXT IDC_PASSWORD_PROT_HIDVOL,112,104,151,14,ES_PASSWORD | ES_AUTOHSCROLL

DEFPUSHBUTTON "OK",IDOK,211,7,60,14

PUSHBUTTON "Cancel",IDCANCEL,211,24,60,14

RTEXT "P&assword to hidden volume:\n(if empty, cache is used)",IDT_HIDDEN_PROT_PASSWD,15,103,91,17,0,WS_EX_RIGHT

CONTROL "Use backup header embedded in &volume if available",IDC_USE_EMBEDDED_HEADER_BAK,

"Button",BS_AUTOCHECKBOX | WS_TABSTOP,12,39,257,11

END

IDD_KEYFILES DIALOGEX 0, 0, 345, 237

LTEXT "Please wait. This process may take a long time...",IDT_STATIC_MODELESS_WAIT_DLG_INFO,9,8,274,9

END

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

CAPTION "VeraCrypt"

FONT 8, "MS Shell Dlg", 0, 0, 0x0

BEGIN

END

BEGIN

LEFTMARGIN, 7

TOPMARGIN, 7

END

IDD_KEYFILES, DIALOG

LEFTMARGIN, 7

RIGHTMARGIN, 285

TOPMARGIN, 7

END

END

#endif // APSTUDIO_INVOKED

{

int ea; /* Encryption algorithm ID */

int mode; /* Mode of operation (e.g., XTS) */

unsigned __int8 ks[MAX_EXPANDED_KEY]; /* Primary key schedule (if it is a cascade, it conatins multiple concatenated keys) */

unsigned __int8 ks2[MAX_EXPANDED_KEY]; /* Secondary key schedule (if cascade, multiple concatenated) for XTS mode. */

UINT64_STRUCT EncryptedAreaLength;

uint32 HeaderFlags;

} CRYPTO_INFO, *PCRYPTO_INFO;

PCRYPTO_INFO crypto_open (void);

void crypto_loadkey (PKEY_INFO keyInfo, char *lpszUserKey, int nUserKeyLen);

void crypto_close (PCRYPTO_INFO cryptoInfo);

char *HashGetName (int hash_algo_id);

#ifndef TC_WINDOWS_BOOT

void HashGetName2 (char *buf, int hashId);

BOOL HashIsDeprecated (int hashId);

BOOL HashForSystemEncryption (int hashId);

{

MountThreadParam* thParam = (MountThreadParam*) lParam;

HANDLE hThread = NULL;

thParam->hwnd = hwndDlg;

int driveNo,

char *volumePath,

Password *password,

BOOL cachePassword,

BOOL sharedAccess,

const MountOptions* const mountOptions,

{

mount.ProtectedHidVolPassword = mountOptions->ProtectedHidVolPassword;

mount.bProtectHiddenVolume = TRUE;

}

else

mount.bProtectHiddenVolume = FALSE;

mount.bPreserveTimestamp = mountOptions->PreserveTimestamp;

mount.bMountManager = TRUE;

// Windows 2000 mount manager causes problems with remounted volumes

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

burn (&mount.VolumePassword, sizeof (mount.VolumePassword));

burn (&mount.ProtectedHidVolPassword, sizeof (mount.ProtectedHidVolPassword));

if (bResult == FALSE)

{

#ifndef SETUP

{

int status = ERR_PARAMETER_INCORRECT;

int volumeType;

}

// Decrypt volume header

if (status == ERR_PASSWORD_WRONG)

continue; // Try next volume type

BOOL IsDeviceMounted (char *deviceName);

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

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

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

BOOL IsPasswordCacheEmpty (void);

BOOL IsMountedVolume (const char *volname);

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

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

BOOL DoDriverInstall (HWND hwndDlg);

void CloseVolume (OpenVolumeContext *context);

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

BOOL IsPagingFileActive (BOOL checkNonWindowsPartitionsOnly);

mountOptions.PartitionInInactiveSysEncScope = FALSE;

mountOptions.UseBackupHeader = FALSE;

{

MessageBoxW (volParams->hwndDlg, GetString ("CANT_MOUNT_VOLUME"), lpszTitle, ICON_HAND);

MessageBoxW (volParams->hwndDlg, GetString ("FORMAT_NTFS_STOP"), lpszTitle, ICON_HAND);

<control lang="en" key="IDT_PARALLELIZATION_OPTIONS">Thread-Based Parallelization</control>

<control lang="en" key="IDT_PKCS11_LIB_PATH">PKCS #11 Library Path</control>

<control lang="en" key="IDT_PKCS5_PRF">PKCS-5 PRF:</control>

<control lang="en" key="IDT_PW_CACHE_OPTIONS">Password Cache</control>

<control lang="en" key="IDT_SECURITY_OPTIONS">Security Options</control>

<control lang="en" key="IDT_TASKBAR_ICON">VeraCrypt Background Task</control>

<control lang="en" key="IDT_SECURITY_TOKEN">Security token:</control>

<control lang="en" key="IDT_SORT_METHOD">Sort Method:</control>

<control lang="en" key="IDT_STATIC_MODELESS_WAIT_DLG_INFO">Please wait. This process may take a long time...</control>

<control lang="en" key="IDT_TEST_BLOCK_NUMBER">Block number:</control>

<control lang="en" key="IDT_TEST_CIPHERTEXT">Ciphertext (hexadecimal)</control>

<control lang="en" key="IDT_TEST_DATA_UNIT_NUMBER">Data unit number (64-bit hexadecimal, data unit size is 512 bytes)</control>

<string lang="en" key="REMOVABLE_DISK">Removable Disk</string>

<string lang="en" key="HARDDISK">Harddisk</string>

<string lang="en" key="UNCHANGED">Unchanged</string>

<string lang="en" key="SETUP_MODE_TITLE">Wizard Mode</string>

<string lang="en" key="SETUP_MODE_INFO">Select one of the modes. If you are not sure which to select, use the default mode.</string>

<string lang="en" key="SETUP_MODE_HELP_INSTALL">Select this option if you want to install VeraCrypt on this system.</string>

return TRUE;

}

{

int nDosLinkCreated = 1, nStatus = ERR_OS_ERROR;

char szDiskFile[TC_MAX_PATH], szCFDevice[TC_MAX_PATH];

/* Try to decrypt the header */

if (nStatus == ERR_CIPHER_INIT_WEAK_KEY)

nStatus = 0; // We can ignore this error here

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

BOOL CheckPasswordLength (HWND hwndDlg, HWND hwndItem);

BOOL CheckPasswordCharEncoding (HWND hPassword, Password *ptrPw);

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

#define IDC_KEYFILES_RANDOM_SIZE 5122

#define IDT_KEYFILES_SIZE 5123

#define IDD_STATIC_MODAL_WAIT_DLG 5124

// Next default values for new objects

//

#define _APS_NO_MFC 1

#define _APS_NEXT_RESOURCE_VALUE 542

#define _APS_NEXT_COMMAND_VALUE 40001

#define _APS_NEXT_SYMED_VALUE 101

#endif

#endif

BOOL ReadVolumeHeaderRecoveryMode = FALSE;

{

char header[TC_VOLUME_HEADER_EFFECTIVE_SIZE];

KEY_INFO keyInfo;

return ERR_OUTOFMEMORY;

}

{

keyDerivationWorkItems = TCalloc (sizeof (KeyDerivationWorkItem) * pkcs5PrfCount);

if (!keyDerivationWorkItems)

// Test all available PKCS5 PRFs

for (enqPkcs5Prf = FIRST_PRF_ID; enqPkcs5Prf <= LAST_PRF_ID || queuedWorkItems > 0; ++enqPkcs5Prf)

{

{

// Enqueue key derivation on thread pool

if (queuedWorkItems < encryptionThreadCount && enqPkcs5Prf <= LAST_PRF_ID)

VirtualUnlock (&dk, sizeof (dk));

#endif

{

TC_WAIT_EVENT (noOutstandingWorkItemEvent);

uint16 GetHeaderField16 (byte *header, int offset);

uint32 GetHeaderField32 (byte *header, int offset);

UINT64_STRUCT GetHeaderField64 (byte *header, int offset);

int ReadVolumeHeader (BOOL bBoot, char *encryptedHeader, Password *password, PCRYPTO_INFO *retInfo, CRYPTO_INFO *retHeaderCryptoInfo);

#if !defined (DEVICE_DRIVER) && !defined (TC_WINDOWS_BOOT)

int CreateVolumeHeaderInMemory (BOOL bBoot, char *encryptedHeader, int ea, int mode, Password *password, int pkcs5_prf, char *masterKeydata, PCRYPTO_INFO *retInfo, unsigned __int64 volumeSize, unsigned __int64 hiddenVolumeSize, unsigned __int64 encryptedAreaStart, unsigned __int64 encryptedAreaLength, uint16 requiredProgramVersion, uint32 headerFlags, uint32 sectorSize, BOOL bWipeMode);

NTSTATUS status;

LARGE_INTEGER offset;

char *header;

Dump ("MountDrive pdo=%p\n", Extension->Pdo);

ASSERT (KeGetCurrentIrql() == PASSIVE_LEVEL);

goto ret;

}

{

// Header decrypted

status = STATUS_SUCCESS;

Dump ("Loaded: EncryptedAreaStart=%I64d (%I64d) EncryptedAreaEnd=%I64d (%I64d)\n", Extension->Queue.EncryptedAreaStart / 1024 / 1024, Extension->Queue.EncryptedAreaStart, Extension->Queue.EncryptedAreaEnd / 1024 / 1024, Extension->Queue.EncryptedAreaEnd);

// Erase boot loader scheduled keys

{

cryptoInfoAddress.QuadPart = (BootLoaderSegment << 4) + BootArgs.CryptoInfoOffset;

}

BootDriveFilterExtension = Extension;

return;

if (!BootDriveFound || !BootDriveFilterExtension || !BootDriveFilterExtension->DriveMounted || !BootDriveFilterExtension->HeaderCryptoInfo

{

irp->IoStatus.Status = STATUS_INVALID_PARAMETER;

goto wipe;

goto ret;

}

{

Dump ("Header reopened\n");

{

MOUNT_STRUCT *mount = (MOUNT_STRUCT *) Irp->AssociatedIrp.SystemBuffer;

{

Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;

Irp->IoStatus.Information = 0;

burn (&mount->VolumePassword, sizeof (mount->VolumePassword));

burn (&mount->ProtectedHidVolPassword, sizeof (mount->ProtectedHidVolPassword));

}

break;

mount->bCache,

readBuffer,

&mount->ProtectedHidVolPassword,

&tmpCryptoInfo);

}

else

mount->bCache,

readBuffer,

&mount->VolumePassword,

&Extension->cryptoInfo);

}

/* Now we will try to decrypt the backup header to verify it has been correctly written. */

if (nStatus != ERR_SUCCESS

|| cryptoInfo->EncryptedAreaStart.Value != cryptoInfo2->EncryptedAreaStart.Value

DWORD n;

char *devicePath = volParams->volumePath;

Password *password = volParams->password;

DISK_GEOMETRY driveGeometry;

sectorSize = driveGeometry.BytesPerSector;

if (nStatus != ERR_SUCCESS)

goto closing_seq;

}

{

LARGE_INTEGER offset;

DWORD n;

}

if (nStatus != ERR_SUCCESS)

goto closing_seq;

BOOL SaveNonSysInPlaceEncSettings (int delta, WipeAlgorithmId wipeAlgorithm);

static void ExportProgressStats (__int64 bytesDone, __int64 totalSize);

int ZeroUnreadableSectors (HANDLE dev, LARGE_INTEGER startOffset, int64 size, int sectorSize, uint64 *zeroedSectorCount);

BOOL MoveClustersBeforeThreshold (HANDLE volumeHandle, PWSTR volumeDevicePath, int64 clusterThreshold);

#ifdef __cplusplus

#include "Common/Dictionary.h"

#include "Common/Endian.h"

#include "Common/resource.h"

#include "Platform/Finally.h"

#include "Platform/ForEach.h"

#include "Random.h"

char szVerify[MAX_PASSWORD + 1]; /* Tmp password buffer */

char szRawPassword[MAX_PASSWORD + 1]; /* Password before keyfile was applied to it */

BOOL bHistoryCmdLine = FALSE; /* History control is always disabled */

BOOL ComServerMode = FALSE;

if (bHiddenVolHost && !bVolTransformThreadCancel && nStatus == 0)

{

/* Auto mount the newly created hidden volume host */

{

case ERR_NO_FREE_DRIVES:

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

case HIDDEN_VOL_HOST_PASSWORD_PAGE:

case NONSYS_INPLACE_ENC_RESUME_PASSWORD_PAGE:

break;

GetWindowText (GetDlgItem (hCurPage, IDC_PASSWORD_DIRECT), (char *) volumePassword.Text, sizeof (volumePassword.Text));

volumePassword.Length = strlen ((char *) volumePassword.Text);

// Store the password in case we need to restore it after keyfile is applied to it

GetWindowText (GetDlgItem (hCurPage, IDC_PASSWORD_DIRECT), szRawPassword, sizeof (szRawPassword));

// Mount the hidden volume host as read-only (to ensure consistent and secure

// results of the volume bitmap scanning)

{

case ERR_NO_FREE_DRIVES:

NormalCursor ();

{

OpenVolumeContext volume;

{

if ((volume.CryptoInfo->HeaderFlags & TC_HEADER_FLAG_NONSYS_INPLACE_ENC) != 0

&& volume.CryptoInfo->EncryptedAreaLength.Value != volume.CryptoInfo->VolumeSize.Value)

{

// Remount the hidden volume host as read-only (to ensure consistent and secure

// results of the volume bitmap scanning)

{

case ERR_NO_FREE_DRIVES:

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

// Mounts a volume within which the user intends to create a hidden volume

{

MountOptions mountOptions;

ZeroMemory (&mountOptions, sizeof (mountOptions));

mountOptions.PartitionInInactiveSysEncScope = FALSE;

mountOptions.UseBackupHeader = FALSE;

{

*driveNo = -3;

return ERR_VOL_MOUNT_FAILED;

static void NonSysInplaceEncResume (void);

void ShowNonSysInPlaceEncUIStatus (void);

void UpdateNonSysInPlaceEncControls (void);

int AnalyzeHiddenVolumeHost (HWND hwndDlg, int *driveNo, __int64 hiddenVolHostSize, int *realClusterSize, __int64 *pnbrFreeClusters);

int ScanVolClusterBitmap ( HWND hwndDlg, int *driveNo, __int64 nbrClusters, __int64 *nbrFreeClusters);

static void WipeStart (void);

CW2A volumePathA(volumePath);

MainDlg = (HWND) hWnd;

if (volumePathA.m_psz)

else

return ERR_OUTOFMEMORY;

}

return BaseCom::WriteLocalMachineRegistryDwordValue (keyPath, valueName, value);

}

protected:

DWORD MessageThreadId;

LONG RefCount;

}

{

CComPtr<ITrueCryptMainCom> tc;

int r;

if (ComGetInstance (hwndDlg, &tc))

{

WaitCursor ();

NormalCursor ();

}

else

void UacAnalyzeKernelMiniDump (HWND hwndDlg);

int UacBackupVolumeHeader (HWND hwndDlg, BOOL bRequireConfirmation, char *lpszVolume);

int UacRestoreVolumeHeader (HWND hwndDlg, char *lpszVolume);

#ifdef __cplusplus

}

[

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

helpstring("VeraCrypt Main UAC Support Library"),

]

library TrueCryptMainCom

{

int RestoreVolumeHeader (LONG_PTR hwndDlg, BSTR lpszVolume);

DWORD SetDriverServiceStartType (DWORD startType);

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

};

[

int cmdUnmountDrive = 0; /* Volume drive letter to unmount (-1 = all) */

Password VolumePassword; /* Password used for mounting volumes */

Password CmdVolumePassword; /* Password passed from command line */

BOOL CmdVolumePasswordValid = FALSE;

MountOptions CmdMountOptions;

BOOL CmdMountOptionsValid = FALSE;

clear them for extra security. */

burn (&VolumePassword, sizeof (VolumePassword));

burn (&CmdVolumePassword, sizeof (CmdVolumePassword));

burn (&mountOptions, sizeof (mountOptions));

burn (&defaultMountOptions, sizeof (defaultMountOptions));

burn (szFileName, sizeof(szFileName));

defaultMountOptions.Removable = ConfigReadInt ("MountVolumesRemovable", FALSE);

defaultMountOptions.ReadOnly = ConfigReadInt ("MountVolumesReadOnly", FALSE);

defaultMountOptions.ProtectHiddenVolume = FALSE;

defaultMountOptions.PartitionInInactiveSysEncScope = FALSE;

defaultMountOptions.RecoveryMode = FALSE;

defaultMountOptions.UseBackupHeader = FALSE;

case WM_INITDIALOG:

{

LPARAM nIndex;

int i;

WipeAlgorithmId headerWipeMode = TC_WIPE_3_DOD_5220;

EnableWindow (GetDlgItem (hwndDlg, IDC_KEYFILES), TRUE);

EnableWindow (GetDlgItem (hwndDlg, IDC_NEW_KEYFILES), TRUE);

SendMessage (hComboBox, CB_RESETCONTENT, 0, 0);

nIndex = SendMessageW (hComboBox, CB_ADDSTRING, 0, (LPARAM) GetString ("UNCHANGED"));

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

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

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

break;

case PCDM_REMOVE_ALL_KEYFILES_FROM_VOL:

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

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

if (SetTimer (hwndDlg, TIMER_ID_KEYB_LAYOUT_GUARD, TIMER_INTERVAL_KEYB_LAYOUT_GUARD, NULL) == 0)

{

Error ("CANNOT_SET_TIMER");

SendMessage (GetDlgItem (hwndDlg, IDC_WIPE_MODE), CB_GETCURSEL, 0, 0),

0);

int nStatus;

int pkcs5 = SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETITEMDATA,

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

{

// System

try

{

}

catch (Exception &e)

{

{

// Non-system

if (nStatus == ERR_OS_ERROR

&& GetLastError () == ERROR_ACCESS_DENIED

&& IsUacSupported ()

&& IsVolumeDeviceHosted (szFileName))

{

}

}

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

{

WORD lw = LOWORD (wParam);

switch (msg)

{

case WM_INITDIALOG:

{

LocalizeDialog (hwndDlg, "IDD_PASSWORD_DLG");

DragAcceptFiles (hwndDlg, TRUE);

SetWindowTextW (hwndDlg, s);

}

SendMessage (GetDlgItem (hwndDlg, IDC_PASSWORD), EM_LIMITTEXT, MAX_PASSWORD, 0);

SendMessage (GetDlgItem (hwndDlg, IDC_CACHE), BM_SETCHECK, bCacheInDriver ? BST_CHECKED:BST_UNCHECKED, 0);

szXPwd->Length = strlen ((char *) szXPwd->Text);

bCacheInDriver = IsButtonChecked (GetDlgItem (hwndDlg, IDC_CACHE));

}

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

EnableWindow (GetDlgItem (hwndDlg, IDC_MOUNT_SYSENC_PART_WITHOUT_PBA), !bPrebootPasswordDlgMode);

protect = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PROTECT_HIDDEN_VOL));

EnableWindow (GetDlgItem (hwndDlg, IDC_PROTECT_HIDDEN_VOL), !IsButtonChecked (GetDlgItem (hwndDlg, IDC_MOUNT_READONLY)));

EnableWindow (GetDlgItem (hwndDlg, IDT_HIDDEN_PROT_PASSWD), protect);

EnableWindow (GetDlgItem (hwndDlg, IDC_KEYFILES_HIDVOL_PROT), protect);

EnableWindow (GetDlgItem (hwndDlg, IDC_KEYFILES_ENABLE_HIDVOL_PROT), protect);

SetCheckBox (hwndDlg, IDC_KEYFILES_ENABLE_HIDVOL_PROT, hidVolProtKeyFilesParam.EnableKeyFiles);

sizeof (mountOptions->ProtectedHidVolPassword.Text));

mountOptions->ProtectedHidVolPassword.Length = strlen ((char *) mountOptions->ProtectedHidVolPassword.Text);

}

// Cleanup

EnableWindow (GetDlgItem (hwndDlg, IDC_SHOW_PASSWORD_MO), protect);

EnableWindow (GetDlgItem (hwndDlg, IDC_KEYFILES_HIDVOL_PROT), protect);

EnableWindow (GetDlgItem (hwndDlg, IDC_KEYFILES_ENABLE_HIDVOL_PROT), protect);

return 1;

}

return item.lParam;

}

{

int result;

PasswordDialogTitleStringId = titleStringId;

PasswordDialogDisableMountOptions = !enableMountOptions;

result = DialogBoxParamW (hInst,

MAKEINTRESOURCEW (IDD_PASSWORD_DLG), hwndDlg,

if (result != IDOK)

{

password->Length = 0;

burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword));

}

return result == IDOK;

nDosDriveNo = HIWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) - 'A';

if (!MultipleMountOperationInProgress)

VolumePassword.Length = 0;

if (szFileName == NULL)

{

// First try cached passwords and if they fail ask user for a new one

WaitCursor ();

// If keyfiles are enabled, test empty password first

if (!mounted && KeyFilesEnable && FirstKeyFile)

emptyPassword.Length = 0;

KeyFilesApply (&emptyPassword, FirstKeyFile);

burn (&emptyPassword, sizeof (emptyPassword));

}

// Test password and/or keyfiles used for the previous volume

if (!mounted && MultipleMountOperationInProgress && VolumePassword.Length != 0)

NormalCursor ();

}

while (mounted == 0)

if (CmdVolumePassword.Length > 0)

{

VolumePassword = CmdVolumePassword;

}

else if (!Silent)

{

StringCbCopyA (PasswordDlgVolume, sizeof(PasswordDlgVolume), szFileName);

goto ret;

}

WaitCursor ();

if (KeyFilesEnable)

KeyFilesApply (&VolumePassword, FirstKeyFile);

NormalCursor ();

// Check for legacy non-ASCII passwords

Warning ("EXE_FILE_EXTENSION_MOUNT_WARNING");

if (!MultipleMountOperationInProgress)

burn (&VolumePassword, sizeof (VolumePassword));

burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword));

if (CmdVolumePassword.Length > 0 || Silent)

break;

ret:

if (!MultipleMountOperationInProgress)

burn (&VolumePassword, sizeof (VolumePassword));

burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword));

RestoreDefaultKeyFilesParam ();

{

if (!CmdVolumePasswordValid && bPasswordPrompt)

{

PasswordDlgVolume[0] = '\0';

goto ret;

}

else if (CmdVolumePasswordValid)

{

bPasswordPrompt = FALSE;

VolumePassword = CmdVolumePassword;

}

WaitCursor();

goto ret;

// First try user password then cached passwords

{

// A volume has been successfully mounted

if (!bHeaderBakRetry)

{

burn (&VolumePassword, sizeof (VolumePassword));

burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword));

}

} while (bPasswordPrompt && mountedVolCount < 1);

MultipleMountOperationInProgress = FALSE;

burn (&VolumePassword, sizeof (VolumePassword));

burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword));

mountOptions.UseBackupHeader = defaultMountOptions.UseBackupHeader;

BOOL mounted;

// Cached password

// Command line password or keyfiles

if (!mounted && (CmdVolumePassword.Length != 0 || FirstCmdKeyFile))

KeyFilesApply (&CmdVolumePassword, FirstCmdKeyFile);

mounted = MountVolume (hwndDlg, szDriveLetter[0] - 'A',

&mountOptions, Silent, reportBadPasswd);

burn (&CmdVolumePassword, sizeof (CmdVolumePassword));

// Ask user for password

while (!mounted && !Silent)

{

VolumePassword.Length = 0;

StringCbCopyA (PasswordDlgVolume, sizeof(PasswordDlgVolume),szFileName);

break;

WaitCursor ();

if (KeyFilesEnable && FirstKeyFile)

KeyFilesApply (&VolumePassword, FirstKeyFile);

burn (&VolumePassword, sizeof (VolumePassword));

burn (&mountOptions.ProtectedHidVolPassword, sizeof (mountOptions.ProtectedHidVolPassword));

NormalCursor ();

}

OptionSilent,

OptionTokenLib,

OptionVolume,

};

argument args[]=

{ OptionSilent, "/silent", "/s", FALSE },

{ OptionTokenLib, "/tokenlib", NULL, FALSE },

{ OptionVolume, "/volume", "/v", FALSE },

};

argumentspec as;

exit(0);

break;

// no option = file name

default:

{

MultipleMountOperationInProgress = FALSE;

burn (&VolumePassword, sizeof (VolumePassword));

if (status && CloseSecurityTokenSessionsAfterMount)

SecurityToken::CloseAllSessions();

while (TRUE)

{

{

nStatus = ERR_SUCCESS;

goto ret;

if (KeyFilesEnable && FirstKeyFile)

KeyFilesApply (askPassword, FirstKeyFile);

NormalCursor();

handleError (hwndDlg, nStatus);

burn (&VolumePassword, sizeof (VolumePassword));

burn (&hiddenVolPassword, sizeof (hiddenVolPassword));

burn (temporaryKey, sizeof (temporaryKey));

burn (originalK2, sizeof (originalK2));

while (TRUE)

{

StringCbCopyA (PasswordDlgVolume, sizeof(PasswordDlgVolume), lpszVolume);

{

nStatus = ERR_SUCCESS;

goto ret;

if (KeyFilesEnable && FirstKeyFile)

KeyFilesApply (&VolumePassword, FirstKeyFile);

NormalCursor();

// Open the header

while (TRUE)

{

{

nStatus = ERR_SUCCESS;

goto ret;

if (type == TC_VOLUME_TYPE_HIDDEN)

headerOffsetBackupFile += (legacyBackup ? TC_VOLUME_HEADER_SIZE_LEGACY : TC_VOLUME_HEADER_SIZE);

if (nStatus == ERR_SUCCESS)

break;

}

handleError (hwndDlg, nStatus);

burn (&VolumePassword, sizeof (VolumePassword));

RestoreDefaultKeyFilesParam();

RandStop (FALSE);

NormalCursor();

BOOL bHidVolDamagePrevReported[26];

} VOLUME_NOTIFICATIONS_LIST;

extern VOLUME_NOTIFICATIONS_LIST VolumeNotificationsList;

CONTROL "",IDC_VOLUME_PROPERTIES_LIST,"SysListView32",LVS_REPORT | LVS_ALIGNLEFT | LVS_NOSORTHEADER | WS_BORDER | WS_TABSTOP,7,6,269,154

END

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

CAPTION "Change Password or Keyfiles"

CLASS "CustomDlg"

FONT 8, "MS Shell Dlg", 0, 0, 0x0

BEGIN

EDITTEXT IDC_OLD_PASSWORD,89,14,147,13,ES_PASSWORD | ES_AUTOHSCROLL

DEFPUSHBUTTON "OK",IDOK,251,7,59,14

PUSHBUTTON "Cancel",IDCANCEL,251,24,59,14

RTEXT "Password:",IDT_PASSWORD,12,16,72,8

END

IDD_MOUNT_DLG DIALOGEX 0, 0, 375, 271

CONTROL "",IDC_STATIC,"Static",SS_ETCHEDFRAME,2,151,372,119

END

STYLE DS_SETFONT | DS_MODALFRAME | DS_3DLOOK | DS_FIXEDSYS | DS_CENTER | WS_POPUP | WS_VISIBLE | WS_CAPTION

CAPTION "Enter VeraCrypt Volume Password"

FONT 8, "MS Shell Dlg", 0, 0, 0x0

BEGIN

CONTROL "Cache passwords and keyfil&es in memory",IDC_CACHE,

END

IDD_TRAVELER_DLG DIALOGEX 0, 0, 300, 269

LEFTMARGIN, 7

RIGHTMARGIN, 309

TOPMARGIN, 7

END

IDD_MOUNT_DLG, DIALOG

IDD_PASSWORD_DLG, DIALOG

BEGIN

END

IDD_TRAVELER_DLG, DIALOG

#define IDC_ENABLE_NEW_KEYFILES 1012

#define IDC_PRESERVE_TIMESTAMPS 1013

#define IDC_PREF_WIPE_CACHE_ON_EXIT 1014

#define IDC_PREF_CACHE_PASSWORDS 1016

#define IDC_DIRECTORY 1017

#define IDC_PREF_DISMOUNT_LOGOFF 1018

#define IDT_NEW 1054

#define IDT_NEW_PASSWORD 1055

#define IDT_CONFIRM_PASSWORD 1056

#define IDT_PW_CACHE_OPTIONS 1058

#define IDT_DEFAULT_MOUNT_OPTIONS 1059

#define IDT_WINDOWS_RELATED_SETTING 1060

#define IDC_FAVORITES_HELP_LINK 1135

#define IDC_FAV_VOL_OPTIONS_GLOBAL_SETTINGS_BOX 1136

#define IDC_PREF_DISMOUNT_SESSION_LOCKED 1137

#define IDM_HELP 40001

#define IDM_ABOUT 40002

#define IDM_UNMOUNT_VOLUME 40003

#define _APS_NO_MFC 1

#define _APS_NEXT_RESOURCE_VALUE 118

#define _APS_NEXT_COMMAND_VALUE 40064

#define _APS_NEXT_SYMED_VALUE 101

#endif

#endif

*/

#define TC_MAIN_COM_VERSION_MAJOR 2

#define TC_FORMAT_COM_VERSION_MAJOR 2

#define TC_FORMAT_COM_VERSION_MINOR 4