BOOL WaitDialogDisplaying = FALSE;

/* Handle to the device driver */

HANDLE hDriver = INVALID_HANDLE_VALUE;

SendMessage(hwnd, EM_HIDEBALLOONTIP, 0, 0);

}

static LRESULT CALLBACK BootPwdFieldProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

{

WNDPROC wp = (WNDPROC) GetWindowLongPtrW (hwnd, GWLP_USERDATA);

switch (message)

{

case WM_PASTE:

return 1;

case WM_CHAR:

HandlePasswordEditWmChar (hwnd, wParam);

break;

}

return CallWindowProcW (wp, hwnd, message, wParam, lParam);

}

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

// input fields (only the US keyboard layout is supported in pre-boot environment so we must prevent the

WNDPROC originalwp = (WNDPROC) GetWindowLongPtrW (hwndCtrl, GWLP_USERDATA);

SendMessage (hwndCtrl, EM_LIMITTEXT, MAX_LEGACY_PASSWORD, 0);

// if ToNormalPwdField has been called before, GWLP_USERDATA already contains original WNDPROC

if (!originalwp)

SetWindowLongPtrW (hwndCtrl, GWLP_WNDPROC, (LONG_PTR) BootPwdFieldProc);

}

// Ensures that a warning is displayed when user is pasting a password longer than the maximum

// length which is set to 64 characters

static LRESULT CALLBACK NormalPwdFieldProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

/* Something went wrong ; couldn't find the requested algo id so we drop

back to a default */

*algo_id = (int) SendMessage (hComboBox, CB_GETITEMDATA, 0, 0);

SendMessage (hComboBox, CB_SETCURSEL, 0, 0);

return BrowseFilesInDir (hwndDlg, stringId, NULL, lpszFileName, keepHistory, saveMode, browseFilter);

}

BOOL BrowseFilesInDir (HWND hwndDlg, char *stringId, wchar_t *initialDir, wchar_t *lpszFileName, BOOL keepHistory, BOOL saveMode, wchar_t *browseFilter, const wchar_t *initialFileName, const wchar_t *defaultExtension)

{

return TRUE;

}

BOOL IsNonInstallMode ()

{

HKEY hkey, hkeybis;

return TRUE;

}

LRESULT SetCheckBox (HWND hwndDlg, int dlgItem, BOOL state)

