SYSENC_COMMAND_CREATE_HIDDEN_OS,

SYSENC_COMMAND_CREATE_HIDDEN_OS_ELEV

};

enum password_status

{

very_weak = 0,

HWND hCurPage = NULL; /* Handle to current wizard page */

int nCurPageNo = -1; /* The current wizard page */

int nLastPageNo = -1;

volatile BOOL bHiddenOS = FALSE; /* If TRUE, we are performing or (or supposed to perform) actions relating to an operating system installed in a hidden volume (i.e., encrypting a decoy OS partition or creating the outer/hidden volume for the hidden OS). To determine or set the phase of the process, call ChangeHiddenOSCreationPhase() and DetermineHiddenOSCreationPhase()) */

BOOL bDirectSysEncMode = FALSE;

BOOL bDirectSysEncModeCommand = SYSENC_COMMAND_NONE;

BOOL DirectPromptNonSysInplaceEncResumeMode = FALSE;

BOOL DirectCreationMode = FALSE;

volatile BOOL bInPlaceDecNonSys = FALSE; /* If TRUE, existing data on a non-system partition/volume are to be decrypted in place (for system encryption, this flag is ignored) */

volatile BOOL bInPlaceEncNonSysResumed = FALSE; /* If TRUE, the wizard is supposed to resume (or has resumed) process of non-system in-place encryption/decryption. */

volatile BOOL bFirstNonSysInPlaceEncResumeDone = FALSE;

__int64 NonSysInplaceEncBytesDone = 0;

__int64 NonSysInplaceEncTotalSize = 0;

int nNeedToStoreFilesOver4GB = 0; /* Whether the user wants to be able to store files larger than 4GB on the volume: -1 = Undecided or error, 0 = No, 1 = Yes */

int nVolumeEA = 1; /* Default encryption algorithm */

BOOL bSystemEncryptionInProgress = FALSE; /* TRUE when encrypting/decrypting the system partition/drive (FALSE when paused). */

volatile BOOL bSysEncDriveAnalysisTimeOutOccurred = FALSE;

int SysEncDetectHiddenSectors = -1; /* Whether the user wants us to detect and encrypt the Host Protect Area (if any): -1 = Undecided or error, 0 = No, 1 = Yes */

int SysEncDriveAnalysisStart;

BOOL bFirstSysEncResumeDone = FALSE;

BOOL bDontCheckFileContainerSize = FALSE; /* If true, we don't check if the given size of file container is smaller than the available size on the hosting disk */

int nMultiBoot = 0; /* The number of operating systems installed on the computer, according to the user. 0: undetermined, 1: one, 2: two or more */

volatile BOOL bHiddenVol = FALSE; /* If true, we are (or will be) creating a hidden volume. */

volatile BOOL bHiddenVolHost = FALSE; /* If true, we are (or will be) creating the host volume (called "outer") for a hidden volume. */

volatile BOOL bHiddenVolDirect = FALSE; /* If true, the wizard omits creating a host volume in the course of the process of hidden volume creation. */

volatile HWND hVerifyPasswordInputField = NULL; /* Verify-password input field */

HBITMAP hbmWizardBitmapRescaled = NULL;

wchar_t OrigKeyboardLayout [8+1] = L"00000409";

BOOL bKeyboardLayoutChanged = FALSE; /* TRUE if the keyboard layout was changed to the standard US keyboard layout (from any other layout). */

BOOL bKeybLayoutAltKeyWarningShown = FALSE; /* TRUE if the user has been informed that it is not possible to type characters by pressing keys while the right Alt key is held down. */

Password outerVolumePassword; /* Outer volume user password */

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

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

int volumePim = 0;

int outerVolumePim = 0;

BOOL bDisplayPoolContents = TRUE;

volatile BOOL bSparseFileSwitch = FALSE;

volatile BOOL fastCreateFile = FALSE;

volatile BOOL dynamicFormat = FALSE; /* this variable represents the sparse file flag. */

volatile int fileSystem = FILESYS_NONE;

BOOL bIsSparseFilesSupportedByHost = FALSE;

vector <HostDevice> DeferredNonSysInPlaceEncDevices;

int iMaxPasswordLength = MAX_PASSWORD;

else

{

wchar_t name[100];

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

EAGetName (name, nIndex, 0);

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

}

}

{

return;

}

