BOOL RecoveryMode;

int pkcs5_prf;

int ProtectedHidVolPkcs5Prf;

} MOUNT_STRUCT;

typedef struct

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

PCRYPTO_INFO cryptoInfo = NULL;

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

if (status != 0)

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

unsigned __int8 k2[MASTER_KEYDATA_SIZE]; /* For XTS, this contains the secondary key (if cascade, multiple concatenated). For LRW (deprecated/legacy), it contains the tweak key. For CBC (deprecated/legacy), it contains the IV seed. */

unsigned __int8 salt[PKCS5_SALT_SIZE];

int noIterations;

uint64 volume_creation_time; // Legacy

uint64 header_creation_time; // Legacy

// A non-error

break;

default:

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

MessageBoxW (hwndDlg, szTmp, lpszTitle, ICON_HAND);

case SHA512:

/* PKCS-5 test with HMAC-SHA-512 used as the PRF */

break;

case SHA256:

/* PKCS-5 test with HMAC-SHA-256 used as the PRF */

break;

case RIPEMD160:

/* PKCS-5 test with HMAC-RIPEMD-160 used as the PRF */

break;

case WHIRLPOOL:

/* PKCS-5 test with HMAC-Whirlpool used as the PRF */

break;

}

}

char *volumePath,

Password *password,

int pkcs5,

BOOL cachePassword,

BOOL sharedAccess,

const MountOptions* const mountOptions,

mount.bMountManager = TRUE;

mount.pkcs5_prf = pkcs5;

// Windows 2000 mount manager causes problems with remounted volumes

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

&mount.nPartitionInInactiveSysEncScopeDriveNo,

sizeof(mount.nPartitionInInactiveSysEncScopeDriveNo)) != 1)

{

return -1;

}

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

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

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

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

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 (HWND hwndDlg, 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="IDC_SHOW_PASSWORD_CHPWD_ORI">Display password</control>

<control lang="en" key="IDC_TRAVEL_OPEN_EXPLORER">Open &amp;Explorer window for mounted volume</control>

<control lang="en" key="IDC_TRAV_CACHE_PASSWORDS">&amp;Cache password in driver memory</control>

<control lang="en" key="IDC_UNMOUNTALL">Di&amp;smount All</control>

<control lang="en" key="IDC_VOLUME_PROPERTIES">&amp;Volume Properties...</control>

<control lang="en" key="IDC_VOLUME_TOOLS">Volume &amp;Tools...</control>

<string lang="en" key="EXTRA_BOOT_PARTITION_REMOVAL_INSTRUCTIONS">\nThe extra boot partition can be removed before installing Windows. To do so, follow these steps:\n\n1) Boot your Windows installation disc.\n\n2) In the Windows installer screen, click 'Install now' > 'Custom (advanced)'.\n\n3) Click 'Drive Options'.\n\n4) Select the main system partition and delete it by clicking 'Delete' and 'OK'.\n\n5) Select the 'System Reserved' partition, click 'Extend', and increase its size so that the operating system can be installed to it.\n\n6) Click 'Apply' and 'OK'.\n\n7) Install Windows on the 'System Reserved' partition.\n\n\nShould an attacker ask why you removed the extra boot partition, you can answer that you wanted to prevent any possible data leaks to the unencrypted boot partition.\n\nNote: You can print this text by clicking the 'Print' button below. If you save a copy of this text or print it (strongly recommended, unless your printer stores copies of documents it prints on its internal drive), you should destroy any copies of it after removing the extra boot partition (otherwise, if such a copy was found, it might indicate that there is a hidden operating system on this computer).</string>

<string lang="en" key="GAP_BETWEEN_SYS_AND_HIDDEN_OS_PARTITION">Warning: There is unallocated space between the system partition and the first partition behind it. After you create the hidden operating system, you must not create any new partitions in that unallocated space. Otherwise, the hidden operating system will be impossible to boot (until you delete such newly created partitions).</string>

<string lang="en" key="ALGO_NOT_SUPPORTED_FOR_SYS_ENCRYPTION">This algorithm is currently not supported for system encryption.</string>

<string lang="en" key="KEYFILES_NOT_SUPPORTED_FOR_SYS_ENCRYPTION">Keyfiles are currently not supported for system encryption.</string>