{

return SendDlgItemMessage (hwndDlg, dlgItem, BM_SETCHECK, state ? BST_CHECKED : BST_UNCHECKED, 0);

{

HGLOBAL hResL;

HRSRC hRes;

#ifdef SETUP_DLL

// In case we're being called from the SetupDLL project, FindResource()

hRes = FindResource (hResInst, MAKEINTRESOURCE(resourceId), resourceType);

hResL = LoadResource (hResInst, hRes);

if (size != NULL)

*size = SizeofResource (hResInst, hRes);

return bResult;

}

#define ISO_BURNER_TOOL L"isoburn.exe"

#define PRINT_TOOL L"notepad.exe"

void InitGlobalLocks ();

void FinalizeGlobalLocks ();

void cleanup ( void );

void ResetCipherTest ( HWND hwndDlg , int idTestCipher );

void ResetCurrentDirectory ();

BOOL BrowseFiles (HWND hwndDlg, char *stringId, wchar_t *lpszFileName, BOOL keepHistory, BOOL saveMode, wchar_t *browseFilter);

BOOL BrowseDirectories (HWND hWnd, char *lpszTitle, wchar_t *dirName);

void handleError ( HWND hwndDlg , int code, const char* srcPos );

BOOL CheckFileStreamWriteErrors (HWND hwndDlg, FILE *file, const wchar_t *fileName);

<font lang="en" class="bold" size="13" face="Arial" />

<font lang="en" class="fixed" size="12" face="Lucida Console" />

<font lang="en" class="title" size="21" face="Times New Roman" />

<entry lang="en" key="IDCANCEL">Cancel</entry>

<entry lang="en" key="IDC_ALL_USERS">Install &amp;for all users</entry>

<entry lang="en" key="IDC_BROWSE">Bro&amp;wse...</entry>

<entry lang="en" key="IDC_DEVICE_TRANSFORM_MODE_INPLACE">Encrypt partition in place</entry>

<entry lang="en" key="IDC_DISPLAY_KEYS">Display generated keys (their portions)</entry>

<entry lang="en" key="IDC_DISPLAY_POOL_CONTENTS">Display pool content</entry>

<entry lang="en" key="IDC_FILE_CONTAINER">Create an encrypted file container</entry>

<entry lang="en" key="IDC_GB">&amp;GiB</entry>

<entry lang="en" key="IDC_TB">&amp;TiB</entry>

<entry lang="en" key="IDC_OPEN_OUTER_VOLUME">Open Outer Volume</entry>

<entry lang="en" key="IDC_PAUSE">&amp;Pause</entry>

<entry lang="en" key="IDC_PIM_ENABLE">Use P&amp;IM</entry>

<entry lang="en" key="IDC_QUICKFORMAT">Quick Format</entry>

<entry lang="en" key="IDC_SHOW_PASSWORD">&amp;Display password</entry>

<entry lang="en" key="IDC_SHOW_PASSWORD_SINGLE">&amp;Display password</entry>

<entry lang="en" key="IDC_SYS_DEVICE">Encrypt the system partition or entire system drive</entry>

<entry lang="en" key="IDC_SYS_PARTITION">Encrypt the Windows system partition</entry>

<entry lang="en" key="IDC_WHOLE_SYS_DRIVE">Encrypt the whole drive</entry>

<entry lang="en" key="IDT_CLUSTER">Cluster </entry>

<entry lang="en" key="IDT_COLLECTING_RANDOM_DATA_NOTE">IMPORTANT: Move your mouse as randomly as possible within this window. The longer you move it, the better. This significantly increases the cryptographic strength of the encryption keys. Then click Next to continue.</entry>

<entry lang="en" key="IDT_CONFIRM">&amp;Confirm:</entry>

<entry lang="en" key="PASSWORD_HIDVOL_HOST_TITLE">Outer Volume Password</entry>

<entry lang="en" key="PASSWORD_HIDVOL_TITLE">Hidden Volume Password</entry>

<entry lang="en" key="PASSWORD_HIDDEN_OS_TITLE">Password for Hidden Operating System</entry>

<entry lang="en" key="PASSWORD_LENGTH_WARNING">WARNING: Short passwords are easy to crack using brute force techniques!\n\nWe recommend choosing a password consisting of 20 or more characters. Are you sure you want to use a short password?</entry>

<entry lang="en" key="PASSWORD_TITLE">Volume Password</entry>

<entry lang="en" key="PASSWORD_WRONG">Operation failed due to one or more of the following:\n - Incorrect password.\n - Incorrect Volume PIM number.\n - Incorrect PRF (hash).\n - Not a valid volume.</entry>

<entry lang="en" key="ENTER_NORMAL_VOL_PASSWORD">Enter password for the normal/outer volume</entry>

<entry lang="en" key="ENTER_HIDDEN_VOL_PASSWORD">Enter password for the hidden volume</entry>

<entry lang="en" key="ENTER_HEADER_BACKUP_PASSWORD">Enter password for the header stored in backup file</entry>

<entry lang="en" key="KEYFILE_CREATED">Keyfiles have been successfully created.</entry>

<entry lang="en" key="KEYFILE_INCORRECT_NUMBER">The number of keyfiles you supplied is invalid.</entry>

<entry lang="en" key="KEYFILE_INCORRECT_SIZE">The keyfile size must be comprized between 64 and 1048576 bytes.</entry>

<entry lang="en" key="BOOT_PIM_REQUIRE_LONG_PASSWORD">Pre-boot authentication Password must contain 20 or more characters in order to use the specified PIM.\nShorter passwords can only be used if the PIM is 98 or greater.</entry>

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

<entry lang="en" key="RESCUE_DISK_BACK_BUTTON">The Rescue Disk was already created depending on the selected options. In order to prevent incompatibility, you have to click 'cancel' and restart the system encryption process, if you want to modify any configuration.</entry>

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

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

<entry lang="en" key="ALT_KEY_CHARS_NOT_FOR_SYS_ENCRYPTION">It is not possible to type characters by pressing keys while the right Alt key is held down. However, you can type most of such characters by pressing appropriate keys while the Shift key is held down.</entry>

<entry lang="en" key="WINDOWS_BOOT_LOADER_HINTS">If the currently running operating system is installed on the boot partition, then, after you encrypt it, you will need to enter the correct password even if you want to start any other unencrypted Windows system(s) (as they will share a single encrypted Windows boot loader/manager).\n\nIn contrast, if the currently running operating system is not installed on the boot partition (or if the Windows boot loader/manager is not used by any other system), then, after you encrypt this system, you will not need to enter the correct password to boot the other unencrypted system(s) -- you will only need to press the Esc key to start the unencrypted system (if there are multiple unencrypted systems, you will also need to choose which system to start in the VeraCrypt Boot Manager menu).\n\nNote: Typically, the earliest installed Windows system is installed on the boot partition.</entry>

<entry lang="en" key="SYSENC_PRE_DRIVE_ANALYSIS_TITLE">Encryption of Host Protected Area</entry>

<entry lang="en" key="SYSENC_PRE_DRIVE_ANALYSIS_HELP">At the end of many drives, there is an area that is normally hidden from the operating system (such areas are usually referred to as Host Protected Areas). However, some programs can read and write data from/to such areas.\n\nWARNING: Some computer manufacturers may use such areas to store tools and data for RAID, system recovery, system setup, diagnostic, or other purposes. If such tools or data must be accessible before booting, the hidden area should NOT be encrypted (choose 'No' above).\n\nDo you want VeraCrypt to detect and encrypt such a hidden area (if any) at the end of the system drive?</entry>

<entry lang="en" key="SYSENC_NORMAL_TYPE_HELP">Select this option if you merely want to encrypt the system partition or the entire system drive.</entry>

<entry lang="en" key="SYSENC_HIDDEN_TYPE_HELP">It may happen that you are forced by somebody to decrypt the operating system. There are many situations where you cannot refuse to do so (for example, due to extortion). If you select this option, you will create a hidden operating system whose existence should be impossible to prove (provided that certain guidelines are followed). Thus, you will not have to decrypt or reveal the password to the hidden operating system. For a detailed explanation, please click the link below.</entry>

<entry lang="en" key="HIDDEN_OS_PREINFO">It may happen that you are forced by somebody to decrypt the operating system. There are many situations where you cannot refuse to do so (for example, due to extortion).\n\nUsing this wizard, you can create a hidden operating system whose existence should be impossible to prove (provided that certain guidelines are followed). Thus, you will not have to decrypt or reveal the password for the hidden operating system.</entry>

<entry lang="en" key="SYSENC_HIDDEN_OS_REQ_CHECK_PAGE_TITLE">Hidden Operating System</entry>

<entry lang="en" key="SYSENC_HIDDEN_OS_REQ_CHECK_PAGE_HELP">In the following steps, you will create two VeraCrypt volumes (outer and hidden) within the first partition behind the system partition. The hidden volume will contain the hidden operating system (OS). VeraCrypt will create the hidden OS by copying the content of the system partition (where the currently running OS is installed) to the hidden volume. To the outer volume, you will copy some sensitive looking files that you actually do NOT want to hide. They will be there for anyone forcing you to disclose the password for the hidden OS partition. You can reveal the password for the outer volume within the hidden OS partition (the existence of the hidden OS remains secret).\n\nFinally, on the system partition of the currently running OS, you will install a new OS, so-called decoy OS, and encrypt it. It must not contain sensitive data and will be there for anyone forcing you to reveal your pre-boot authentication password. In total, there will be three passwords. Two of them can be disclosed (for the decoy OS and outer volume). If you use the third one, the hidden OS will start.</entry>

<entry lang="en" key="CD_BURNER_NOT_PRESENT_CONNECTED_NOW">A CD/DVD burner is connected to my computer now. Continue and write the Rescue Disk.</entry>

<entry lang="en" key="CD_BURNER_NOT_PRESENT_WILL_STORE_ISO_INFO">Please follow these steps:\n\n1) Connect a removable drive, such as a USB flash drive, to your computer now.\n\n2) Copy the VeraCrypt Rescue Disk image file (%s) to the removable drive.\n\nIn case you need to use the VeraCrypt Rescue Disk in the future, you will be able to connect your removable drive (containing the VeraCrypt Rescue Disk image) to a computer with a CD/DVD burner and create a bootable VeraCrypt Rescue Disk by burning the image to a CD or DVD. IMPORTANT: Note that the VeraCrypt Rescue Disk image file must be written to the CD/DVD as an ISO disk image (not as an individual file).</entry>