EnableWindow (GetDlgItem (hCurPage, IDC_WIPE_MODE),

!locBootEncStatus.SetupInProgress

&& SystemEncryptionStatus == SYSENC_STATUS_ENCRYPTING);

SetWindowTextW (GetDlgItem (hCurPage, IDC_PAUSE),

GetString (locBootEncStatus.SetupInProgress ? "IDC_PAUSE" : "RESUME"));

volParams->headerFlags = (CreatingHiddenSysVol() ? TC_HEADER_FLAG_ENCRYPTED_SYSTEM : 0);

volParams->fileSystem = fileSystem;

volParams->clusterSize = clusterSize;

volParams->quickFormat = quickFormat;

volParams->sectorSize = GetFormatSectorSize();

volParams->realClusterSize = &realClusterSize;

volParams->password = &volumePassword;

{

Info("FORMAT_FINISHED_INFO", hwndDlg);

Warning("SPARSE_FILE_SIZE_NOTE", hwndDlg);

}

}

case PASSWORD_PAGE:

{

wchar_t tmp[MAX_PASSWORD+1];

// Attempt to wipe passwords stored in the input field buffers. This is performed here (and

// not in the IDC_PREV or IDC_NEXT sections) in order to prevent certain race conditions

tmp [MAX_PASSWORD] = 0;

SetWindowText (hPasswordInputField, tmp);

SetWindowText (hVerifyPasswordInputField, tmp);

}

break;

}

return TRUE;

}

BOOL QueryFreeSpace (HWND hwndDlg, HWND hwndTextBox, BOOL display, LONGLONG *pFreeSpaceValue, BOOL* pbIsSparceFilesSupported)

{

if (pFreeSpaceValue)

UpdateWizardModeControls (hwndDlg, WizardMode);

break;

bHiddenVolHost = bHiddenVol = bHiddenOS;

{

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

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

}

else

{

{

}

else

{

}

}

SetWindowTextW (GetDlgItem (MainDlg, IDC_NEXT), GetString ("NEXT"));

SetWindowTextW (GetDlgItem (MainDlg, IDC_PREV), GetString ("PREV"));

SetWindowTextW (GetDlgItem (MainDlg, IDCANCEL), GetString ("CANCEL"));

// Start loading the password dictonary into memory ("need" is just a random word for initializing the process)

CheckWord("need");

break;

case SYSENC_HIDDEN_OS_REQ_CHECK_PAGE:

SetWindowTextW (GetDlgItem (GetParent (hwndDlg), IDC_BOX_TITLE), GetString ("SYSENC_HIDDEN_OS_REQ_CHECK_PAGE_TITLE"));

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

break;

case SYSENC_PRE_DRIVE_ANALYSIS_PAGE:

Init2RadButtonPageYesNo (SysEncDetectHiddenSectors);

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

break;

case SYSENC_MULTI_BOOT_SYS_EQ_BOOT_PAGE:

}

break;

{

}

{

}

break;

case SIZE_PAGE:

break;

case PASSWORD_PAGE:

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

hPasswordInputField = GetDlgItem (hwndDlg, IDC_PASSWORD);

ToBootPwdField (hwndDlg, IDC_PASSWORD);

ToBootPwdField (hwndDlg, IDC_VERIFY);

{

{

}

}

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

{

Error ("CANNOT_SET_TIMER", MainDlg);

EndMainDlg (MainDlg);

return 1;

}

}

SetFocus (GetDlgItem (hwndDlg, IDC_PASSWORD));

if (CreatingHiddenSysVol())

SetWindowTextW (GetDlgItem (GetParent (hwndDlg), IDC_BOX_TITLE), GetString ("PASSWORD_HIDDEN_OS_TITLE"));

else if (bHiddenVol)

SetWindowTextW (GetDlgItem (GetParent (hwndDlg), IDC_BOX_TITLE), GetString ("CHOOSE_PASSWORD_TITLE"));

else

SetWindowTextW (GetDlgItem (GetParent (hwndDlg), IDC_BOX_TITLE), GetString ("PASSWORD_TITLE"));

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

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

NULL,

NULL,

KeyFilesEnable && FirstKeyFile!=NULL && !SysEncInEffect());

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

{

}

}

break;

case PIM_PAGE:

SetWindowTextW (GetDlgItem (GetParent (hwndDlg), IDC_BOX_TITLE), GetString ("RESCUE_DISK"));

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

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