<string lang="en" key="CANNOT_RESTORE_KEYBOARD_LAYOUT">Warning: VeraCrypt could not restore the original keyboard layout. This may cause you to enter a password incorrectly.</string>

<string lang="en" key="CANT_CHANGE_KEYB_LAYOUT_FOR_SYS_ENCRYPTION">Error: Cannot set the keyboard layout for VeraCrypt to the standard US keyboard layout.\n\nNote that the password needs to be typed in the pre-boot environment (before Windows starts) where non-US Windows keyboard layouts are not available. Therefore, the password must always be typed using the standard US keyboard layout.</string>

<string lang="en" key="ASK_REMOVE_DEVICE_WRITE_PROTECTION">Do you want VeraCrypt to attempt to disable write protection of the partition/drive?</string>

<string lang="en" key="CONFIRM_SETTING_DEGRADES_PERFORMANCE">WARNING: This setting may degrade performance.\n\nAre you sure you want to use this setting?</string>

<string lang="en" key="HOST_DEVICE_REMOVAL_DISMOUNT_WARN_TITLE">Warning: VeraCrypt volume auto-dismounted</string>

<string lang="en" key="KEYFILE">Keyfile</string>

<string lang="en" key="VKEY_08">Backspace</string>

<string lang="en" key="VKEY_09">Tab</string>

return TRUE;

}

{

int nDosLinkCreated = 1, nStatus = ERR_OS_ERROR;

char szDiskFile[TC_MAX_PATH], szCFDevice[TC_MAX_PATH];

if (oldPassword->Length == 0 || newPassword->Length == 0) return -1;

{

nStatus = ERR_PARAMETER_INCORRECT;

handleError (hwndDlg, nStatus);

/* Try to decrypt the header */

if (nStatus == ERR_CIPHER_INIT_WEAK_KEY)

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

(volumeType == TC_VOLUME_TYPE_HIDDEN) ? cryptoInfo->hiddenVolumeSize : 0,

cryptoInfo->EncryptedAreaStart.Value,

cryptoInfo->EncryptedAreaLength.Value,

cryptoInfo->HeaderFlags,

cryptoInfo->SectorSize,

wipePass < wipePassCount - 1);

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)