<entry lang="en" key="RESCUE_DISK_RECORDING_TITLE">Rescue Disk Recording</entry>

<entry lang="en" key="AES_BOX_HELP">AES is secure according to NIST</entry>

<entry lang="en" key="BACKUP_RESCUE_DISK_TITLE">Backup Rescue Disk</entry>

<entry lang="en" key="RESCUE_DISK_CREATED_TITLE">Rescue Disk Created</entry>

<entry lang="en" key="RESCUE_DISK_DISK_VERIFIED_TITLE">Rescue Disk Verified</entry>

<entry lang="en" key="RESCUE_DISK_VERIFIED_INFO">\nThe VeraCrypt Rescue Disk has been successfully verified. Please remove it from the drive now and store it in a safe place.\n\nClick Next to continue.</entry>

<entry lang="en" key="REMOVE_RESCUE_DISK_FROM_DRIVE">WARNING: During the next steps, the VeraCrypt Rescue Disk must not be in the drive. Otherwise, it will not be possible to complete the steps correctly.\n\nPlease remove it from the drive now and store it in a safe place. Then click OK.</entry>

<entry lang="en" key="SYS_ENCRYPTION_PRETEST_INFO2_PORTION_2">What to Do If Windows Cannot Start\n------------------------------------------------\n\nNote: These instructions are valid only if you have not started encrypting.\n\n- If Windows does not start after you enter the correct password (or if you repeatedly enter the correct password but VeraCrypt says that the password is incorrect), do not panic. Restart (power off and on) the computer, and in the VeraCrypt Boot Loader screen, press the Esc key on your keyboard (and if you have multiple systems, choose which to start). Then Windows should start (provided that it is not encrypted) and VeraCrypt will automatically ask whether you want to uninstall the pre-boot authentication component. Note that the previous steps do NOT work if the system partition/drive is encrypted (nobody can start Windows or access encrypted data on the drive without the correct password even if he or she follows the previous steps).\n\n</entry>