SetWindowTextW(GetDlgItem(hwndDlg, IDT_RESCUE_DISK_INFO_2), GetString("RESCUE_DISK_INFO_2"));

SetCheckBox (hwndDlg, IDC_SKIP_RESCUE_VERIFICATION, bDontVerifyRescueDisk);

}

SetWindowTextW (GetDlgItem (hwndDlg, IDT_RESCUE_DISK_BURN_INFO), szTmp);

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

/* The 'Back' button is enabled but user can't go back, instead warning is provided */

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

break;

case SYSENC_RESCUE_DISK_VERIFIED_PAGE:

break;

case SYSENC_WIPE_MODE_PAGE:

break;

case SYSENC_PRETEST_INFO_PAGE:

{

StringCbPrintfW (finalMsg, sizeof(finalMsg),

GetString ("SYS_ENCRYPTION_PRETEST_INFO"),

}

catch (Exception &e)

{

SetWindowTextW (GetDlgItem (GetParent (hwndDlg), IDC_BOX_TITLE), GetString ("SYS_ENCRYPTION_PRETEST_RESULT_TITLE"));

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

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

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

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

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

break;

case SYSENC_ENCRYPTION_PAGE:

SetWindowTextW (GetDlgItem (GetParent (hwndDlg), IDC_BOX_TITLE),

GetString (SystemEncryptionStatus != SYSENC_STATUS_DECRYPTING ? "ENCRYPTION" : "DECRYPTION"));

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

SetWindowTextW (GetDlgItem (GetParent (hwndDlg), IDC_NEXT),

GetString (SystemEncryptionStatus != SYSENC_STATUS_DECRYPTING ? "ENCRYPT" : "DECRYPT"));

SetWindowTextW (GetDlgItem (hwndDlg, IDC_PAUSE),

GetString (bSystemEncryptionInProgress ? "IDC_PAUSE" : "RESUME"));

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

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

if (SystemEncryptionStatus == SYSENC_STATUS_DECRYPTING)

{

nWipeMode = TC_WIPE_NONE;

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

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

PopulateWipeModeCombo (GetDlgItem (hwndDlg, IDC_WIPE_MODE), TRUE, TRUE, FALSE);

}

else

{

PopulateWipeModeCombo (GetDlgItem (hwndDlg, IDC_WIPE_MODE), FALSE, TRUE, FALSE);

SelectAlgo (GetDlgItem (hwndDlg, IDC_WIPE_MODE), (int *) &nWipeMode);

}

{

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

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

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

}

PostMessage (hwndDlg, TC_APPMSG_PERFORM_POST_SYSENC_WMINIT_TASKS, 0, 0);

}

else

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

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

if (bInPlaceDecNonSys)

{

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

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

PopulateWipeModeCombo (GetDlgItem (hwndDlg, IDC_WIPE_MODE), FALSE, TRUE, FALSE);

SelectAlgo (GetDlgItem (hwndDlg, IDC_WIPE_MODE), (int *) &nWipeMode);

}

break;

case NONSYS_INPLACE_ENC_TRANSFORM_FINISHED_PAGE:

{

dynamicFormat = FALSE;

bSparseFileSwitch = FALSE;

SetCheckBox (hwndDlg, SPARSE_FILE, FALSE);

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

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

{

wchar_t root[TC_MAX_PATH];

DWORD fileSystemFlags = 0;

/* Check if the host file system supports sparse files */

if (GetVolumePathName (szFileName, root, array_capacity (root)))

dynamicFormat = FALSE;

SetCheckBox (hwndDlg, SPARSE_FILE, FALSE);

}

EnableWindow (GetDlgItem (hwndDlg, SPARSE_FILE), bSparseFileSwitch);

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

}

break;

case DEVICE_WIPE_PAGE:

if (bHiddenOS && IsHiddenOSRunning())

{

// Decoy system partition wipe

case WM_CTLCOLORSTATIC:

{

{

// we're about to draw the static

// set the text colour in (HDC)lParam

SetTextColor ((HDC)wParam, RGB(255, 0, 0)); // password weak red

return (BOOL)GetSysColorBrush(COLOR_MENU);

}

{

// we're about to draw the static

// set the text colour in (HDC)lParam

return (BOOL) GetSysColorBrush (COLOR_MENU);

}

{

SetBkMode ((HDC)wParam, TRANSPARENT);

SetTextColor ((HDC)wParam, RGB (218, 218, 0)); // password strong yellow

return (BOOL) GetSysColorBrush (COLOR_MENU);

}

{

SetBkMode((HDC)wParam, TRANSPARENT);

SetTextColor((HDC)wParam, RGB(50, 205, 50)); // password very strong green

return (BOOL) GetSysColorBrush (COLOR_MENU);

}

{

// we're about to draw the static

// set the text colour in (HDC)lParam

// NOTE: per documentation as pointed out by selbie, GetSolidBrush would leak a GDI handle.

}

}

return 0;

return 1;

}

}