{

switch (pkcs5_prf_id)

{

case RIPEMD160:

case SHA512:

case WHIRLPOOL:

case SHA256:

return bBoot? 200000 : 500000;

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

void derive_u_whirlpool (char *pwd, int pwd_len, char *salt, int salt_len, int iterations, char *u, int b);

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

char *get_pkcs5_prf_name (int pkcs5_prf_id);

#if defined(__cplusplus)

ERR_PARAMETER_INCORRECT = 30,

ERR_SYS_HIDVOL_HEAD_REENC_MODE_WRONG = 31,

ERR_NONSYS_INPLACE_ENC_INCOMPLETE = 32,

};

#endif // #ifndef TCDEFS_H

BOOL ReadVolumeHeaderRecoveryMode = FALSE;

{

char header[TC_VOLUME_HEADER_EFFECTIVE_SIZE];

KEY_INFO keyInfo;

LONG outstandingWorkItemCount = 0;

int i;

if (retHeaderCryptoInfo != NULL)

{

cryptoInfo = retHeaderCryptoInfo;

if (selected_pkcs5_prf != 0 && enqPkcs5Prf != selected_pkcs5_prf)

continue;

if ((selected_pkcs5_prf == 0) && (encryptionThreadCount > 1))

{

// Enqueue key derivation on thread pool

EncryptionThreadPoolBeginKeyDerivation (&keyDerivationCompletedEvent, &noOutstandingWorkItemEvent,

&item->KeyReady, &outstandingWorkItemCount, enqPkcs5Prf, keyInfo.userKey,

++queuedWorkItems;

break;

if (!item->Free && InterlockedExchangeAdd (&item->KeyReady, 0) == TRUE)

{

pkcs5_prf = item->Pkcs5Prf;

memcpy (dk, item->DerivedKey, sizeof (dk));

item->Free = TRUE;

else

{

pkcs5_prf = enqPkcs5Prf;

switch (pkcs5_prf)

{

DecryptBuffer (header + HEADER_ENCRYPTED_DATA_OFFSET, HEADER_ENCRYPTED_DATA_SIZE, cryptoInfo);

continue;

// Header version

// Required program version

cryptoInfo->RequiredProgramVersion = GetHeaderField16 (header, TC_HEADER_OFFSET_REQUIRED_VERSION);

// Check CRC of the key set

if (!ReadVolumeHeaderRecoveryMode

// Now we have the correct password, cipher, hash algorithm, and volume type

// Check the version required to handle this volume

{

status = ERR_NEW_VERSION_REQUIRED;

goto err;

{

cryptoInfo->pkcs5 = pkcs5_prf;

cryptoInfo->noIterations = keyInfo.noIterations;

goto ret;

}

memcpy (cryptoInfo->salt, keyInfo.salt, PKCS5_SALT_SIZE);

cryptoInfo->pkcs5 = pkcs5_prf;

cryptoInfo->noIterations = keyInfo.noIterations;

// Init the cipher with the decrypted master key

status = EAInit (cryptoInfo->ea, keyInfo.master_keydata + primaryKeyOffset, cryptoInfo->ks);

// User key

memcpy (keyInfo.userKey, password->Text, nUserKeyLen);

keyInfo.keyLength = nUserKeyLen;

// User selected encryption algorithm

cryptoInfo->ea = ea;

// User selected PRF

cryptoInfo->pkcs5 = pkcs5_prf;

// Mode of operation

cryptoInfo->mode = mode;

#ifdef TC_WINDOWS_BOOT

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

#else

#endif

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

}

}

{

// Header decrypted

status = STATUS_SUCCESS;

goto ret;

}

{

Dump ("Header reopened\n");

if (mount->VolumePassword.Length > MAX_PASSWORD || mount->ProtectedHidVolPassword.Length > MAX_PASSWORD

|| mount->pkcs5_prf < 0 || mount->pkcs5_prf > LAST_PRF_ID

{

Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;

Irp->IoStatus.Information = 0;

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

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

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

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

}

break;

readBuffer,

&mount->ProtectedHidVolPassword,

mount->ProtectedHidVolPkcs5Prf,

&tmpCryptoInfo);

}

else

readBuffer,

&mount->VolumePassword,

mount->pkcs5_prf,

&Extension->cryptoInfo);

}

}

if (nStatus != ERR_SUCCESS)

goto closing_seq;

{

OpenVolumeContext volume;

{

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

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

mountOptions.PartitionInInactiveSysEncScope = FALSE;

mountOptions.UseBackupHeader = FALSE;

{

*driveNo = -3;

return ERR_VOL_MOUNT_FAILED;

CW2A volumePathA(volumePath);

MainDlg = (HWND) hWnd;

if (volumePathA.m_psz)

else

return ERR_OUTOFMEMORY;

}

CW2A volumePathA(volumePath);

MainDlg = (HWND) hWnd;

if (volumePathA.m_psz)

else

return ERR_OUTOFMEMORY;

}

}

{

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

{

DWORD SetDriverServiceStartType (DWORD startType);

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

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

};

[

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

int VolumePkcs5 = 0;

int CmdVolumePkcs5 = 0;

BOOL CmdVolumePasswordValid = FALSE;

MountOptions CmdMountOptions;

BOOL CmdMountOptionsValid = FALSE;

burn (&CmdVolumePassword, sizeof (CmdVolumePassword));

burn (&VolumePkcs5, sizeof (VolumePkcs5));

burn (&CmdVolumePkcs5, sizeof (CmdVolumePkcs5));

burn (&mountOptions, sizeof (mountOptions));

burn (&defaultMountOptions, sizeof (defaultMountOptions));

burn (szFileName, sizeof(szFileName));

Password *newPassword;

int pkcs5;

int wipePassCount;

int* pnStatus;

} ChangePwdThreadParam;

{

// Non-system

if (*pThreadParam->pnStatus == ERR_OS_ERROR

&& GetLastError () == ERROR_ACCESS_DENIED

&& IsUacSupported ()

&& IsVolumeDeviceHosted (szFileName))

{

}

}

}

if (bSysEncPwdChangeDlgMode)

{

ToBootPwdField (hwndDlg, IDC_PASSWORD);

ToBootPwdField (hwndDlg, IDC_VERIFY);

ToBootPwdField (hwndDlg, IDC_OLD_PASSWORD);

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

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

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

if (!CheckPasswordCharEncoding (GetDlgItem (hwndDlg, IDC_PASSWORD), NULL))

{

changePwdParam.pkcs5 = pkcs5;

changePwdParam.wipePassCount = GetWipePassCount(headerWiperMode);

changePwdParam.pnStatus = &nStatus;

ShowWaitDialog(hwndDlg, TRUE, ChangePwdWaitThreadProc, &changePwdParam);

WORD lw = LOWORD (wParam);

static Password *szXPwd;

static int *pkcs5;

switch (msg)

{

int i, nIndex;

szXPwd = ((PasswordDlgParam *) lParam) -> password;

pkcs5 = ((PasswordDlgParam *) lParam) -> pkcs5;

LocalizeDialog (hwndDlg, "IDD_PASSWORD_DLG");

DragAcceptFiles (hwndDlg, TRUE);

{

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

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

}

if (!SetForegroundWindow (hwndDlg) && (FavoriteMountOnArrivalInProgress || LogOn))

case TC_APPMSG_PREBOOT_PASSWORD_MODE:

{

ToBootPwdField (hwndDlg, IDC_PASSWORD);

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

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

*pkcs5 = (int) SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETITEMDATA, SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETCURSEL, 0, 0), 0);

}

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

HWND hComboBox = GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID);

SendMessage (hComboBox, CB_RESETCONTENT, 0, 0);

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

}

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

ListSubItemSetW (list, i++, 1, GetString (IsHiddenOSRunning() ? "TYPE_HIDDEN_SYSTEM_ADJECTIVE" : "SYSTEM_VOLUME_TYPE_ADJECTIVE"));

else

{

}

if (!bSysEnc)

return item.lParam;

}

{

int result;

PasswordDlgParam dlgParam;

dlgParam.password = password;

dlgParam.pkcs5 = pkcs5;

result = DialogBoxParamW (hInst,

MAKEINTRESOURCEW (IDD_PASSWORD_DLG), hwndDlg,

{

password->Length = 0;

*pkcs5 = 0;

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

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

}

{

VolumePassword.Length = 0;

VolumePkcs5 = 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 (hwndDlg, &emptyPassword, FirstKeyFile);

if (mounted)

VolumePkcs5 = CmdVolumePkcs5;

burn (&emptyPassword, sizeof (emptyPassword));

}

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

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

NormalCursor ();

{

VolumePassword = CmdVolumePassword;

VolumePkcs5 = CmdVolumePkcs5;

}

else if (!Silent)

{

int GuiPkcs5 = CmdVolumePkcs5;

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

goto ret;

else

{

VolumePkcs5 = GuiPkcs5;

burn (&GuiPkcs5, sizeof(GuiPkcs5));

}

}

if (KeyFilesEnable)

KeyFilesApply (hwndDlg, &VolumePassword, FirstKeyFile);

NormalCursor ();

// Check for legacy non-ASCII passwords

{

burn (&VolumePassword, sizeof (VolumePassword));

burn (&VolumePkcs5, sizeof (VolumePkcs5));

}

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

{

burn (&VolumePassword, sizeof (VolumePassword));

burn (&VolumePkcs5, sizeof (VolumePkcs5));

}

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

if (!CmdVolumePasswordValid && bPasswordPrompt)

{

int GuiPkcs5 = CmdVolumePkcs5;

PasswordDlgVolume[0] = '\0';

goto ret;

else

{

VolumePkcs5 = GuiPkcs5;

burn (&GuiPkcs5, sizeof(GuiPkcs5));

}

}

else if (CmdVolumePasswordValid)

bPasswordPrompt = FALSE;

VolumePassword = CmdVolumePassword;

VolumePkcs5 = CmdVolumePkcs5;

}

WaitCursor();

goto ret;

// First try user password then cached passwords

{

// A volume has been successfully mounted

{

burn (&VolumePassword, sizeof (VolumePassword));

burn (&VolumePkcs5, sizeof (VolumePkcs5));

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

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

}

burn (&VolumePassword, sizeof (VolumePassword));

burn (&VolumePkcs5, sizeof (VolumePkcs5));

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

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

BOOL mounted;

// Cached password

// Command line password or keyfiles

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

KeyFilesApply (hwndDlg, &CmdVolumePassword, FirstCmdKeyFile);

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

&mountOptions, Silent, reportBadPasswd);

burn (&CmdVolumePassword, sizeof (CmdVolumePassword));

while (!mounted && !Silent)

{

int GuiPkcs5 = CmdVolumePkcs5;

VolumePassword.Length = 0;

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

break;

else

{

VolumePkcs5 = GuiPkcs5;

burn (&GuiPkcs5, sizeof(GuiPkcs5));

}

WaitCursor ();

if (KeyFilesEnable && FirstKeyFile)

KeyFilesApply (hwndDlg, &VolumePassword, FirstKeyFile);

burn (&VolumePassword, sizeof (VolumePassword));

burn (&VolumePkcs5, sizeof (VolumePkcs5));

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

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

OptionVolume,

CommandWipeCache,

OptionPkcs5,

};

argument args[]=

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

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

{ CommandWipeCache, "/wipecache", "/w", FALSE },

};

argumentspec as;

Error ("COMMAND_LINE_ERROR", hwndDlg);

}

break;

// no option = file name

default:

MultipleMountOperationInProgress = FALSE;

burn (&VolumePassword, sizeof (VolumePassword));

burn (&VolumePkcs5, sizeof (VolumePkcs5));

if (status && CloseSecurityTokenSessionsAfterMount)

SecurityToken::CloseAllSessions();

while (TRUE)

{

{

nStatus = ERR_SUCCESS;

goto ret;

if (KeyFilesEnable && FirstKeyFile)

KeyFilesApply (hwndDlg, askPassword, FirstKeyFile);

NormalCursor();

burn (&VolumePassword, sizeof (VolumePassword));

burn (&VolumePkcs5, sizeof (VolumePkcs5));

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 (hwndDlg, &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;

}

burn (&VolumePassword, sizeof (VolumePassword));

burn (&VolumePkcs5, sizeof (VolumePkcs5));

RestoreDefaultKeyFilesParam();

RandStop (FALSE);

NormalCursor();

{

Password *password;

int* pkcs5;

} PasswordDlgParam;

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

CONTROL "Display password",IDC_SHOW_PASSWORD_CHPWD_ORI,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,89,65,138,10,WS_EX_TRANSPARENT

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

RTEXT "Password:",IDT_NEW_PASSWORD,8,102,76,8

RTEXT "Confirm Password:",IDT_CONFIRM_PASSWORD,9,118,75,16

RTEXT "PKCS-5 PRF:",IDT_NEW_PKCS5_PRF,9,162,74,10,SS_CENTERIMAGE

RTEXT "Wipe mode:",IDT_WIPE_MODE,9,182,74,8,0,WS_EX_RIGHT

RTEXT "PKCS-5 PRF:",IDT_PKCS5_PRF,12,34,74,10,SS_CENTERIMAGE

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,

"Button",BS_AUTOCHECKBOX | WS_TABSTOP,70,50,153,10

CONTROL "&Display password",IDC_SHOW_PASSWORD,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,70,63,83,10

CONTROL "U&se keyfiles",IDC_KEYFILES_ENABLE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,70,75,83,11

RTEXT "Password:",IDT_PASSWORD,0,10,65,13

RTEXT "PKCS-5 PRF:",IDT_PKCS5_PRF,0,27,65,13

END

IDD_TRAVELER_DLG DIALOGEX 0, 0, 300, 269

IDD_PASSWORDCHANGE_DLG, DIALOG

BEGIN

LEFTMARGIN, 7

TOPMARGIN, 7

BOTTOMMARGIN, 200

END

IDD_PASSWORD_DLG, DIALOG

BEGIN

BOTTOMMARGIN, 86

END

#define IDC_PREF_DISMOUNT_SESSION_LOCKED 1137

#define IDT_NEW_PKCS5_PRF 1138

#define IDC_PKCS5_OLD_PRF_ID 1139

#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 40065

#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