<entry lang="en" key="SYS_ENCRYPTION_PRETEST_INFO2_PORTION_3">- If the previous steps do not help or if the VeraCrypt Boot Loader screen does not appear (before Windows starts), insert the VeraCrypt Rescue Disk into your CD/DVD drive and restart your computer. If the VeraCrypt Rescue Disk screen does not appear (or if you do not see the 'Repair Options' item in the 'Keyboard Controls' section of the VeraCrypt Rescue Disk screen), it is possible that your BIOS is configured to attempt to boot from hard drives before CD/DVD drives. If that is the case, restart your computer, press F2 or Delete (as soon as you see a BIOS start-up screen), and wait until a BIOS configuration screen appears. If no BIOS configuration screen appears, restart (reset) the computer again and start pressing F2 or Delete repeatedly as soon as you restart (reset) the computer. When a BIOS configuration screen appears, configure your BIOS to boot from the CD/DVD drive first (for information on how to do so, please refer to the documentation for your BIOS/motherboard or contact your computer vendor's technical support team for assistance). Then restart your computer. The VeraCrypt Rescue Disk screen should appear now. In the VeraCrypt Rescue Disk screen, select 'Repair Options' by pressing F8 on your keyboard. From the 'Repair Options' menu, select 'Restore original system loader'. Then remove the Rescue Disk from your CD/DVD drive and restart your computer. Windows should start normally (provided that it is not encrypted).\n\n</entry>

<entry lang="en" key="SYS_ENCRYPTION_PRETEST_INFO2_PORTION_4">Note that the previous steps do NOT work if the system partition/drive is encrypted (nobody can start Windows or access encrypted data on the drive without the correct password even if he or she follows the previous steps).\n\n\nNote that even if you lose your VeraCrypt Rescue Disk and an attacker finds it, he or she will NOT be able to decrypt the system partition or drive without the correct password.</entry>

<entry lang="en" key="NONSYS_INPLACE_ENC_ENCRYPTION_PAGE_INFO">\n\nYou can click Pause or Defer anytime to interrupt the process of encryption, exit this wizard, restart or shut down your computer, and then resume the process, which will continue from the point it was stopped. Note that the volume cannot be mounted until it has been fully encrypted.</entry>

<entry lang="en" key="NONSYS_INPLACE_DEC_DECRYPTION_PAGE_INFO">\n\nYou can click Pause or Defer anytime to interrupt the process of decryption, exit this wizard, restart or shut down the computer, and then resume the process, which will continue from the point where it was stopped. Note that the volume cannot be mounted until it has been fully decrypted.</entry>

<entry lang="en" key="SYSENC_HIDDEN_OS_INITIAL_INFO_TITLE">Hidden System Started</entry>

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

<entry lang="en" key="HOST_DEVICE_REMOVAL_DISMOUNT_WARN">Before you physically remove or turn off a device containing a mounted volume, you should always dismount the volume in VeraCrypt first.\n\nUnexpected spontaneous dismount is usually caused by an intermittently failing cable, drive (enclosure), etc.</entry>

<entry lang="en" key="UNSUPPORTED_TRUECRYPT_FORMAT">This volume was created with TrueCrypt %x.%x but VeraCrypt supports only TrueCrypt volumes created with TrueCrypt 6.x/7.x series</entry>

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

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

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

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

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

<entry lang="en" key="PRE-BOOT">Pre-Boot</entry>

<entry lang="en" key="RESCUE_DISK_EFI_EXTRACT_INFO">The Rescue Disk ZIP image has been created and stored in this file:\n%s\n\nNow you need to extract it to a USB stick that is formatted as FAT/FAT32.\n\n%lsAfter you create the Rescue Disk, click Next to verify that it has been correctly created.</entry>

<entry lang="en" key="RESCUE_DISK_EFI_EXTRACT_INFO_NO_CHECK">The Rescue Disk ZIP image has been created and stored in this file:\n%s\n\nNow you should either extract the image to a USB stick that is formatted as FAT/FAT32 or move it to a safe location for later use.\n\n\n\n%lsClick Next to continue.</entry>

<entry lang="en" key="RESCUE_DISK_EFI_EXTRACT_INFO_NOTE">IMPORTANT: Note that the zip file must be extracted directly to the root of the USB stick. For example, if the drive letter of the USB stick is E: then extracting the zip file should create a folder E:\\EFI on the USB stick.\n\n</entry>

<entry lang="en" key="RESCUE_DISK_EFI_CHECK_FAILED">Cannot verify that the Rescue Disk has been correctly extracted.\n\nIf you have extracted the Rescue Disk, please eject and reinsert the USB stick; then click Next to try again. If this does not help, please try another USB stick and/or another ZIP software.\n\nIf you have not extracted the Rescue Disk yet, please do so, and then click Next.\n\nIf you attempted to verify a VeraCrypt Rescue Disk created before you started this wizard, please note that such Rescue Disk cannot be used, because it was created for a different master key. You need to extract the newly generated Rescue Disk ZIP image.</entry>

<entry lang="en" key="PASSWORD_MAXLENGTH_REACHED">Password already reached its maximum length of %d characters.\nNo additional character is allowed.</entry>

<entry lang="en" key="IDC_SELECT_LANGUAGE_LABEL">Select the language to use during the installation:</entry>

<entry lang="en" key="VOLUME_TOO_LARGE_FOR_HOST">ERROR: The size of the file container is larger than the available free space on disk.</entry>

<entry lang="en" key="CONFIRM_ALLOW_WINDOWS_DEFRAG">WARNING: Defragmenting non-system partitions/drives may leak metadata about their content or cause issues with hidden volumes they may contain.\n\nContinue?</entry>

<entry lang="en" key="VIRTUAL_DEVICE">Virtual Device</entry>

<entry lang="en" key="MOUNTED_VOLUME_NOT_ASSOCIATED">The selected mounted volume is not associated with its drive letter in Windows and so it can not be opened in Windows Explorer.</entry>

<entry lang="en" key="UNKNOWN_OPTION">Unknown option</entry>

<entry lang="en" key="VOLUME_LOCATION">Volume Location</entry>

<entry lang="en" key="VOLUME_HOST_IN_USE">WARNING: The host file/device {0} is already in use!\n\nIgnoring this can cause undesired results including system instability. All applications that might be using the host file/device should be closed before mounting the volume.\n\nContinue mounting?</entry>

<entry lang="en" key="RESCUE_DISK_CHECKLIST_C">Before you start encrypting your system, it is always a good idea to backup your personal data on an external drive for the unlikely case that the encryption process fails.</entry>

<entry lang="en" key="RESCUE_DISK_INFO_2">The VeraCrypt Rescue Disk ZIP image will be created by clicking the Next button in location specified below.</entry>

<entry lang="en" key="REMEMBER_PASSWORD"> I remember my Password</entry>

<entry lang="en" key="BACKUP_DATA"> I considered doing a backup of my personal Data</entry>

<entry lang="en" key="CHECKLIST_TITLE">Checklist - Before clicking 'Next'</entry>

<entry lang="en" key="ADVANCED_FEATURES">Advanced features</entry>

<entry lang="en" key="VERY_WEAK_PASSWORD">very weak</entry>

<entry lang="en" key="WEAK_PASSWORD">weak</entry>

<entry lang="en" key="STRONG_PASSWORD">strong</entry>

<entry lang="en" key="VERY_STRONG_PASSWORD">very strong</entry>

<entry lang="en" key="IDT_PASSWORD_STRENGTH">Password strength:</entry>

<entry lang="en" key="CHOOSE_PASSWORD_TITLE">Choose Password</entry>

</localization>

<xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema">

<xs:element name="VeraCrypt">

utf8Len1 = WideCharToMultiByte (CP_UTF8, 0, szTmp1, -1, szTmp1Utf8, MAX_PASSWORD + 1, NULL, NULL);

utf8Len2 = WideCharToMultiByte (CP_UTF8, 0, szTmp2, -1, szTmp2Utf8, MAX_PASSWORD + 1, NULL, NULL);

bEnable = FALSE;

}