if (lw == IDC_ADVANCE_INTRO && nCurPageNo == SYSENC_TYPE_PAGE)

{

DialogBoxParamW(hInst,

(DLGPROC)AdvanceDlgProcIntro, NULL);

return 1;

}

if (nCurPageNo == SYSENC_HIDDEN_OS_REQ_CHECK_PAGE && lw == IDC_HIDDEN_SYSENC_INFO_LINK)

{

Applink ("hiddensysenc");

break;

}

if (nCurPageNo == FILESYS_PAGE && (lw == IDC_CHOICE1 || lw == IDC_CHOICE2))

{

if (bWarnOuterVolSuitableFileSys && lw == IDC_CHOICE1 && bHiddenVolHost)

bValidEntry = FALSE;

}

}

EnableWindow (GetDlgItem (GetParent (hwndDlg), IDC_NEXT),

bValidEntry);

if (hw == EN_CHANGE && nCurPageNo == PASSWORD_PAGE)

{

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

{

}

{

}

{

}

{

}

else

{

}

return 1;

}

HandleShowPasswordFieldAction (hwndDlg, IDC_SHOW_PASSWORD, IDC_PASSWORD, IDC_VERIFY);

return 1;

}

if (lw == IDC_SHOW_PIM && nCurPageNo == PIM_PAGE)

{

HandleShowPasswordFieldAction (hwndDlg, IDC_SHOW_PIM, IDC_PIM, 0);

return 1;

}

if (lw == IDC_CHECKLIST_A)

{

}

if (lw == IDC_CHECKLIST_B)

{

}

if (lw == IDC_PIM_ENABLE)

return 1;

}

if (lw == IDC_QUICKFORMAT)

{

if (IsButtonChecked (GetDlgItem (hCurPage, IDC_QUICKFORMAT)))

}

return 1;

}

if (lw == SPARSE_FILE && IsButtonChecked (GetDlgItem (hCurPage, SPARSE_FILE)))

{

if (AskWarnYesNo("CONFIRM_SPARSE_FILE", MainDlg) == IDNO)

SetWindowText (GetDlgItem (hCurPage, IDC_DISK_KEY), showKeys ? L"" : L"******************************** ");

return 1;

}

if (lw == IDC_DISPLAY_POOL_CONTENTS

&& (nCurPageNo == SYSENC_COLLECTING_RANDOM_DATA_PAGE || nCurPageNo == NONSYS_INPLACE_ENC_RAND_DATA_PAGE))

{

return 1;

}

}

/* The password and rescue checkbox have to be clicked in order to enable the next button */

{

{

}

{

}

}

if ((nCurPageNo == SYSENC_WIPE_MODE_PAGE

|| nCurPageNo == NONSYS_INPLACE_ENC_WIPE_MODE_PAGE

|| nCurPageNo == DEVICE_WIPE_MODE_PAGE)

}

return 0;

return 0;

}

}

try

bSystemIsGPT = BootEncObj->GetSystemDriveConfiguration().SystemPartition.IsGPT;

}

catch (...)

{

AbortProcess ("VOLUME_TOO_LARGE_FOR_WINXP");

}

if (volumePassword.Length > 0)

{

// Check password length (check also done for outer volume which is not the case in TrueCrypt).

SHGetFolderPath (NULL, CSIDL_MYDOCUMENTS, NULL, 0, szRescueDiskISO);

StringCbCatW (szRescueDiskISO, sizeof(szRescueDiskISO), L"\\VeraCrypt Rescue Disk.zip");

if (IsOSAtLeast (WIN_VISTA))

{

// Availability of in-place encryption (which is pre-selected by default whenever

case TIMER_ID_SYSENC_PROGRESS:

{

// Manage system encryption/decryption and update related GUI

try

{

BootEncStatus = BootEncObj->GetStatus();

case TIMER_ID_KEYB_LAYOUT_GUARD:

if (SysEncInEffect ())

{

{

if (keybLayout != 0x00000409 && keybLayout != 0x04090409)

{

wchar_t szTmp [4096];

StringCbCatW (szTmp, sizeof(szTmp), L"\n\n");

StringCbCatW (szTmp, sizeof(szTmp), GetString ("KEYB_LAYOUT_SYS_ENC_EXPLANATION"));

}

}

}

return 1;

case TIMER_ID_SYSENC_DRIVE_ANALYSIS_PROGRESS:

if (bSysEncDriveAnalysisInProgress)

return 1;

}

else

}

else if ((nCurPageNo == SYSENC_ENCRYPTION_PAGE || nCurPageNo == SYSENC_PRETEST_RESULT_PAGE)

&& SystemEncryptionStatus != SYSENC_STATUS_NONE

case WM_COMMAND:

if (lw == IDHELP)

if (nCurPageNo == SYSENC_RESCUE_DISK_CREATION_PAGE ||

nCurPageNo == SYSENC_RESCUE_DISK_BURN_PAGE ||

nCurPageNo == SYSENC_RESCUE_DISK_VERIFIED_PAGE)

}

if (!bHiddenOS)

}

else if (nCurPageNo == SYSENC_HIDDEN_OS_REQ_CHECK_PAGE)

{

else if (nCurPageNo == PASSWORD_PAGE)

{

VerifyPasswordAndUpdate (hwndDlg, GetDlgItem (MainDlg, IDC_NEXT),

GetDlgItem (hCurPage, IDC_PASSWORD),

GetDlgItem (hCurPage, IDC_VERIFY),

}

}

if (bInPlaceEncNonSys)

{

nNewPageNo = NONSYS_INPLACE_ENC_RAND_DATA_PAGE - 1; // Skip irrelevant pages

}

}

wchar_t tmp[RANDPOOL_DISPLAY_SIZE + 1];

if (!bInPlaceEncNonSys)

{

tmp[ARRAYSIZE(tmp) - 1] = 0;

SetWindowText(hRandPoolSys, tmp);

NormalCursor();

}

else if (nCurPageNo == PIM_PAGE)

return 1;

}

// Check password length (check also done for outer volume which is not the case in TrueCrypt).

{

return 1;

}

}

if (bInPlaceEncNonSys)

{

nNewPageNo = NONSYS_INPLACE_ENC_RAND_DATA_PAGE - 1; // Skip irrelevant pages

{

nNewPageNo = FORMAT_PAGE - 1; // Skip irrelevant pages

}

}

else if (nCurPageNo == HIDDEN_VOL_HOST_PASSWORD_PAGE

|| nCurPageNo == NONSYS_INPLACE_ENC_RESUME_PASSWORD_PAGE)

{

WaitCursor ();

if (!GetPassword (hCurPage, IDC_PASSWORD_DIRECT, (char*) volumePassword.Text, iMaxPasswordLength + 1, FALSE, TRUE))

{

NormalCursor ();

GetWindowText (GetDlgItem (hCurPage, IDC_RESCUE_DISK_ISO_PATH), szRescueDiskISO, ARRAYSIZE (szRescueDiskISO));

try

{

WaitCursor();

wchar_t msg[8192];

StringCchPrintfW (msg, array_capacity (msg), GetString ("CD_BURNER_NOT_PRESENT_WILL_STORE_ISO_INFO"), szRescueDiskISO);

WarningDirect (msg, hwndDlg);

Warning ("RESCUE_DISK_BURN_NO_CHECK_WARN", hwndDlg);

bDontVerifyRescueDisk = TRUE;

nNewPageNo = SYSENC_RESCUE_DISK_VERIFIED_PAGE;

nNewPageNo = SYSENC_RESCUE_DISK_VERIFIED_PAGE; // Skip irrelevant pages

}

}

|| nCurPageNo == NONSYS_INPLACE_ENC_WIPE_MODE_PAGE)

{

if (nWipeMode > 0

&& AskWarnYesNo ("WIPE_MODE_WARN", hwndDlg) == IDNO)

return 1;

else if (nCurPageNo == SYSENC_PRETEST_INFO_PAGE)

{

// Cancel

return 1;

}

NonSysInplaceEncResume ();

return 1;

}

SetWindowTextW (GetDlgItem (MainDlg, IDCANCEL), GetString ("CANCEL"));

bHiddenVolFinished = FALSE;

WipePasswordsAndKeyfiles (true);