else if (utf8Len1 <= 0)

bEnable = FALSE;

Error (bootPimCondition? "BOOT_PIM_REQUIRE_LONG_PASSWORD": "PIM_REQUIRE_LONG_PASSWORD", hwndDlg);

return FALSE;

}

}

#ifndef _DEBUG

else if (bCustomPimSmall)

return nStatus;

}

PUSHBUTTON "",IDC_PREV,243,234,60,14

DEFPUSHBUTTON "",IDC_NEXT,305,234,60,14

PUSHBUTTON "Cancel",IDCANCEL,382,234,60,14

GROUPBOX "",IDC_STATIC,4,0,440,230

CONTROL 116,IDC_BITMAP_WIZARD,"Static",SS_BITMAP | SS_SUNKEN,10,18,137,200

LTEXT "",IDC_POS_BOX,160,24,281,193

STYLE DS_SETFONT | DS_FIXEDSYS | DS_CONTROL | WS_CHILD

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

BEGIN

COMBOBOX IDC_COMBO_BOX,7,23,172,126,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP

PUSHBUTTON "&Test",IDC_CIPHER_TEST,191,22,81,14

PUSHBUTTON "&Benchmark",IDC_BENCHMARK,191,122,81,14

LTEXT "",IDC_BOX_HELP,7,40,266,78