return 1;

}

return 1;

}

ovf_end:

return 1;

}

if (nCurPageNo == SYSENC_SPAN_PAGE)

{

// Skip irrelevant pages when going back

}

if (nCurPageNo == SYSENC_RESCUE_DISK_BURN_PAGE)

{

Warning("RESCUE_DISK_BACK_BUTTON", hwndDlg);

}

if (nCurPageNo == SYSENC_MULTI_BOOT_MODE_PAGE)

{

// Skip the drive analysis page(s) or other irrelevant pages when going back

if (SysEncInEffect ())

{

KillTimer (hwndDlg, TIMER_ID_KEYB_LAYOUT_GUARD);

}

else if (bInPlaceEncNonSys)

nNewPageNo = CIPHER_PAGE + 1;

}

else if (nCurPageNo == PIM_PAGE)

nNewPageNo = (PimEnable? PIM_PAGE : PASSWORD_PAGE) + 1;

}

}

return 1;

}

else

{

// Unsupported file system

Error ("HIDDEN_VOL_HOST_UNSUPPORTED_FILESYS", hwndDlg);

return 0;

}

return;

}

}

}

return geometry.Geometry.BytesPerSector;

}

/* This function is called when advanced dialog in intro page is open */

{

WORD lw = LOWORD(wParam);

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

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

case WM_COMMAND:

{

if (lw == IDCANCEL)

}

/* AES, HASH, Pim and Wipe mode can be selected here */

{

WORD lw = LOWORD(wParam);

WORD hw = HIWORD(wParam);

{

case WM_INITDIALOG:

{

/* Encryption algorithms */

SendMessage(GetDlgItem(hwndDlg, IDC_COMBO_BOX), CB_RESETCONTENT, 0, 0);

SelectAlgo(GetDlgItem(hwndDlg, IDC_WIPE_MODE), (int *)&nWipeMode);

SetFocus(GetDlgItem(GetParent(hwndDlg), IDOK));

}

case WM_COMMAND:

if (lw == IDCANCEL)

{

if (lw == IDC_WIPE_MODE && hw == CBN_SELCHANGE)

{

return 1;

}

if (lw == IDC_PIM_ENABLE)

{

if (!PimEnable)

volumePim = 0;

return 1;

}

return 0;

}

void

{

LPARAM nIndex;

nIndex = SendMessageW(hComboBox, CB_ADDSTRING, 0, (LPARAM)lpszItem);

nIndex = SendMessage(hComboBox, CB_SETITEMDATA, nIndex, (LPARAM)value);

}

/* Acording to NIST, only a blacklist check and at least 8 character should be compulsary, no special character check... */

{

unsigned int n = length;

{

}

else if (CheckWord(input))

{

}

//Tetermine the strength of the passsord

if ((n >= 13))

{

}

//if 3 out of 4 paramters are true

else if (n >= 10)

{

}

//if 2 out of 4 values are true

else if (n >= 8)

{

}

else

{

}

}

/* Check if password is in list

Credits go Martin York from https://codereview.stackexchange.com/questions/52702/how-to-search-for-a-word-in-a-sorted-text-file-efficiently */

{

bool isWordInDict(std::string const& word);

wchar_t destFileName[TC_MAX_PATH] = L"password1000000.txt";

wchar_t *destPathName;

wcsncpy(tmp, path, wcslen(path));

//detects the last '\' in order to remove the name of the exe file. Afterwards add .txt file in the path

for (int i = wcslen(path); i > 1; i--)

{

if (tmp[i] == '\\')

{

{

tmp[j] = '\0';

}

}

}

destPathName = wcscat(tmp, destFileName);

std::ifstream fin(destPathName);

std::copy(std::istream_iterator<std::string>(fin), std::istream_iterator<std::string>(),

std::inserter(*this, end()));

}

};

MyDict::const_iterator find = dict.find(search);

return find != dict.end();

}

}

/* Credits go to Barmak Shemirani from https://stackoverflow.com/questions/31407492/c-tooltip-function-for-checkbox */

void CreateToolTip(HWND hWndParent, HWND hControlItem, PTSTR pszText)

GetClientRect(hWndParent, &toolInfo.rect);

if (!SendMessage(hwndTip, TTM_ADDTOOL, 0, (LPARAM)&toolInfo))

{

MessageBox(0, TEXT("TTM_ADDTOOL failed\nWrong project manifest!"), 0, 0);

}