GROUPBOX "Encryption Algorithm",IDT_ENCRYPTION_ALGO,0,10,273,131

GROUPBOX "Hash Algorithm",IDT_HASH_ALGO,0,156,273,35

BEGIN

EDITTEXT IDC_PASSWORD,69,3,202,14,ES_PASSWORD | ES_AUTOHSCROLL

EDITTEXT IDC_VERIFY,69,20,202,14,ES_PASSWORD | ES_AUTOHSCROLL

RTEXT "Password:", IDT_PASSWORD, 1, 6, 40, 8

RTEXT "&Confirm:", IDT_CONFIRM, 1, 23, 40, 8

CONTROL "",IDC_SYS_POOL_CONTENTS,"Static",SS_LEFTNOWORDWRAP | WS_GROUP | NOT WS_VISIBLE,33,17,209,63,WS_EX_TRANSPARENT

END

IDD_SIZE_PAGE_DLG DIALOGEX 0, 0, 276, 193

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

BEGIN

LTEXT "",IDC_BOX_HELP,0,15,267,155

END

IDD_HIDVOL_HOST_FILL_PAGE_DLG DIALOGEX 0, 0, 276, 193

STYLE DS_SETFONT | DS_FIXEDSYS | DS_CONTROL | WS_CHILD

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

BEGIN

PUSHBUTTON "Bro&wse...",IDC_BROWSE,185,159,70,14

LTEXT "",IDT_RESCUE_DISK_INFO,0,1,266,137

LTEXT "",IDT_RESCUE_DISK_INFO_2,0,135,266,20

CONTROL "Skip Rescue Disk verification",IDC_SKIP_RESCUE_VERIFICATION,

END

IDD_SYSENC_COLLECTING_RANDOM_DATA_DLG DIALOGEX 0, 0, 276, 193

LTEXT "Select this option if there are two or more operating systems installed on this computer.\n\nFor example:\n- Windows XP and Windows XP\n- Windows XP and Windows Vista\n- Windows and Mac OS X\n- Windows and Linux\n- Windows, Linux and Mac OS X",IDT_MULTI_BOOT,16,89,253,90

END

IDD_SYSENC_RESCUE_DISK_BURN_PAGE_DLG DIALOGEX 0, 0, 276, 193

STYLE DS_SETFONT | DS_FIXEDSYS | DS_CONTROL | WS_CHILD

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

BEGIN

LTEXT "",IDT_RESCUE_DISK_BURN_INFO,0,15,275,170

END

IDD_SYSENC_WIPE_MODE_PAGE_DLG DIALOGEX 0, 0, 276, 193

STYLE DS_SETFONT | DS_FIXEDSYS | DS_CONTROL | WS_CHILD

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

BEGIN

CONTROL "B", IDC_CHECKLIST_B, "Button", BS_AUTOCHECKBOX | WS_TABSTOP, 0, 60, 10, 10

LTEXT " I remember my Password", IDC_REMEMBER_PASSWORD, 11, 13, 212, 10

LTEXT " I securely stored the Rescue Disk", IDC_STORE_RESCUE_DISK, 11, 60, 217, 10

LTEXT "", IDT_REMEMBER_PASSWORD, 16, 26, 205, 32

END

IDD_INPLACE_ENCRYPTION_PAGE_DLG DIALOGEX 0, 0, 276, 193

RTEXT "Done",IDT_DONE,5,27,22,8

RTEXT "Status",IDT_STATUS,73,27,33,8

RTEXT "Left",IDT_LEFT,172,27,35,8

GROUPBOX "",IDC_STATIC,0,3,268,41

GROUPBOX "Options",IDT_FORMAT_OPTIONS,0,50,268,29

END

LTEXT "Progress:",IDT_PROGRESS,2,124,172,8

END

IDD_SYSENC_TYPE_PAGE_DLG DIALOGEX 0, 0, 276, 193

STYLE DS_SETFONT | DS_FIXEDSYS | DS_CONTROL | WS_CHILD

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

BEGIN

PUSHBUTTON "Advanced features", IDC_ADVANCE_INTRO, 190, 160, 68, 14

CONTROL "", IDC_INFORMATION_TIP, "Static", SS_ICON | SS_NOTIFY, 262,163,10,5

END

PUSHBUTTON "Cancel", IDCANCEL, 180, 213, 50, 14

PUSHBUTTON "&Help",IDHELP,15,213,50,14

END

IDD_SYSENC_HIDDEN_OS_REQ_CHECK_PAGE_DLG DIALOGEX 0, 0, 276, 193

STYLE DS_SETFONT | DS_FIXEDSYS | DS_CONTROL | WS_CHILD

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

CONTROL "Display PIM",IDC_SHOW_PIM,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,74,17,196,10

END

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

CAPTION "Advanced Algorithm Options"

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

BEGIN

END

#ifdef APSTUDIO_INVOKED

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

#endif // not APSTUDIO_INVOKED

#define IDT_SINGLE_BOOT 1079

#define IDC_SYS_POOL_CONTENTS 1080

#define IDT_PARTIAL_POOL_CONTENTS 1081

#define IDT_RESCUE_DISK_BURN_INFO 1083

#define IDT_WIPE_MODE_INFO 1084

#define IDC_WIPE_MODE 1085

#define IDC_SHOW_PIM 1106

#define IDC_TB 1107

#define IDC_SKIP_RESCUE_VERIFICATION 1108

// Next default values for new objects

#ifdef APSTUDIO_INVOKED

#ifndef APSTUDIO_READONLY_SYMBOLS

#define _APS_NO_MFC 1

#define _APS_NEXT_RESOURCE_VALUE 134

#define _APS_NEXT_COMMAND_VALUE 40001

#define _APS_NEXT_SYMED_VALUE 101

#endif

#endif

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

}

static void localcleanup ( void );

static void LoadSettings ( HWND hwndDlg );

static void EndMainDlg ( HWND hwndDlg );

void ComboSelChangeEA ( HWND hwndDlg );

static void VerifySizeAndUpdate ( HWND hwndDlg , BOOL bUpdate );

__int64 PrintFreeSpace ( HWND hwndTextBox , wchar_t *lpszDrive , PLARGE_INTEGER lDiskFree );

void DisplaySizingErrorText ( HWND hwndTextBox );

void EnableDisableFileNext ( HWND hComboBox , HWND hMainButton );

static BOOL FinalPreTransformPrompts (void);

void UpdateLastDialogId (void);

void HandleOldAssignedDriveLetter (void);

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

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

void AddComboPairW (HWND hComboBox, const wchar_t *lpszItem, int value);

#ifdef __cplusplus

}

#endif