+// IOCTL interface to \\device\veracrypt

+

+// Gets version of driver

+// OUT struct - LONG

+

+// Gets boot loader version

+// OUT struct - int16

+

+// Mount volume to \\Device\VeraCryptVolume"X"

+// IN OUT - MOUNT_STRUCT

+

+// Dismount volume

+// IN OUT - UNMOUNT_STRUCT

+

+// Dismount all volumes

+// IN OUT - UNMOUNT_STRUCT

+

+// Get list of all mounted volumes

+// IN OUT - MOUNT_LIST_STRUCT (only 26 volumes possible)

+

+// Get properties of the volume selected by driveNo

+// In OUT - VOLUME_PROPERTIES_STRUCT

+

+// Get reference count to main device object

+// OUT - int

+

+// Is it possible to unload driver

+// It check file system cache of mounted drives via unmount IOCTL.

+// OUT - int

+

+// Is there any mounted device

+// OUT - int

+

+// Check password cache

+// Result in IOCTL result TRUE if there is chached passwords

+

+// Clean password cache

+

+// Check file/drive container

+// IN OUT - OPEN_TEST_STRUCT

+

+// result of IOCTL_DISK_GET_PARTITION_INFO

+// IN OUT - DISK_PARTITION_INFO_STRUCT

+// TODO: need IOCTL_DISK_GET_PARTITION_INFO_EX to support GPT

+

+// result IOCTL_DISK_GET_DRIVE_GEOMETRY

+// IN OUT - DISK_GEOMETRY_STRUCT

+

+// result IOCTL_DISK_GET_LENGTH_INFO

+// IN OUT - ProbeRealDriveSizeRequest

+

+// result of ZwQuerySymbolicLinkObject

+// IN OUT RESOLVE_SYMLINK_STRUCT

+

+ CRYPTOPP_ALIGN_DATA(16) byte WipeKey[MASTER_KEYDATA_SIZE];

+ Modifications and additions to the original source code (contained in this file)

+DWORD BaseCom::GetFileSize (BSTR filePath, unsigned __int64 *pSize)

+{

+ if (!pSize)

+ return ERROR_INVALID_PARAMETER;

+

+ try

+ {

+ std::wstring path (filePath);

+ File file(filePath, true);

+ file.CheckOpened (SRC_POS);

+ file.GetFileSize (*pSize);

+ }

+ catch (SystemException &)

+ {

+ return GetLastError();

+ }

+ catch (Exception &e)

+ {

+ e.Show (NULL);

+ return ERROR_EXCEPTION_IN_SERVICE;

+ }

+ catch (...)

+ {

+ return ERROR_EXCEPTION_IN_SERVICE;

+ }

+

+ return ERROR_SUCCESS;

+}

+

+DWORD BaseCom::DeviceIoControl (BOOL readOnly, BOOL device, BSTR filePath, DWORD dwIoControlCode, BSTR input, BSTR *output)

+{

+ try

+ {

+ auto_ptr <File> file (device ? new Device (filePath, readOnly == TRUE) : new File (filePath, readOnly == TRUE));

+ file->CheckOpened (SRC_POS);

+ if (!file->IoCtl (dwIoControlCode, (BYTE *) input, !(BYTE *) input ? 0 : ((DWORD *) ((BYTE *) input))[-1],

+ (BYTE *) *output, !(BYTE *) *output ? 0 : ((DWORD *) ((BYTE *) *output))[-1]))

+ {

+ return GetLastError();

+ }

+ }

+ catch (SystemException &)

+ {

+ return GetLastError();

+ }

+ catch (Exception &e)

+ {

+ e.Show (NULL);

+ return ERROR_EXCEPTION_IN_SERVICE;

+ }

+ catch (...)

+ {

+ return ERROR_EXCEPTION_IN_SERVICE;

+ }

+

+ return ERROR_SUCCESS;

+}

+DWORD BaseCom::InstallEfiBootLoader (BOOL preserveUserConfig, BOOL hiddenOSCreation, int pim, int hashAlg)

+{

+ try

+ {

+ BootEncryption bootEnc (NULL);

+ bootEnc.InstallBootLoader (preserveUserConfig? true : false, hiddenOSCreation? true : false, pim, hashAlg);

+ }

+ catch (SystemException &)

+ {

+ return GetLastError();

+ }

+ catch (Exception &e)

+ {

+ e.Show (NULL);

+ return ERROR_EXCEPTION_IN_SERVICE;

+ }

+ catch (...)

+ {

+ return ERROR_EXCEPTION_IN_SERVICE;

+ }

+

+ return ERROR_SUCCESS;

+}

+

+DWORD BaseCom::BackupEfiSystemLoader ()

+{

+ try

+ {

+ BootEncryption bootEnc (NULL);

+ bootEnc.BackupSystemLoader ();

+ }

+ catch (SystemException &)

+ {

+ return GetLastError();

+ }

+ catch (Exception &e)

+ {

+ e.Show (NULL);

+ return ERROR_EXCEPTION_IN_SERVICE;

+ }

+ catch (...)

+ {

+ return ERROR_EXCEPTION_IN_SERVICE;

+ }

+

+ return ERROR_SUCCESS;

+}

+

+DWORD BaseCom::RestoreEfiSystemLoader ()

+{

+ try

+ {

+ BootEncryption bootEnc (NULL);

+ bootEnc.RestoreSystemLoader ();

+ }

+ catch (SystemException &)

+ {

+ return GetLastError();

+ }

+ catch (Exception &e)

+ {

+ e.Show (NULL);

+ return ERROR_EXCEPTION_IN_SERVICE;

+ }

+ catch (...)

+ {

+ return ERROR_EXCEPTION_IN_SERVICE;

+ }

+

+ return ERROR_SUCCESS;

+}

+

+DWORD BaseCom::GetEfiBootDeviceNumber (BSTR* pSdn)

+{

+ if (!pSdn || !(*pSdn) || ((((DWORD *) ((BYTE *) *pSdn))[-1]) < sizeof (STORAGE_DEVICE_NUMBER)))

+ return ERROR_INVALID_PARAMETER;

+

+ try

+ {

+ BootEncryption bootEnc (NULL);

+ bootEnc.GetEfiBootDeviceNumber ((PSTORAGE_DEVICE_NUMBER) *pSdn);

+ }

+ catch (SystemException &)

+ {

+ return GetLastError();

+ }

+ catch (Exception &e)

+ {

+ e.Show (NULL);

+ return ERROR_EXCEPTION_IN_SERVICE;

+ }

+ catch (...)

+ {

+ return ERROR_EXCEPTION_IN_SERVICE;

+ }

+

+ return ERROR_SUCCESS;

+}

+

+DWORD BaseCom::ReadEfiConfig (BSTR* pContent, DWORD *pcbRead)

+{

+ if (!pContent || !(*pContent))

+ return ERROR_INVALID_PARAMETER;

+

+ try

+ {

+ DWORD maxSize = ((DWORD *) ((BYTE *) *pContent))[-1];

+ BootEncryption bootEnc (NULL);

+ bootEnc.ReadEfiConfig ((byte*) *pContent, maxSize, pcbRead);

+ }

+ catch (SystemException &)

+ {

+ return GetLastError();

+ }

+ catch (Exception &e)

+ {

+ e.Show (NULL);

+ return ERROR_EXCEPTION_IN_SERVICE;

+ }

+ catch (...)

+ {

+ return ERROR_EXCEPTION_IN_SERVICE;

+ }

+

+ return ERROR_SUCCESS;

+}

+

+DWORD BaseCom::WriteEfiBootSectorUserConfig (DWORD userConfig, BSTR customUserMessage, int pim, int hashAlg)

+{

+ if (!customUserMessage)

+ return ERROR_INVALID_PARAMETER;

+

+ try

+ {

+ DWORD maxSize = ((DWORD *) ((BYTE *) customUserMessage))[-1];

+ char* msg = (char*) *customUserMessage;

+ if (maxSize > 0)

+ msg [maxSize - 1] = 0;

+ std::string msgStr = maxSize > 0 ? msg : "";

+ BootEncryption bootEnc (NULL);

+ bootEnc.WriteEfiBootSectorUserConfig ((byte) userConfig, msgStr, pim, hashAlg);

+ }

+ catch (SystemException &)

+ {

+ return GetLastError();

+ }

+ catch (Exception &e)

+ {

+ e.Show (NULL);

+ return ERROR_EXCEPTION_IN_SERVICE;

+ }

+ catch (...)

+ {

+ return ERROR_EXCEPTION_IN_SERVICE;

+ }

+

+ return ERROR_SUCCESS;

+} \ No newline at end of file

+ Modifications and additions to the original source code (contained in this file)

+ TrueCryptFactory (DWORD messageThreadId) :

+

+

+ static DWORD GetFileSize (BSTR filePath, unsigned __int64 *pSize);

+ static DWORD DeviceIoControl (BOOL readOnly, BOOL device, BSTR filePath, DWORD dwIoControlCode, BSTR input, BSTR *output);

+ static DWORD InstallEfiBootLoader (BOOL preserveUserConfig, BOOL hiddenOSCreation, int pim, int hashAlg);

+ static DWORD BackupEfiSystemLoader ();

+ static DWORD RestoreEfiSystemLoader ();

+ static DWORD GetEfiBootDeviceNumber (BSTR* pSdn);

+ static DWORD ReadEfiConfig (BSTR* pContent, DWORD *pcbRead);

+ static DWORD WriteEfiBootSectorUserConfig (DWORD userConfig, BSTR customUserMessage, int pim, int hashAlg);

+#include "Xml.h"

+#include "XZip.h"

+#include "XUnzip.h"

+

+ static void GetFileSize (const wstring &filePath, unsigned __int64* pSize)

+ {

+ Elevate();

+

+ DWORD result;

+ CComBSTR fileBstr;

+ BSTR bstr = W2BSTR(filePath.c_str());

+ if (bstr)

+ {

+ fileBstr.Attach (bstr);

+ result = ElevatedComInstance->GetFileSize (fileBstr, pSize);

+ }

+ else

+ {

+ result = ERROR_OUTOFMEMORY;

+ }

+

+ if (result != ERROR_SUCCESS)

+ {

+ SetLastError (result);

+ throw SystemException(SRC_POS);

+ }

+ }

+

+ static BOOL DeviceIoControl (BOOL readOnly, BOOL device, const wstring &filePath, DWORD dwIoControlCode, LPVOID input, DWORD inputSize,

+ LPVOID output, DWORD outputSize)

+ {

+ Elevate();

+

+ DWORD result;

+

+ BSTR bstr = W2BSTR(filePath.c_str());

+ if (bstr)

+ {

+ CComBSTR inputBstr;

+ if (input && inputBstr.AppendBytes ((const char *) input, inputSize) != S_OK)

+ {

+ SetLastError (ERROR_INVALID_PARAMETER);

+ return FALSE;

+ }

+

+ CComBSTR outputBstr;

+ if (output && outputBstr.AppendBytes ((const char *) output, outputSize) != S_OK)

+ {

+ SetLastError (ERROR_INVALID_PARAMETER);

+ return FALSE;

+ }

+

+ CComBSTR fileBstr;

+ fileBstr.Attach (bstr);

+ result = ElevatedComInstance->DeviceIoControl (readOnly, device, fileBstr, dwIoControlCode, inputBstr, &outputBstr);

+

+ if (output)

+ memcpy (output, *(void **) &outputBstr, outputSize);

+ }

+ else

+ {

+ result = ERROR_OUTOFMEMORY;

+ }

+

+ if (result != ERROR_SUCCESS)

+ {

+ SetLastError (result);

+ return FALSE;

+ }

+ else

+ return TRUE;

+ }

+

+ static void InstallEfiBootLoader (bool preserveUserConfig, bool hiddenOSCreation, int pim, int hashAlg)

+ {

+ Elevate();

+

+ DWORD result = ElevatedComInstance->InstallEfiBootLoader (preserveUserConfig ? TRUE : FALSE, hiddenOSCreation ? TRUE : FALSE, pim, hashAlg);

+ if (result != ERROR_SUCCESS)

+ {

+ SetLastError (result);

+ throw SystemException(SRC_POS);

+ }

+ }

+

+ static void BackupEfiSystemLoader ()

+ {

+ Elevate();

+

+ DWORD result = ElevatedComInstance->BackupEfiSystemLoader ();

+ if (result != ERROR_SUCCESS)

+ {

+ SetLastError (result);

+ throw SystemException(SRC_POS);

+ }

+ }

+

+ static void RestoreEfiSystemLoader ()

+ {

+ Elevate();

+

+ DWORD result = ElevatedComInstance->RestoreEfiSystemLoader ();

+ if (result != ERROR_SUCCESS)

+ {

+ SetLastError (result);

+ throw SystemException(SRC_POS);

+ }

+ }

+

+ static void GetEfiBootDeviceNumber (PSTORAGE_DEVICE_NUMBER pSdn)

+ {

+ Elevate();

+

+ CComBSTR outputBstr;

+ if (pSdn && outputBstr.AppendBytes ((const char *) pSdn, sizeof (STORAGE_DEVICE_NUMBER)) != S_OK)

+ {

+ SetLastError (ERROR_INVALID_PARAMETER);

+ throw SystemException(SRC_POS);

+ }

+

+ DWORD result = ElevatedComInstance->GetEfiBootDeviceNumber (&outputBstr);

+

+ if (pSdn)

+ memcpy (pSdn, *(void **) &outputBstr, sizeof (STORAGE_DEVICE_NUMBER));

+

+ if (result != ERROR_SUCCESS)

+ {

+ SetLastError (result);

+ throw SystemException(SRC_POS);

+ }

+ }

+

+ static void ReadEfiConfig (byte* confContent, DWORD maxSize, DWORD* pcbRead)

+ {

+ Elevate();

+

+ CComBSTR outputBstr;

+ if (confContent && outputBstr.AppendBytes ((const char *) confContent, maxSize) != S_OK)

+ {

+ SetLastError (ERROR_INVALID_PARAMETER);

+ throw SystemException(SRC_POS);

+ }

+

+ DWORD result = ElevatedComInstance->ReadEfiConfig (&outputBstr, pcbRead);

+

+ if (confContent)

+ memcpy (confContent, *(void **) &outputBstr, maxSize);

+

+ if (result != ERROR_SUCCESS)

+ {

+ SetLastError (result);

+ throw SystemException(SRC_POS);

+ }

+ }

+

+ static void WriteEfiBootSectorUserConfig (byte userConfig, const string &customUserMessage, int pim, int hashAlg)

+ {

+ Elevate();

+

+ DWORD result;

+ CComBSTR customUserMessageBstr;

+ BSTR bstr = A2BSTR(customUserMessage.c_str());

+ if (bstr)

+ {

+ customUserMessageBstr.Attach (bstr);

+ result = ElevatedComInstance->WriteEfiBootSectorUserConfig ((DWORD) userConfig, customUserMessageBstr, pim, hashAlg);

+ }

+ else

+ {

+ result = ERROR_OUTOFMEMORY;

+ }

+

+ if (result != ERROR_SUCCESS)

+ {

+ SetLastError (result);

+ throw SystemException(SRC_POS);

+ }

+ }

+

+ static void GetFileSize (const wstring &filePath, unsigned __int64 *pSize) { throw ParameterIncorrect (SRC_POS); }

+ static BOOL DeviceIoControl (BOOL readOnly, BOOL device, const wstring &filePath, DWORD dwIoControlCode, LPVOID input, DWORD inputSize, LPVOID output, DWORD outputSize) { throw ParameterIncorrect (SRC_POS); }

+ static void InstallEfiBootLoader (bool preserveUserConfig, bool hiddenOSCreation, int pim, int hashAlg) { throw ParameterIncorrect (SRC_POS); }

+ static void BackupEfiSystemLoader () { throw ParameterIncorrect (SRC_POS); }

+ static void RestoreEfiSystemLoader () { throw ParameterIncorrect (SRC_POS); }

+ static void GetEfiBootDeviceNumber (PSTORAGE_DEVICE_NUMBER pSdn) { throw ParameterIncorrect (SRC_POS); }

+ static void ReadEfiConfig (byte* confContent, DWORD maxSize, DWORD* pcbRead) { throw ParameterIncorrect (SRC_POS); }

+ static void WriteEfiBootSectorUserConfig (byte userConfig, const string &customUserMessage, int pim, int hashAlg) { throw ParameterIncorrect (SRC_POS); }

+ File::File (wstring path, bool readOnly, bool create) : Elevated (false), FileOpen (false), ReadOnly (readOnly), LastError(0)

+ void File::GetFileSize (unsigned __int64& size)

+ {

+ if (!FileOpen)

+ {

+ SetLastError (LastError);

+ throw SystemException (SRC_POS);

+ }

+

+ if (Elevated)

+ {

+ Elevator::GetFileSize (Path, &size);

+ }

+ else

+ {

+ LARGE_INTEGER lSize;

+ lSize.QuadPart = 0;

+ throw_sys_if (!GetFileSizeEx (Handle, &lSize));

+ size = (unsigned __int64) lSize.QuadPart;

+ }

+ }

+

+ void File::GetFileSize (DWORD& dwSize)

+ {

+ unsigned __int64 size64;

+ GetFileSize (size64);

+ dwSize = (DWORD) size64;

+ }

+

+ bool File::IoCtl(DWORD code, void* inBuf, DWORD inBufSize, void* outBuf, DWORD outBufSize)

+ {

+ if (!FileOpen)

+ {

+ SetLastError (LastError);

+ throw SystemException (SRC_POS);

+ }

+

+ if (Elevated)

+ {

+ return TRUE == Elevator::DeviceIoControl (ReadOnly, IsDevice, Path, code, inBuf, inBufSize, outBuf, outBufSize);

+ }

+ else

+ {

+ DWORD bytesReturned = 0;

+ return TRUE == DeviceIoControl(Handle, code, inBuf, inBufSize, outBuf, outBufSize, &bytesReturned, NULL);

+ }

+ }

+

+ ReadOnly = readOnly;

+ static EfiBoot EfiBootInst;

+ RescueZipData (nullptr),

+ RescueZipSize (0),

+ {

+ burn (RescueIsoImage, RescueIsoImageSize);

+ }

+ if (RescueZipData)

+ {

+ burn (RescueZipData, RescueZipSize);

+ delete [] RescueZipData;

+ }

+ if (!config.SystemPartition.IsGPT)

+// throw ParameterIncorrect (SRC_POS); // It is assumed that CheckRequirements() had been called

+

+ // Find the first active partition on the system drive

+ foreach (const Partition &partition, config.Partitions)

+ if (partition.Info.BootIndicator)

+ if (partition.Info.PartitionNumber != config.SystemPartition.Number)

+ // If there is an extra boot partition, the system partition must be located right behind it

+ if (IsOSAtLeast (WIN_7) && config.ExtraBootPartitionPresent)

+ int64 minOffsetFound = config.DrivePartition.Info.PartitionLength.QuadPart;

+ Partition bootPartition = partition;

+ Partition partitionBehindBoot;

+

+ foreach (const Partition &partition, config.Partitions)

+ if (partition.Info.StartingOffset.QuadPart > bootPartition.Info.StartingOffset.QuadPart

+ && partition.Info.StartingOffset.QuadPart < minOffsetFound)

+ {

+ minOffsetFound = partition.Info.StartingOffset.QuadPart;

+ partitionBehindBoot = partition;

+ }

+ if (minOffsetFound != config.DrivePartition.Info.PartitionLength.QuadPart

+ && partitionBehindBoot.Number == config.SystemPartition.Number)

+ {

+ activePartitionFound = true;

+ break;

+ }

+

+ throw ErrorException (wstring (GetString ("SYSTEM_PARTITION_NOT_ACTIVE"))

+ + GetRemarksOnHiddenOS(), SRC_POS);

+ activePartitionFound = true;

+ break;

+ } else {

+ // For GPT

+ activePartitionFound = true;

+ BOOL bIsGPT = GetSystemDriveConfiguration().SystemPartition.IsGPT;

+ else if (_stricmp (request.BootEncryptionAlgorithmName, "Camellia") == 0)

+ ea = CAMELLIA;

+#if defined(CIPHER_GOST89)

+ else if (_stricmp (request.BootEncryptionAlgorithmName, "GOST89") == 0)

+ ea = GOST89;

+#endif

+ else if (_stricmp(request.BootPrfAlgorithmName, "SHA-512") == 0)

+ pkcs5_prf = SHA512;

+ else if (_stricmp(request.BootPrfAlgorithmName, "Whirlpool") == 0)

+ pkcs5_prf = WHIRLPOOL;

+ else if (_stricmp(request.BootPrfAlgorithmName, "Streebog") == 0)

+ pkcs5_prf = STREEBOG;

+

+ if (pkcs5_prf == 0)

+ throw ParameterIncorrect (SRC_POS);

+ // Only RIPEMD160 and SHA-256 are supported for MBR boot loader

+ if (!bIsGPT && pkcs5_prf != RIPEMD160 && pkcs5_prf != SHA256)

+

+ case CAMELLIA:

+ if (pkcs5_prf == SHA256)

+ {

+ bootSectorId = rescueDisk ? IDR_RESCUE_BOOT_SECTOR_CAMELLIA_SHA2 : IDR_BOOT_SECTOR_CAMELLIA_SHA2;

+ bootLoaderId = rescueDisk ? IDR_RESCUE_LOADER_CAMELLIA_SHA2 : IDR_BOOT_LOADER_CAMELLIA_SHA2;

+ }

+ else

+ {

+ bootSectorId = rescueDisk ? IDR_RESCUE_BOOT_SECTOR_CAMELLIA : IDR_BOOT_SECTOR_CAMELLIA;

+ bootLoaderId = rescueDisk ? IDR_RESCUE_LOADER_CAMELLIA : IDR_BOOT_LOADER_CAMELLIA;

+ }

+ break;

+ void BootEncryption::ReadEfiConfig (byte* confContent, DWORD maxSize, DWORD* pcbRead)

+ if (!pcbRead)

+ if (!IsAdmin() && IsUacSupported())

+ {

+ Elevator::ReadEfiConfig (confContent, maxSize, pcbRead);

+ }

+ else

+ {

+ unsigned __int64 ui64Size = 0;

+

+ finally_do ({ EfiBootInst.DismountBootPartition(); });

+ EfiBootInst.MountBootPartition(0);

+

+ EfiBootInst.GetFileSize(L"\\EFI\\VeraCrypt\\DcsProp", ui64Size);

+

+ *pcbRead = (DWORD) ui64Size;

+

+ if (*pcbRead > maxSize)

+ throw ParameterIncorrect (SRC_POS);

+ EfiBootInst.ReadFile (L"\\EFI\\VeraCrypt\\DcsProp", confContent, *pcbRead);

+ }

+ }

+

+ // return false when the user cancel an elevation request

+ bool BootEncryption::ReadBootSectorConfig (byte *config, size_t bufLength, byte *userConfig, string *customUserMessage, uint16 *bootLoaderVersion)

+ {

+ bool bCanceled = false, bExceptionOccured = false;

+ if (GetSystemDriveConfiguration().SystemPartition.IsGPT)

+ {

+ byte confContent[4096];

+ DWORD dwSize;

+ // for now, we don't support any boot config flags, like hidden OS one

+ if (config)

+ memset (config, 0, bufLength);

+ // call ReadEfiConfig only when needed since it requires elevation

+ if (userConfig || customUserMessage || bootLoaderVersion)

+ {

+ ReadEfiConfig (confContent, sizeof (confContent) - 1, &dwSize);

+

+ confContent[dwSize] = 0;

+

+ EfiBootConf conf;

+ conf.Load ((char*) confContent);

+

+ if (userConfig)

+ {

+ *userConfig = 0;

+ if (!conf.requestPim)

+ *userConfig |= TC_BOOT_USER_CFG_FLAG_DISABLE_PIM;

+ if (!conf.requestHash)

+ *userConfig |= TC_BOOT_USER_CFG_FLAG_STORE_HASH;

+

+ }

+

+ if (customUserMessage)

+ customUserMessage->clear();

+

+ if (bootLoaderVersion)

+ {

+ *bootLoaderVersion = GetStatus().BootLoaderVersion;

+ }

+ }

+ else

+ {

+ if (config && bufLength < TC_BOOT_CFG_FLAG_AREA_SIZE)

+ throw ParameterIncorrect (SRC_POS);

+ GetSystemDriveConfigurationRequest request;

+ StringCchCopyW (request.DevicePath, ARRAYSIZE (request.DevicePath), GetSystemDriveConfiguration().DeviceKernelPath.c_str());

+

+ CallDriver (TC_IOCTL_GET_SYSTEM_DRIVE_CONFIG, &request, sizeof (request), &request, sizeof (request));

+ if (config)

+ *config = request.Configuration;

+

+ if (userConfig)

+ *userConfig = request.UserConfiguration;

+

+ if (customUserMessage)

+ {

+ request.CustomUserMessage[TC_BOOT_SECTOR_USER_MESSAGE_MAX_LENGTH] = 0;

+ *customUserMessage = request.CustomUserMessage;

+ }

+

+ if (bootLoaderVersion)

+ *bootLoaderVersion = request.BootLoaderVersion;

+ }

+ }

+ catch (UserAbort&)

+ {

+ bCanceled = true;

+ bExceptionOccured= true;

+ bExceptionOccured = true;

+ }

+

+ if (bExceptionOccured)

+ {

+

+

+ return !bCanceled;

+ void BootEncryption::WriteEfiBootSectorUserConfig (byte userConfig, const string &customUserMessage, int pim, int hashAlg)

+ if (!IsAdmin() && IsUacSupported())

+ Elevator::WriteEfiBootSectorUserConfig (userConfig, customUserMessage, pim, hashAlg);

+ else

+ finally_do ({ EfiBootInst.DismountBootPartition(); });

+ EfiBootInst.MountBootPartition(0);

+ if (! (userConfig & TC_BOOT_USER_CFG_FLAG_DISABLE_PIM))

+ pim = -1;

+ if (! (userConfig & TC_BOOT_USER_CFG_FLAG_STORE_HASH))

+ hashAlg = -1;

+

+ EfiBootInst.UpdateConfig (L"\\EFI\\VeraCrypt\\DcsProp", pim, hashAlg, ParentWindow);

+ }

+ void BootEncryption::WriteBootSectorUserConfig (byte userConfig, const string &customUserMessage, int pim, int hashAlg)

+ {

+ if (GetSystemDriveConfiguration().SystemPartition.IsGPT)

+ WriteEfiBootSectorUserConfig (userConfig, customUserMessage, pim, hashAlg);

+ {

+ Device device (GetSystemDriveConfiguration().DevicePath);

+ device.CheckOpened (SRC_POS);

+ byte mbr[TC_SECTOR_SIZE_BIOS];

+ device.SeekAt (0);

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

+ if (!BufferContainsString (mbr, sizeof (mbr), TC_APP_NAME)

+ || BE16 (*(uint16 *) (mbr + TC_BOOT_SECTOR_VERSION_OFFSET)) != VERSION_NUM)

+ {

+ return;

+ }

+ mbr[TC_BOOT_SECTOR_USER_CONFIG_OFFSET] = userConfig;

+

+ memset (mbr + TC_BOOT_SECTOR_USER_MESSAGE_OFFSET, 0, TC_BOOT_SECTOR_USER_MESSAGE_MAX_LENGTH);

+

+ if (!customUserMessage.empty())

+ {

+ if (customUserMessage.size() > TC_BOOT_SECTOR_USER_MESSAGE_MAX_LENGTH)

+ throw ParameterIncorrect (SRC_POS);

+

+ memcpy (mbr + TC_BOOT_SECTOR_USER_MESSAGE_OFFSET, customUserMessage.c_str(), customUserMessage.size());

+ }

+

+ if (userConfig & TC_BOOT_USER_CFG_FLAG_DISABLE_PIM)

+ {

+ // PIM for pre-boot authentication can be encoded on two bytes since its maximum

+ // value is 65535 (0xFFFF)

+ memcpy (mbr + TC_BOOT_SECTOR_PIM_VALUE_OFFSET, &pim, TC_BOOT_SECTOR_PIM_VALUE_SIZE);

+ }

+ else

+ memset (mbr + TC_BOOT_SECTOR_PIM_VALUE_OFFSET, 0, TC_BOOT_SECTOR_PIM_VALUE_SIZE);

+

+ device.SeekAt (0);

+ device.Write (mbr, sizeof (mbr));

+

+ byte mbrVerificationBuf[TC_SECTOR_SIZE_BIOS];

+ device.SeekAt (0);

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

+

+ if (memcmp (mbr, mbrVerificationBuf, sizeof (mbr)) != 0)

+ throw ErrorException ("ERROR_MBR_PROTECTED", SRC_POS);

+ }

+

+

+

+ NtQuerySystemInformationFn NtQuerySystemInformationPtr = NULL;

+

+ EfiBootConf::EfiBootConf() : passwordType (0),

+ passwordMsg ("Enter Password: "),

+ passwordPicture ("login.bmp"),

+ hashMsg ("(0) TEST ALL (1) SHA512 (2) WHIRLPOOL (3) SHA256 (4) RIPEMD160 (5) STREEBOG\nHash: "),

+ hashAlgo (0),

+ requestHash (0),

+ pimMsg ("PIM (Leave empty for default): "),

+ pim (0),

+ requestPim (1),

+ authorizeVisible (0),

+ authorizeRetry (10)

+ {

+

+ }

+

+ BOOL EfiBootConf::ReadConfigValue (char* configContent, const char *configKey, char *configValue, int maxValueSize)

+ {

+ char *xml;

+

+ xml = configContent;

+ if (xml != NULL)

+ {

+ xml = XmlFindElementByAttributeValue (xml, "config", "key", configKey);

+ if (xml != NULL)

+ {

+ XmlGetNodeText (xml, configValue, maxValueSize);

+ return TRUE;

+ }

+ }

+

+ return FALSE;

+ }

+

+

+ int EfiBootConf::ReadConfigInteger (char* configContent, const char *configKey, int defaultValue)

+ {

+ char s[32];

+ int iRet;

+ if (ReadConfigValue (configContent, configKey, s, sizeof (s)))

+ iRet = atoi (s);

+ else

+ iRet = defaultValue;

+ burn (s, sizeof (s));

+ return iRet;

+ }

+

+

+ char* EfiBootConf::ReadConfigString (char* configContent, const char *configKey, char *defaultValue, char *str, int maxLen)

+ {

+ if (ReadConfigValue (configContent, configKey, str, maxLen))

+ return str;

+ else

+ {

+ StringCbCopyA (str, maxLen, defaultValue);

+ return defaultValue;

+ }

+ }

+

+ BOOL EfiBootConf::WriteConfigString (FILE* configFile, char* configContent, const char *configKey, const char *configValue)

+ {

+

+ BOOL bRet = FALSE;

+ if (configFile)

+ {

+ char *c;

+ // Mark previous config value as updated

+ if (configContent != NULL)

+ {

+ c = XmlFindElementByAttributeValue (configContent, "config", "key", configKey);

+ if (c != NULL)

+ c[1] = '!';

+ }

+

+ if ( 0 != fwprintf (

+ configFile, L"\n\t\t<config key=\"%hs\">%hs</config>",

+ configKey, configValue))

+ {

+ bRet = TRUE;

+ }

+ }

+ return bRet;

+ }

+

+ BOOL EfiBootConf::WriteConfigInteger (FILE* configFile, char* configContent, const char *configKey, int configValue)

+ {

+ BOOL bRet = FALSE;

+ if (configFile)

+ {

+ char val[32];

+ StringCbPrintfA (val, sizeof(val), "%d", configValue);

+ bRet = WriteConfigString (configFile, configContent, configKey, val);

+ burn (val, sizeof (val));

+ }

+ return bRet;

+ }

+

+ BOOL EfiBootConf::Load (const wchar_t* fileName)

+ {

+ DWORD size = 0;

+ char* configContent = LoadFile (fileName, &size);

+ if (configContent)

+ {

+ Load (configContent);

+ burn (configContent, size);

+ free (configContent);

+ return TRUE;

+ }

+ else

+ return FALSE;

+ }

+

+ void EfiBootConf::Load (char* configContent)

+ {

+ char buffer[1024];

+

+ passwordType = ReadConfigInteger (configContent, "PasswordType", 0);

+ passwordMsg = ReadConfigString (configContent, "PasswordMsg", "Enter password: ", buffer, sizeof (buffer));

+ passwordPicture = ReadConfigString (configContent, "PasswordPicture", "\\EFI\\VeraCrypt\\login.bmp", buffer, sizeof (buffer));

+ //hashMsg = ReadConfigString (configContent, "HashMsg", "(0) TEST ALL (1) SHA512 (2) WHIRLPOOL (3) SHA256 (4) RIPEMD160 (5) STREEBOG\nHash: ", buffer, sizeof (buffer));

+ hashAlgo = ReadConfigInteger (configContent, "Hash", 0);

+ requestHash = ReadConfigInteger (configContent, "HashRqt", 1);

+ pimMsg = ReadConfigString (configContent, "PimMsg", "PIM: ", buffer, sizeof (buffer));

+ pim = ReadConfigInteger (configContent, "Pim", 0);

+ requestPim = ReadConfigInteger (configContent, "PimRqt", 1);

+ authorizeVisible = ReadConfigInteger (configContent, "AuthorizeVisible", 0);

+ authorizeRetry = ReadConfigInteger (configContent, "AuthorizeRetry", 0);

+

+ burn (buffer, sizeof (buffer));

+ }

+

+ BOOL EfiBootConf::Save (const wchar_t* fileName, HWND hwnd)

+ {

+ FILE *configFile = _wfopen (fileName, L"w,ccs=UTF-8");

+ if (configFile == NULL)

+ return FALSE;

+

+ BOOL bRet = FALSE;

+ DWORD size = 0;

+ char* configContent = LoadFile (fileName, &size);

+

+

+ XmlWriteHeader (configFile);

+ fputws (L"\n\t<configuration>", configFile);

+

+ WriteConfigInteger (configFile, configContent, "PasswordType", passwordType);

+ WriteConfigString (configFile, configContent, "PasswordMsg", passwordMsg.c_str());

+ WriteConfigString (configFile, configContent, "PasswordPicture", passwordPicture.c_str());

+ WriteConfigString (configFile, configContent, "HashMsg", hashMsg.c_str());

+ WriteConfigInteger (configFile, configContent, "Hash", hashAlgo);

+ WriteConfigInteger (configFile, configContent, "HashRqt", requestHash);

+ WriteConfigString (configFile, configContent, "PimMsg", pimMsg.c_str());

+ WriteConfigInteger (configFile, configContent, "Pim", pim);

+ WriteConfigInteger (configFile, configContent, "PimRqt", requestPim);

+ WriteConfigInteger (configFile, configContent, "AuthorizeVisible", authorizeVisible);

+ WriteConfigInteger (configFile, configContent, "AuthorizeRetry", authorizeRetry);

+

+ // Write unmodified values

+ char* xml = configContent;

+ char key[128], value[2048];

+ while (xml && (xml = XmlFindElement (xml, "config")))

+ {

+ XmlGetAttributeText (xml, "key", key, sizeof (key));

+ XmlGetNodeText (xml, value, sizeof (value));

+

+ fwprintf (configFile, L"\n\t\t<config key=\"%hs\">%hs</config>", key, value);

+ xml++;

+ }

+

+ fputws (L"\n\t</configuration>", configFile);

+ XmlWriteFooter (configFile);

+

+ TCFlushFile (configFile);

+

+ bRet = CheckFileStreamWriteErrors (hwnd, configFile, fileName);

+

+ fclose (configFile);

+

+ if (configContent != NULL)

+ {

+ burn (configContent, size);

+ free (configContent);

+ }

+

+ return bRet;

+ }

+

+ static const wchar_t* EfiVarGuid = L"{8BE4DF61-93CA-11D2-AA0D-00E098032B8C}";

+

+ EfiBoot::EfiBoot() {

+ ZeroMemory(EfiBootPartPath, sizeof(EfiBootPartPath));

+ ZeroMemory (systemPartitionPath, sizeof (systemPartitionPath));

+ m_bMounted = false;

+ }

+

+ void EfiBoot::MountBootPartition(WCHAR letter) {

+ NTSTATUS res;

+ ULONG len;

+ memset(tempBuf, 0, sizeof(tempBuf));

+

+ // Load NtQuerySystemInformation function point

+ if (!NtQuerySystemInformationPtr)

+ {

+ NtQuerySystemInformationPtr = (NtQuerySystemInformationFn) GetProcAddress (GetModuleHandle (L"ntdll.dll"), "NtQuerySystemInformation");

+ if (!NtQuerySystemInformationPtr)

+ throw SystemException (SRC_POS);

+ }

+

+ res = NtQuerySystemInformationPtr((SYSTEM_INFORMATION_CLASS)SYSPARTITIONINFORMATION, tempBuf, sizeof(tempBuf), &len);

+ if (res != S_OK)

+ {

+ SetLastError (res);

+ throw SystemException (SRC_POS);

+ }

+

+ PUNICODE_STRING pStr = (PUNICODE_STRING) tempBuf;

+ memcpy (systemPartitionPath, pStr->Buffer, min (pStr->Length, (sizeof (systemPartitionPath) - 2)));

+

+ if (!letter) {

+ if (!GetFreeDriveLetter(&EfiBootPartPath[0])) {

+ throw ErrorException(L"No free letter to mount EFI boot partition", SRC_POS);

+ }

+ } else {

+ EfiBootPartPath[0] = letter;

+ }

+ EfiBootPartPath[1] = ':';

+ EfiBootPartPath[2] = 0;

+ throw_sys_if(!DefineDosDevice(DDD_RAW_TARGET_PATH, EfiBootPartPath, systemPartitionPath));

+

+ Device dev(EfiBootPartPath, TRUE);

+

+ try

+ {

+ dev.CheckOpened(SRC_POS);

+ }

+ catch (...)

+ {

+ DefineDosDevice(DDD_REMOVE_DEFINITION, EfiBootPartPath, NULL);

+ throw;

+ }

+

+ bool bSuccess = dev.IoCtl(IOCTL_STORAGE_GET_DEVICE_NUMBER, NULL, 0, &sdn, sizeof(sdn))

+ && dev.IoCtl(IOCTL_DISK_GET_PARTITION_INFO_EX, NULL, 0, &partInfo, sizeof(partInfo));

+ DWORD dwLastError = GetLastError ();

+ dev.Close();

+ if (!bSuccess)

+ {

+ DefineDosDevice(DDD_REMOVE_DEFINITION, EfiBootPartPath, NULL);

+ SetLastError (dwLastError);

+ throw SystemException(SRC_POS);

+ }

+

+ m_bMounted = true;

+ }

+

+ void EfiBoot::DismountBootPartition() {

+ if (m_bMounted)

+ {

+ DefineDosDevice(DDD_REMOVE_DEFINITION, EfiBootPartPath, NULL);

+ m_bMounted = false;

+ }

+ }

+

+ bool EfiBoot::IsEfiBoot() {

+ DWORD BootOrderLen;

+ BootOrderLen = GetFirmwareEnvironmentVariable(L"BootOrder", EfiVarGuid, tempBuf, sizeof(tempBuf));

+ return BootOrderLen != 0;

+ }

+

+ void EfiBoot::DeleteStartExec(uint16 statrtOrderNum, wchar_t* type) {

+ RaisePrivileges();

+ // Check EFI

+ if (!IsEfiBoot()) {

+ throw ErrorException(L"can not detect EFI environment", SRC_POS);

+ }

+ wchar_t varName[256];

+ StringCchPrintfW(varName, ARRAYSIZE (varName), L"%s%04X", type == NULL ? L"Boot" : type, statrtOrderNum);

+ SetFirmwareEnvironmentVariable(varName, EfiVarGuid, NULL, 0);

+

+ wstring order = L"Order";

+ order.insert(0, type == NULL ? L"Boot" : type);

+ uint32 startOrderLen = GetFirmwareEnvironmentVariable(order.c_str(), EfiVarGuid, tempBuf, sizeof(tempBuf));

+ uint32 startOrderNumPos = UINT_MAX;

+ bool startOrderUpdate = false;

+ uint16* startOrder = (uint16*)tempBuf;

+ for (uint32 i = 0; i < startOrderLen / 2; i++) {

+ if (startOrder[i] == statrtOrderNum) {

+ startOrderNumPos = i;

+ break;

+ }

+ }

+

+ // delete entry if present

+ if (startOrderNumPos != UINT_MAX) {

+ for (uint32 i = startOrderNumPos; i < ((startOrderLen / 2) - 1); ++i) {

+ startOrder[i] = startOrder[i + 1];

+ }

+ startOrderLen -= 2;

+ startOrderUpdate = true;

+ }

+

+ if (startOrderUpdate) {

+ SetFirmwareEnvironmentVariable(order.c_str(), EfiVarGuid, startOrder, startOrderLen);

+

+ // remove ourselves from BootNext value

+ uint16 bootNextValue = 0;

+ wstring next = L"Next";

+ next.insert(0, type == NULL ? L"Boot" : type);

+

+ if ( (GetFirmwareEnvironmentVariable(next.c_str(), EfiVarGuid, &bootNextValue, 2) == 2)

+ && (bootNextValue == statrtOrderNum)

+ )

+ {

+ SetFirmwareEnvironmentVariable(next.c_str(), EfiVarGuid, startOrder, 0);

+ }

+ }

+ }

+

+ void EfiBoot::SetStartExec(wstring description, wstring execPath, uint16 statrtOrderNum , wchar_t* type, uint32 attr) {

+ RaisePrivileges();

+ // Check EFI

+ if (!IsEfiBoot()) {

+ throw ErrorException(L"can not detect EFI environment", SRC_POS);

+ }

+

+ uint32 varSize = 56;

+ varSize += ((uint32) description.length()) * 2 + 2;

+ varSize += ((uint32) execPath.length()) * 2 + 2;

+ byte *startVar = new byte[varSize];

+ byte *pVar = startVar;

+

+ // Attributes (1b Active, 1000b - Hidden)

+ *(uint32 *)pVar = attr;

+ pVar += sizeof(uint32);

+

+ // Size Of device path + file path

+ *(uint16 *)pVar = (uint16)(50 + execPath.length() * 2 + 2);

+ pVar += sizeof(uint16);

+

+ // description

+ for (uint32 i = 0; i < description.length(); i++) {

+ *(uint16 *)pVar = description[i];

+ pVar += sizeof(uint16);

+ }

+ *(uint16 *)pVar = 0;

+ pVar += sizeof(uint16);

+

+ /* EFI_DEVICE_PATH_PROTOCOL (HARDDRIVE_DEVICE_PATH \ FILE_PATH \ END) */

+

+ // Type

+ *(byte *)pVar = 0x04;

+ pVar += sizeof(byte);

+

+ // SubType

+ *(byte *)pVar = 0x01;

+ pVar += sizeof(byte);

+

+ // HDD dev path length

+ *(uint16 *)pVar = 0x2A; // 42

+ pVar += sizeof(uint16);

+

+ // PartitionNumber

+ *(uint32 *)pVar = (uint32)partInfo.PartitionNumber;

+ pVar += sizeof(uint32);

+

+ // PartitionStart

+ *(uint64 *)pVar = partInfo.StartingOffset.QuadPart >> 9;

+ pVar += sizeof(uint64);

+

+ // PartitiontSize

+ *(uint64 *)pVar = partInfo.PartitionLength.QuadPart >> 9;

+ pVar += sizeof(uint64);

+

+ // GptGuid

+ memcpy(pVar, &partInfo.Gpt.PartitionId, 16);

+ pVar += 16;

+

+ // MbrType

+ *(byte *)pVar = 0x02;

+ pVar += sizeof(byte);

+

+ // SigType

+ *(byte *)pVar = 0x02;

+ pVar += sizeof(byte);

+

+ // Type and sub type 04 04 (file path)

+ *(uint16 *)pVar = 0x0404;

+ pVar += sizeof(uint16);

+

+ // SizeOfFilePath ((CHAR16)FullPath.length + sizeof(EndOfrecord marker) )

+ *(uint16 *)pVar = (uint16)(execPath.length() * 2 + 2 + sizeof(uint32));

+ pVar += sizeof(uint16);

+

+ // FilePath

+ for (uint32 i = 0; i < execPath.length(); i++) {

+ *(uint16 *)pVar = execPath[i];

+ pVar += sizeof(uint16);

+ }

+ *(uint16 *)pVar = 0;

+ pVar += sizeof(uint16);

+

+ // EndOfrecord

+ *(uint32 *)pVar = 0x04ff7f;

+ pVar += sizeof(uint32);

+

+ // Set variable

+ wchar_t varName[256];

+ StringCchPrintfW(varName, ARRAYSIZE (varName), L"%s%04X", type == NULL ? L"Boot" : type, statrtOrderNum);

+ SetFirmwareEnvironmentVariable(varName, EfiVarGuid, startVar, varSize);

+ delete startVar;

+

+ // Update order

+ wstring order = L"Order";

+ order.insert(0, type == NULL ? L"Boot" : type);

+

+ uint32 startOrderLen = GetFirmwareEnvironmentVariable(order.c_str(), EfiVarGuid, tempBuf, sizeof(tempBuf));

+ uint32 startOrderNumPos = UINT_MAX;

+ bool startOrderUpdate = false;

+ uint16* startOrder = (uint16*)tempBuf;

+ for (uint32 i = 0; i < startOrderLen / 2; i++) {

+ if (startOrder[i] == statrtOrderNum) {

+ startOrderNumPos = i;

+ break;

+ }

+ }

+

+ // Create new entry if absent

+ if (startOrderNumPos == UINT_MAX) {

+ for (uint32 i = startOrderLen / 2; i > 0; --i) {

+ startOrder[i] = startOrder[i - 1];

+ }

+ startOrder[0] = statrtOrderNum;

+ startOrderLen += 2;

+ startOrderUpdate = true;

+ } else if (startOrderNumPos > 0) {

+ for (uint32 i = startOrderNumPos; i > 0; --i) {

+ startOrder[i] = startOrder[i - 1];

+ }

+ startOrder[0] = statrtOrderNum;

+ startOrderUpdate = true;

+ }

+

+ if (startOrderUpdate) {

+ SetFirmwareEnvironmentVariable(order.c_str(), EfiVarGuid, startOrder, startOrderLen);

+ }

+

+ // set BootNext value

+ wstring next = L"Next";

+ next.insert(0, type == NULL ? L"Boot" : type);

+

+ SetFirmwareEnvironmentVariable(next.c_str(), EfiVarGuid, &statrtOrderNum, 2);

+ }

+

+ void EfiBoot::SaveFile(wchar_t* name, byte* data, DWORD size) {

+ wstring path = EfiBootPartPath;

+ path += name;

+ File f(path, false, true);

+ f.Write(data, size);

+ f.Close();

+ }

+

+ void EfiBoot::GetFileSize(const wchar_t* name, unsigned __int64& size) {

+ wstring path = EfiBootPartPath;

+ path += name;

+ File f(path, true);

+ f.GetFileSize(size);

+ f.Close();

+ }

+

+ void EfiBoot::ReadFile(const wchar_t* name, byte* data, DWORD size) {

+ wstring path = EfiBootPartPath;

+ path += name;

+ File f(path, true);

+ f.Read(data, size);

+ f.Close();

+ }

+

+ void EfiBoot::CopyFile(const wchar_t* name, const wchar_t* targetName) {

+ wstring path = EfiBootPartPath;

+ path += name;

+ wstring targetPath;

+ if (targetName[0] == L'\\')

+ {

+ targetPath = EfiBootPartPath;

+ targetPath += targetName;

+ }

+ else

+ targetPath = targetName;

+ throw_sys_if (!::CopyFileW (path.c_str(), targetPath.c_str(), FALSE));

+ }

+

+ BOOL EfiBoot::RenameFile(wchar_t* name, wchar_t* nameNew, BOOL bForce) {

+ wstring path = EfiBootPartPath;

+ path += name;

+ wstring pathNew = EfiBootPartPath;

+ pathNew += nameNew;

+ return MoveFileExW(path.c_str(), pathNew.c_str(), bForce? MOVEFILE_REPLACE_EXISTING : 0);

+ }

+

+ BOOL EfiBoot::DelFile(wchar_t* name) {

+ wstring path = EfiBootPartPath;

+ path += name;

+ return DeleteFile(path.c_str());

+ }

+

+ BOOL EfiBoot::MkDir(wchar_t* name, bool& bAlreadyExists) {

+ wstring path = EfiBootPartPath;

+ path += name;

+ bAlreadyExists = false;

+ BOOL bRet = CreateDirectory(path.c_str(), NULL);

+ if (!bRet && (GetLastError () == ERROR_ALREADY_EXISTS))

+ {

+ bRet = TRUE;

+ bAlreadyExists = true;

+ }

+ return bRet;

+ }

+

+ BOOL EfiBoot::ReadConfig (wchar_t* name, EfiBootConf& conf)

+ {

+ wstring path = EfiBootPartPath;

+ path += name;

+

+ return conf.Load (path.c_str());

+ }

+

+ BOOL EfiBoot::UpdateConfig (wchar_t* name, int pim, int hashAlgo, HWND hwndDlg)

+ {

+ BOOL bRet = FALSE;

+ EfiBootConf conf;

+ wstring path = EfiBootPartPath;

+ path += name;

+

+ if (conf.Load (path.c_str()))

+ {

+ if (pim >= 0)

+ {

+ conf.pim = pim;

+ conf.requestPim = 0;

+ }

+ else

+ {

+ conf.pim = 0;

+ conf.requestPim = 1;

+ }

+

+ if (hashAlgo >= 0)

+ {

+ conf.hashAlgo = hashAlgo;

+ conf.requestHash = 0;

+ }

+ else

+ {

+ conf.hashAlgo = 0;

+ conf.requestHash = 1;

+ }

+

+ return conf.Save (path.c_str(), hwndDlg);

+ }

+

+ return bRet;

+ }

+

+ BOOL EfiBoot::WriteConfig (wchar_t* name, bool preserveUserConfig, int pim, int hashAlgo, const char* passPromptMsg, HWND hwndDlg)

+ {

+ EfiBootConf conf;

+ wstring path = EfiBootPartPath;

+ path += name;

+

+ if (preserveUserConfig)

+ {

+ conf.Load (path.c_str());

+ if (pim >= 0 && (conf.requestPim == 0))

+ {

+ conf.pim = pim;

+ }

+ if (hashAlgo >= 0 && (conf.requestHash == 0))

+ {

+ conf.hashAlgo = hashAlgo;

+ }

+ }

+ else

+ {

+ if (pim >= 0)

+ {

+ conf.pim = pim;

+ conf.requestPim = 0;

+ }

+ else

+ {

+ conf.pim = 0;

+ conf.requestPim = 1;

+ }

+

+ if (hashAlgo >= 0)

+ {

+ conf.hashAlgo = hashAlgo;

+ conf.requestHash = 0;

+ }

+ else

+ {

+ conf.hashAlgo = 0;

+ conf.requestHash = 1;

+ }

+ }

+

+ if (passPromptMsg && strlen (passPromptMsg))

+ {

+ conf.passwordMsg = passPromptMsg;

+ }

+

+ return conf.Save (path.c_str(), hwndDlg);

+ }

+

+ void BootEncryption::InstallBootLoader (bool preserveUserConfig, bool hiddenOSCreation, int pim, int hashAlg)

+ InstallBootLoader (device, preserveUserConfig, hiddenOSCreation, pim, hashAlg);

+ void BootEncryption::InstallBootLoader (Device& device, bool preserveUserConfig, bool hiddenOSCreation, int pim, int hashAlg)

+ SystemDriveConfiguration config = GetSystemDriveConfiguration();

+ if (config.SystemPartition.IsGPT) {

+ if (!IsAdmin()) {

+ if (IsUacSupported())

+ {

+ Elevator::InstallEfiBootLoader (preserveUserConfig, hiddenOSCreation, pim, hashAlg);

+ return;

+ }

+ else

+ {

+ Warning ("ADMIN_PRIVILEGES_WARN_DEVICES", ParentWindow);

+ }

+ }

+ DWORD sizeDcsBoot;

+ byte *dcsBootImg = MapResource(L"BIN", IDR_EFI_DCSBOOT, &sizeDcsBoot);

+ if (!dcsBootImg)

+ throw ErrorException(L"Out of resource DcsBoot", SRC_POS);

+ DWORD sizeDcsInt;

+ byte *dcsIntImg = MapResource(L"BIN", IDR_EFI_DCSINT, &sizeDcsInt);

+ if (!dcsIntImg)

+ throw ErrorException(L"Out of resource DcsInt", SRC_POS);

+ DWORD sizeDcsCfg;

+ byte *dcsCfgImg = MapResource(L"BIN", IDR_EFI_DCSCFG, &sizeDcsCfg);

+ if (!dcsCfgImg)

+ throw ErrorException(L"Out of resource DcsCfg", SRC_POS);

+ DWORD sizeLegacySpeaker;

+ byte *LegacySpeakerImg = MapResource(L"BIN", IDR_EFI_LEGACYSPEAKER, &sizeLegacySpeaker);

+ if (!LegacySpeakerImg)

+ throw ErrorException(L"Out of resource LegacySpeaker", SRC_POS);

+ DWORD sizeBootMenuLocker;

+ byte *BootMenuLockerImg = MapResource(L"BIN", IDR_EFI_DCSBML, &sizeBootMenuLocker);

+ if (!BootMenuLockerImg)

+ throw ErrorException(L"Out of resource DcsBml", SRC_POS);

+

+ finally_do ({ EfiBootInst.DismountBootPartition(); });

+ EfiBootInst.MountBootPartition(0);

+ try

+ {

+ // Save modules

+ bool bAlreadyExist;

+

+ EfiBootInst.MkDir(L"\\EFI\\VeraCrypt", bAlreadyExist);

+ EfiBootInst.SaveFile(L"\\EFI\\VeraCrypt\\DcsBoot.efi", dcsBootImg, sizeDcsBoot);

+ EfiBootInst.SaveFile(L"\\EFI\\Boot\\bootx64.efi", dcsBootImg, sizeDcsBoot);

+ EfiBootInst.SaveFile(L"\\EFI\\VeraCrypt\\DcsInt.dcs", dcsIntImg, sizeDcsInt);

+ EfiBootInst.SaveFile(L"\\EFI\\VeraCrypt\\DcsCfg.dcs", dcsCfgImg, sizeDcsCfg);

+ EfiBootInst.SaveFile(L"\\EFI\\VeraCrypt\\LegacySpeaker.dcs", LegacySpeakerImg, sizeLegacySpeaker);

+ EfiBootInst.SaveFile(L"\\EFI\\VeraCrypt\\DcsBml.dcs", BootMenuLockerImg, sizeBootMenuLocker);

+ EfiBootInst.SetStartExec(L"VeraCrypt BootLoader (DcsBoot)", L"\\EFI\\VeraCrypt\\DcsBoot.efi");

+

+ // move configuration file from old location (if it exists) to new location

+ // we don't force the move operation if the new location already exists

+ EfiBootInst.RenameFile (L"\\DcsProp", L"\\EFI\\VeraCrypt\\DcsProp", FALSE);

+ EfiBootInst.RenameFile (L"\\DcsBoot", L"\\EFI\\VeraCrypt\\DcsBoot", FALSE);

+

+ // move the original bootloader backup from old location (if it exists) to new location

+ // we don't force the move operation if the new location already exists

+ EfiBootInst.RenameFile (L"\\EFI\\Boot\\original_bootx64_vc_backup.efi", L"\\EFI\\Boot\\original_bootx64.vc_backup", FALSE);

+

+ // Clean beta9

+ EfiBootInst.DelFile(L"\\DcsBoot.efi");

+ EfiBootInst.DelFile(L"\\DcsInt.efi");

+ EfiBootInst.DelFile(L"\\DcsCfg.efi");

+ EfiBootInst.DelFile(L"\\LegacySpeaker.efi");

+ EfiBootInst.DelFile(L"\\DcsBoot");

+ EfiBootInst.DelFile(L"\\DcsProp");

+ }

+ catch (...)

+ {

+ throw;

+ }

+ EfiBootInst.WriteConfig (L"\\EFI\\VeraCrypt\\DcsProp", preserveUserConfig, pim, hashAlg, NULL, ParentWindow);

+ }

+ else

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

+ CreateBootLoaderInMemory (bootLoaderBuf, sizeof (bootLoaderBuf), false, hiddenOSCreation);

+

+ // Write MBR

+ byte mbr[TC_SECTOR_SIZE_BIOS];

+ device.SeekAt (0);

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

+

+ if (preserveUserConfig && BufferContainsString (mbr, sizeof (mbr), TC_APP_NAME))

+ {

+ uint16 version = BE16 (*(uint16 *) (mbr + TC_BOOT_SECTOR_VERSION_OFFSET));

+ if (version != 0)

+ bootLoaderBuf[TC_BOOT_SECTOR_USER_CONFIG_OFFSET] = mbr[TC_BOOT_SECTOR_USER_CONFIG_OFFSET];

+ memcpy (bootLoaderBuf + TC_BOOT_SECTOR_USER_MESSAGE_OFFSET, mbr + TC_BOOT_SECTOR_USER_MESSAGE_OFFSET, TC_BOOT_SECTOR_USER_MESSAGE_MAX_LENGTH);

+

+ if (bootLoaderBuf[TC_BOOT_SECTOR_USER_CONFIG_OFFSET] & TC_BOOT_USER_CFG_FLAG_DISABLE_PIM)

+ if (pim >= 0)

+ {

+ memcpy (bootLoaderBuf + TC_BOOT_SECTOR_PIM_VALUE_OFFSET, &pim, TC_BOOT_SECTOR_PIM_VALUE_SIZE);

+ }

+ else

+ memcpy (bootLoaderBuf + TC_BOOT_SECTOR_PIM_VALUE_OFFSET, mbr + TC_BOOT_SECTOR_PIM_VALUE_OFFSET, TC_BOOT_SECTOR_PIM_VALUE_SIZE);

+ memcpy (mbr, bootLoaderBuf, TC_MAX_MBR_BOOT_CODE_SIZE);

+ device.SeekAt (0);

+ device.Write (mbr, sizeof (mbr));

+ byte mbrVerificationBuf[TC_SECTOR_SIZE_BIOS];

+ device.SeekAt (0);

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

+ if (memcmp (mbr, mbrVerificationBuf, sizeof (mbr)) != 0)

+ throw ErrorException ("ERROR_MBR_PROTECTED", SRC_POS);

+ // Write boot loader

+ device.SeekAt (TC_SECTOR_SIZE_BIOS);

+ device.Write (bootLoaderBuf + TC_SECTOR_SIZE_BIOS, sizeof (bootLoaderBuf) - TC_SECTOR_SIZE_BIOS);

+ }

+ SystemDriveConfiguration config = GetSystemDriveConfiguration();

+

+ // return true for now when EFI system encryption is used until we implement

+ // a dedicated EFI fingerprinting mechanism in VeraCrypt driver

+ if (config.SystemPartition.IsGPT)

+ return true;

+

+

+ BOOL bIsGPT = GetSystemDriveConfiguration().SystemPartition.IsGPT;

+ if (bIsGPT)

+ {

+ // create EFI disk structure

+ DWORD sizeDcsBoot;

+ byte *dcsBootImg = MapResource(L"BIN", IDR_EFI_DCSBOOT, &sizeDcsBoot);

+ if (!dcsBootImg)

+ throw ParameterIncorrect (SRC_POS);

+ DWORD sizeDcsInt;

+ byte *dcsIntImg = MapResource(L"BIN", IDR_EFI_DCSINT, &sizeDcsInt);

+ if (!dcsIntImg)

+ throw ParameterIncorrect (SRC_POS);

+ DWORD sizeDcsCfg;

+ byte *dcsCfgImg = MapResource(L"BIN", IDR_EFI_DCSCFG, &sizeDcsCfg);

+ if (!dcsCfgImg)

+ throw ParameterIncorrect (SRC_POS);

+ DWORD sizeLegacySpeaker;

+ byte *LegacySpeakerImg = MapResource(L"BIN", IDR_EFI_LEGACYSPEAKER, &sizeLegacySpeaker);

+ if (!LegacySpeakerImg)

+ throw ParameterIncorrect (SRC_POS);

+ DWORD sizeBootMenuLocker;

+ byte *BootMenuLockerImg = MapResource(L"BIN", IDR_EFI_DCSBML, &sizeBootMenuLocker);

+ if (!BootMenuLockerImg)

+ throw ParameterIncorrect (SRC_POS);

+ DWORD sizeDcsRescue;

+ byte *DcsRescueImg = MapResource(L"BIN", IDR_EFI_DCSRE, &sizeDcsRescue);

+ if (!DcsRescueImg)

+ throw ParameterIncorrect (SRC_POS);

+ unsigned int maxRescueZipSize = 4 * 1024 * 1024;

+ ZRESULT res;

+ HZIP hz = CreateZip (0, maxRescueZipSize, ZIP_MEMORY);

+ if (!hz)

+ finally_do_arg (HZIP, hz, { CloseZip (finally_arg); });

+ if (ZR_OK != ZipAdd (hz, L"EFI/Boot/bootx64.efi", DcsRescueImg, sizeDcsRescue, ZIP_MEMORY))

+ throw ParameterIncorrect (SRC_POS);

+ if (ZR_OK !=ZipAdd (hz, L"EFI/VeraCrypt/DcsBml.dcs", BootMenuLockerImg, sizeBootMenuLocker, ZIP_MEMORY))

+ throw ParameterIncorrect (SRC_POS);

+ if (ZR_OK != ZipAdd (hz, L"EFI/VeraCrypt/DcsBoot.efi", dcsBootImg, sizeDcsBoot, ZIP_MEMORY))

+ throw ParameterIncorrect (SRC_POS);

+ if (ZR_OK != ZipAdd (hz, L"EFI/VeraCrypt/DcsCfg.dcs", dcsCfgImg, sizeDcsCfg, ZIP_MEMORY))

+ throw ParameterIncorrect (SRC_POS);

+ if (ZR_OK != ZipAdd (hz, L"EFI/VeraCrypt/DcsInt.dcs", dcsIntImg, sizeDcsInt, ZIP_MEMORY))

+ throw ParameterIncorrect (SRC_POS);

+ if (ZR_OK != ZipAdd (hz, L"EFI/VeraCrypt/LegacySpeaker.dcs", LegacySpeakerImg, sizeLegacySpeaker, ZIP_MEMORY))

+ throw ParameterIncorrect (SRC_POS);

+

+ Buffer volHeader(TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE);

+

+ // Volume header

+ if (initialSetup)

+ {

+ if (!RescueVolumeHeaderValid)

+ throw ParameterIncorrect (SRC_POS);

+

+ memcpy (volHeader.Ptr (), RescueVolumeHeader, TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE);

+ }

+ else

+ {

+ Device bootDevice (GetSystemDriveConfiguration().DevicePath, true);

+ bootDevice.CheckOpened (SRC_POS);

+ bootDevice.SeekAt (TC_BOOT_VOLUME_HEADER_SECTOR_OFFSET);

+ bootDevice.Read (volHeader.Ptr (), TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE);

+ }

+

+ if (ZR_OK != ZipAdd (hz, L"EFI/VeraCrypt/svh_bak", volHeader.Ptr (), TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE, ZIP_MEMORY))

+ throw ParameterIncorrect (SRC_POS);

+

+ // Original system loader

+ res = ZR_WRITE;

+ try

+ {

+ DWORD fileSize = 0;

+ File sysBakFile (GetSystemLoaderBackupPath(), true);

+ sysBakFile.CheckOpened (SRC_POS);

+ sysBakFile.GetFileSize(fileSize);

+ Buffer fileBuf ((DWORD) fileSize);

+ DWORD sizeLoader = sysBakFile.Read (fileBuf.Ptr (), fileSize);

+ res = ZipAdd (hz, L"EFI/Boot/original_bootx64.vc_backup", fileBuf.Ptr (), sizeLoader, ZIP_MEMORY);

+ }

+ catch (Exception &e)

+ {

+ e.Show (ParentWindow);

+ Warning ("SYS_LOADER_UNAVAILABLE_FOR_RESCUE_DISK", ParentWindow);

+ }

+

+ if (res != ZR_OK)

+ throw ParameterIncorrect (SRC_POS);

+

+ EfiBootConf conf;

+ wstring dcsPropFileName = GetTempPathString() + L"_dcsproprescue";

+ finally_do_arg (wstring, dcsPropFileName, { DeleteFileW (finally_arg.c_str()); });

+ if (conf.Save(dcsPropFileName.c_str(), ParentWindow))

+ {

+ DWORD fileSize = 0;

+ File propFile (dcsPropFileName, true, false);

+ propFile.CheckOpened (SRC_POS);

+ propFile.GetFileSize(fileSize);

+ Buffer propBuf (fileSize);

+ DWORD sizeDcsProp = propFile.Read (propBuf.Ptr (), fileSize);

+

+ if (ZR_OK != ZipAdd (hz, L"EFI/VeraCrypt/DcsProp", propBuf.Ptr (), sizeDcsProp, ZIP_MEMORY))

+ throw ParameterIncorrect (SRC_POS);

+ }

+ else

+ throw ParameterIncorrect (SRC_POS);

+ void* pZipContent = NULL;

+ unsigned long ulZipSize = 0;

+ if (ZR_OK != ZipGetMemory (hz, &pZipContent, &ulZipSize))

+ throw ParameterIncorrect (SRC_POS);

+

+ RescueZipData = new byte[ulZipSize];

+ if (!RescueZipData)

+ throw bad_alloc();

+ memcpy (RescueZipData, pZipContent, ulZipSize);

+ RescueZipSize = ulZipSize;

+

+ if (!isoImagePath.empty())

+ {

+ File isoFile (isoImagePath, false, true);

+ isoFile.Write (RescueZipData, RescueZipSize);

+ }

+ else

+ Buffer imageBuf (RescueIsoImageSize);

+

+ byte *image = imageBuf.Ptr();

+ memset (image, 0, RescueIsoImageSize);

+

+ // Primary volume descriptor

+ const char* szPrimVolDesc = "\001CD001\001";

+ const char* szPrimVolLabel = "VeraCrypt Rescue Disk ";

+ memcpy (image + 0x8000, szPrimVolDesc, strlen(szPrimVolDesc) + 1);

+ memcpy (image + 0x7fff + 41, szPrimVolLabel, strlen(szPrimVolLabel) + 1);

+ *(uint32 *) (image + 0x7fff + 81) = RescueIsoImageSize / 2048;

+ *(uint32 *) (image + 0x7fff + 85) = BE32 (RescueIsoImageSize / 2048);

+ image[0x7fff + 121] = 1;

+ image[0x7fff + 124] = 1;

+ image[0x7fff + 125] = 1;

+ image[0x7fff + 128] = 1;

+ image[0x7fff + 130] = 8;

+ image[0x7fff + 131] = 8;

+

+ image[0x7fff + 133] = 10;

+ image[0x7fff + 140] = 10;

+ image[0x7fff + 141] = 0x14;

+ image[0x7fff + 157] = 0x22;

+ image[0x7fff + 159] = 0x18;

+

+ // Boot record volume descriptor

+ const char* szBootRecDesc = "CD001\001EL TORITO SPECIFICATION";

+ memcpy (image + 0x8801, szBootRecDesc, strlen(szBootRecDesc) + 1);

+ image[0x8800 + 0x47] = 0x19;

+

+ // Volume descriptor set terminator

+ const char* szVolDescTerm = "\377CD001\001";

+ memcpy (image + 0x9000, szVolDescTerm, strlen(szVolDescTerm) + 1);

+

+ // Path table

+ image[0xA000 + 0] = 1;

+ image[0xA000 + 2] = 0x18;

+ image[0xA000 + 6] = 1;

+

+ // Root directory

+ image[0xc000 + 0] = 0x22;

+ image[0xc000 + 2] = 0x18;

+ image[0xc000 + 9] = 0x18;

+ image[0xc000 + 11] = 0x08;

+ image[0xc000 + 16] = 0x08;

+ image[0xc000 + 25] = 0x02;

+ image[0xc000 + 28] = 0x01;

+ image[0xc000 + 31] = 0x01;

+ image[0xc000 + 32] = 0x01;

+ image[0xc000 + 34] = 0x22;

+ image[0xc000 + 36] = 0x18;

+ image[0xc000 + 43] = 0x18;

+ image[0xc000 + 45] = 0x08;

+ image[0xc000 + 50] = 0x08;

+ image[0xc000 + 59] = 0x02;

+ image[0xc000 + 62] = 0x01;

+ *(uint32 *) (image + 0xc000 + 65) = 0x010101;

+

+ // Validation entry

+ image[0xc800] = 1;

+ int offset = 0xc800 + 0x1c;

+ image[offset++] = 0xaa;

+ image[offset++] = 0x55;

+ image[offset++] = 0x55;

+ image[offset] = 0xaa;

+

+ // Initial entry

+ offset = 0xc820;

+ image[offset++] = 0x88;

+ image[offset++] = 2;

+ image[0xc820 + 6] = 1;

+ image[0xc820 + 8] = TC_CD_BOOT_LOADER_SECTOR;

+

+ // TrueCrypt Boot Loader

+ CreateBootLoaderInMemory (image + TC_CD_BOOTSECTOR_OFFSET, TC_BOOT_LOADER_AREA_SIZE, true);

+

+ // Volume header

+ if (initialSetup)

+ {

+ if (!RescueVolumeHeaderValid)

+ throw ParameterIncorrect (SRC_POS);

+

+ memcpy (image + TC_CD_BOOTSECTOR_OFFSET + TC_BOOT_VOLUME_HEADER_SECTOR_OFFSET, RescueVolumeHeader, TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE);

+ }

+ else

+ {

+ Device bootDevice (GetSystemDriveConfiguration().DevicePath, true);

+ bootDevice.CheckOpened (SRC_POS);

+ bootDevice.SeekAt (TC_BOOT_VOLUME_HEADER_SECTOR_OFFSET);

+ bootDevice.Read (image + TC_CD_BOOTSECTOR_OFFSET + TC_BOOT_VOLUME_HEADER_SECTOR_OFFSET, TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE);

+ }

+ // Original system loader

+ try

+ {

+ File sysBakFile (GetSystemLoaderBackupPath(), true);

+ sysBakFile.CheckOpened (SRC_POS);

+ sysBakFile.Read (image + TC_CD_BOOTSECTOR_OFFSET + TC_ORIG_BOOT_LOADER_BACKUP_SECTOR_OFFSET, TC_BOOT_LOADER_AREA_SIZE);

+

+ image[TC_CD_BOOTSECTOR_OFFSET + TC_BOOT_SECTOR_CONFIG_OFFSET] |= TC_BOOT_CFG_FLAG_RESCUE_DISK_ORIG_SYS_LOADER;

+ }

+ catch (Exception &e)

+ {

+ e.Show (ParentWindow);

+ Warning ("SYS_LOADER_UNAVAILABLE_FOR_RESCUE_DISK", ParentWindow);

+ }

+

+ // Boot loader backup

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

+ RescueIsoImage = new byte[RescueIsoImageSize];

+ if (!RescueIsoImage)

+ throw bad_alloc();

+ memcpy (RescueIsoImage, image, RescueIsoImageSize);

+ if (!isoImagePath.empty())

+ {

+ File isoFile (isoImagePath, false, true);

+ isoFile.Write (image, RescueIsoImageSize);

+ }

+ BOOL bIsGPT = GetSystemDriveConfiguration().SystemPartition.IsGPT;

+ if ((bIsGPT && !RescueZipData) || (!bIsGPT && !RescueIsoImage))

+ if (bIsGPT)

+ const wchar_t* efiFiles[] = {

+ L"EFI/Boot/bootx64.efi",

+ L"EFI/VeraCrypt/DcsBml.dcs",

+ L"EFI/VeraCrypt/DcsBoot.efi",

+ L"EFI/VeraCrypt/DcsCfg.dcs",

+ L"EFI/VeraCrypt/DcsInt.dcs",

+ L"EFI/VeraCrypt/LegacySpeaker.dcs",

+ L"EFI/VeraCrypt/svh_bak",

+ L"EFI/Boot/original_bootx64.vc_backup"

+ };

+

+ ZRESULT res;

+ HZIP hz = OpenZip(RescueZipData, RescueZipSize, ZIP_MEMORY);

+ if (!hz)

+ throw ParameterIncorrect (SRC_POS);

+ finally_do_arg (HZIP, hz, { CloseZip (finally_arg); });

+

+ for (WCHAR drive = L'Z'; drive >= L'C'; --drive)

+ {

+ try

+ {

+ WCHAR rootPath[4] = { drive, L':', L'\\', 0};

+ UINT driveType = GetDriveType (rootPath);

+ if (DRIVE_REMOVABLE == driveType)

+ {

+ // check if it is FAT/FAT32

+ WCHAR szNameBuffer[TC_MAX_PATH];

+ if (GetVolumeInformationW (rootPath, NULL, 0, NULL, NULL, NULL, szNameBuffer, ARRAYSIZE(szNameBuffer))

+ && !wcsncmp (szNameBuffer, L"FAT", 3))

+ {

+ int index, i;

+ ZIPENTRYW ze;

+ for (i = 0; i < ARRAYSIZE(efiFiles); i++)

+ {

+ bool bMatch = false;

+ res = FindZipItemW (hz, efiFiles[i], true, &index, &ze);

+ if ((res == ZR_OK) && (index >= 0))

+ {

+ // check that the file exists on the disk and that it has the same content

+ StringCbCopyW (szNameBuffer, sizeof (szNameBuffer), rootPath);

+ StringCbCatW (szNameBuffer, sizeof (szNameBuffer), efiFiles[i]);

+

+ try

+ {

+ DWORD dwSize = 0;

+ File diskFile (szNameBuffer, true);

+ diskFile.CheckOpened (SRC_POS);

+ diskFile.GetFileSize (dwSize);

+ if (dwSize == (DWORD) ze.unc_size)

+ {

+ Buffer fileBuf (dwSize);

+ if (dwSize == diskFile.Read (fileBuf.Ptr (), dwSize))

+ {

+ Buffer efiBuf (dwSize);

+ res = UnzipItem (hz, ze.index, efiBuf.Ptr (), dwSize, ZIP_MEMORY);

+ if (res == ZR_OK)

+ {

+ bMatch = (memcmp (efiBuf.Ptr(), fileBuf.Ptr(), dwSize) == 0);

+ }

+ }

+ }

+ }

+ catch (...)

+ {

+ }

+

+ }

+ else

+ {

+ // entry not found in our Rescue ZIP image. Skip it.

+ bMatch = true;

+ }

+

+ if (!bMatch)

+ break;

+ }

+

+ if (i == ARRAYSIZE(efiFiles))

+ {

+ // All entries processed

+ return true;

+ }

+ }

+ }

+ }

+ catch (...) { }

+ }

+ }

+ else

+ {

+ size_t verifiedSectorCount = (TC_CD_BOOTSECTOR_OFFSET + TC_ORIG_BOOT_LOADER_BACKUP_SECTOR_OFFSET + TC_BOOT_LOADER_AREA_SIZE) / 2048;

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

+ for (WCHAR drive = L'Z'; drive >= L'C'; --drive)

+ try

+ WCHAR rootPath[4] = { drive, L':', L'\\', 0};

+ UINT driveType = GetDriveType (rootPath);

+ // check that it is a CD/DVD drive or a removable media in case a bootable

+ // USB key was created from the rescue disk ISO file

+ if ((DRIVE_CDROM == driveType) || (DRIVE_REMOVABLE == driveType))

+ {

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

+ Device driveDevice (rootPath, true);

+ driveDevice.CheckOpened (SRC_POS);

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

+ if (bytesRead != buffer.Size())

+ continue;

+ if (memcmp (buffer.Ptr(), RescueIsoImage, buffer.Size()) == 0)

+ return true;

+ }

+ catch (...) { }

+ bool BootEncryption::VerifyRescueDiskImage (const wchar_t* imageFile)

+ BOOL bIsGPT = GetSystemDriveConfiguration().SystemPartition.IsGPT;

+ if ((bIsGPT && !RescueZipData) || (!bIsGPT && !RescueIsoImage))

+ if (bIsGPT)

+ try

+ {

+ DWORD dwSize = 0;

+ File rescueFile (imageFile, true);

+ rescueFile.CheckOpened (SRC_POS);

+ rescueFile.GetFileSize (dwSize);

+ Buffer rescueData (dwSize);

+ if (dwSize == rescueFile.Read (rescueData.Ptr (), dwSize))

+ {

+ ZRESULT res;

+ HZIP hzFile = OpenZip(rescueData.Ptr (), dwSize, ZIP_MEMORY);

+ if (hzFile)

+ {

+ finally_do_arg (HZIP, hzFile, { CloseZip (finally_arg); });

+ HZIP hzMem = OpenZip(RescueZipData, RescueZipSize, ZIP_MEMORY);

+ if (hzMem)

+ {

+ finally_do_arg (HZIP, hzMem, { CloseZip (finally_arg); });

+ const wchar_t* efiFiles[] = {

+ L"EFI/Boot/bootx64.efi",

+ L"EFI/VeraCrypt/DcsBml.dcs",

+ L"EFI/VeraCrypt/DcsBoot.efi",

+ L"EFI/VeraCrypt/DcsCfg.dcs",

+ L"EFI/VeraCrypt/DcsInt.dcs",

+ L"EFI/VeraCrypt/LegacySpeaker.dcs",

+ L"EFI/VeraCrypt/svh_bak",

+ L"EFI/Boot/original_bootx64.vc_backup"

+ };

+

+ int index, i;

+ ZIPENTRYW zeFile, zeMem;

+ for (i = 0; i < ARRAYSIZE(efiFiles); i++)

+ {

+ bool bMatch = false;

+ res = FindZipItemW (hzMem, efiFiles[i], true, &index, &zeMem);

+ if ((res == ZR_OK) && (index >= 0))

+ {

+ res = FindZipItemW (hzFile, efiFiles[i], true, &index, &zeFile);

+ if ((res == ZR_OK) && (index >= 0) && (zeMem.unc_size == zeFile.unc_size))

+ {

+ Buffer fileBuf (zeFile.unc_size);

+ Buffer memBuf (zeFile.unc_size);

+

+ res = UnzipItem (hzMem, zeMem.index, memBuf.Ptr (), zeMem.unc_size, ZIP_MEMORY);

+ if (res == ZR_OK)

+ {

+ res = UnzipItem (hzFile, zeFile.index, fileBuf.Ptr (), zeFile.unc_size, ZIP_MEMORY);

+ if (res == ZR_OK)

+ {

+ bMatch = (memcmp (memBuf.Ptr (), fileBuf.Ptr (), zeMem.unc_size) == 0);

+ }

+ }

+ }

+

+ }

+ else

+ {

+ // entry not found in our internal Rescue ZIP image. Skip it.

+ bMatch = true;

+ }

+

+ if (!bMatch)

+ break;

+ }

+

+ if (i == ARRAYSIZE(efiFiles))

+ {

+ // All entries processed

+ return true;

+ }

+

+

+ }

+ }

+ }

+ }

+ catch (...) { }

+ }

+ else

+ {

+ try

+ File rescueFile (imageFile, true);

+ rescueFile.CheckOpened (SRC_POS);

+ size_t verifiedSectorCount = (TC_CD_BOOTSECTOR_OFFSET + TC_ORIG_BOOT_LOADER_BACKUP_SECTOR_OFFSET + TC_BOOT_LOADER_AREA_SIZE) / 2048;

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

+

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

+ if ( (bytesRead == buffer.Size())

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

+ )

+ {

+ return true;

+ }

+ catch (...) { }

+#define VC_EFI_BOOTLOADER_NAME L"DcsBoot"

+

+ if (GetSystemDriveConfiguration().SystemPartition.IsGPT)

+ {

+ if (!IsAdmin()) {

+ if (IsUacSupported())

+ {

+ Elevator::BackupEfiSystemLoader ();

+ return;

+ }

+ else

+ {

+ Warning ("ADMIN_PRIVILEGES_WARN_DEVICES", ParentWindow);

+ }

+ }

+ unsigned __int64 loaderSize = 0;

+ finally_do ({ EfiBootInst.DismountBootPartition(); });

+ EfiBootInst.MountBootPartition(0);

+

+ EfiBootInst.GetFileSize(L"\\EFI\\Boot\\bootx64.efi", loaderSize);

+

+ std::vector<byte> bootLoaderBuf ((size_t) loaderSize);

+

+ EfiBootInst.ReadFile(L"\\EFI\\Boot\\bootx64.efi", &bootLoaderBuf[0], (DWORD) loaderSize);

+

+ // Prevent VeraCrypt EFI loader from being backed up

+ for (size_t i = 0; i < (size_t) loaderSize - (wcslen (VC_EFI_BOOTLOADER_NAME) * 2); ++i)

+ if (memcmp (&bootLoaderBuf[i], VC_EFI_BOOTLOADER_NAME, wcslen (VC_EFI_BOOTLOADER_NAME) * 2) == 0)

+ {

+ if (AskWarnNoYes ("TC_BOOT_LOADER_ALREADY_INSTALLED", ParentWindow) == IDNO)

+ throw UserAbort (SRC_POS);

+ return;

+ }

+

+ EfiBootInst.CopyFile(L"\\EFI\\Boot\\bootx64.efi", GetSystemLoaderBackupPath().c_str());

+ EfiBootInst.CopyFile(L"\\EFI\\Boot\\bootx64.efi", L"\\EFI\\Boot\\original_bootx64.vc_backup");

+ else

+ {

+ Device device (GetSystemDriveConfiguration().DevicePath, true);

+ device.CheckOpened (SRC_POS);

+ byte bootLoaderBuf[TC_BOOT_LOADER_AREA_SECTOR_COUNT * TC_SECTOR_SIZE_BIOS];

+

+ device.SeekAt (0);

+ device.Read (bootLoaderBuf, sizeof (bootLoaderBuf));

+

+ // Prevent TrueCrypt loader from being backed up

+ for (size_t i = 0; i < sizeof (bootLoaderBuf) - strlen (TC_APP_NAME); ++i)

+ {

+ if (memcmp (bootLoaderBuf + i, TC_APP_NAME, strlen (TC_APP_NAME)) == 0)

+ {

+ if (AskWarnNoYes ("TC_BOOT_LOADER_ALREADY_INSTALLED", ParentWindow) == IDNO)

+ throw UserAbort (SRC_POS);

+ return;

+ }

+ }

+ File backupFile (GetSystemLoaderBackupPath(), false, true);

+ backupFile.Write (bootLoaderBuf, sizeof (bootLoaderBuf));

+ }

+ SystemDriveConfiguration config = GetSystemDriveConfiguration();

+ if (config.SystemPartition.IsGPT) {

+ if (!IsAdmin()) {

+ if (IsUacSupported())

+ {

+ Elevator::RestoreEfiSystemLoader ();

+ return;

+ }

+ else

+ {

+ Warning ("ADMIN_PRIVILEGES_WARN_DEVICES", ParentWindow);

+ }

+ }

+ finally_do ({ EfiBootInst.DismountBootPartition(); });

+

+ EfiBootInst.MountBootPartition(0);

+

+ EfiBootInst.DeleteStartExec();

+ EfiBootInst.RenameFile(L"\\EFI\\Boot\\original_bootx64.vc_backup", L"\\EFI\\Boot\\bootx64.efi", TRUE);

+

+ EfiBootInst.DelFile(L"\\DcsBoot.efi");

+ EfiBootInst.DelFile(L"\\DcsInt.efi");

+ EfiBootInst.DelFile(L"\\DcsCfg.efi");

+ EfiBootInst.DelFile(L"\\LegacySpeaker.efi");

+ EfiBootInst.DelFile(L"\\DcsBoot");

+ EfiBootInst.DelFile(L"\\DcsProp");

+ EfiBootInst.DelFile(L"\\EFI\\VeraCrypt\\DcsBoot.efi");

+ EfiBootInst.DelFile(L"\\EFI\\VeraCrypt\\DcsInt.dcs");

+ EfiBootInst.DelFile(L"\\EFI\\VeraCrypt\\DcsCfg.dcs");

+ EfiBootInst.DelFile(L"\\EFI\\VeraCrypt\\LegacySpeaker.dcs");

+ EfiBootInst.DelFile(L"\\EFI\\VeraCrypt\\DcsBml.dcs");

+ EfiBootInst.DelFile(L"\\EFI\\VeraCrypt\\DcsBoot");

+ EfiBootInst.DelFile(L"\\EFI\\VeraCrypt\\DcsProp");

+ }

+ else

+ {

+ byte bootLoaderBuf[TC_BOOT_LOADER_AREA_SECTOR_COUNT * TC_SECTOR_SIZE_BIOS];

+ File backupFile (GetSystemLoaderBackupPath(), true);

+ backupFile.CheckOpened(SRC_POS);

+ if (backupFile.Read (bootLoaderBuf, sizeof (bootLoaderBuf)) != sizeof (bootLoaderBuf))

+ throw ParameterIncorrect (SRC_POS);

+ Device device (GetSystemDriveConfiguration().DevicePath);

+ device.CheckOpened (SRC_POS);

+ // Preserve current partition table

+ byte mbr[TC_SECTOR_SIZE_BIOS];

+ device.SeekAt (0);

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

+ memcpy (bootLoaderBuf + TC_MAX_MBR_BOOT_CODE_SIZE, mbr + TC_MAX_MBR_BOOT_CODE_SIZE, sizeof (mbr) - TC_MAX_MBR_BOOT_CODE_SIZE);

+

+ device.SeekAt (0);

+ device.Write (bootLoaderBuf, sizeof (bootLoaderBuf));

+ }

+ void BootEncryption::GetEfiBootDeviceNumber (PSTORAGE_DEVICE_NUMBER pSdn)

+ {

+ SystemDriveConfiguration config = GetSystemDriveConfiguration ();

+ if (config.SystemPartition.IsGPT && pSdn)

+ {

+ if (!IsAdmin() && IsUacSupported())

+ {

+ Elevator::GetEfiBootDeviceNumber (pSdn);

+ }

+ else

+ {

+ finally_do ({ EfiBootInst.DismountBootPartition(); });

+ EfiBootInst.MountBootPartition(0);

+ memcpy (pSdn, EfiBootInst.GetStorageDeviceNumber(), sizeof (STORAGE_DEVICE_NUMBER));

+ }

+ }

+ else

+ {

+ SetLastError (ERROR_INVALID_PARAMETER);

+ throw SystemException (SRC_POS);

+ }

+ }

+

+

+ if (config.SystemPartition.IsGPT && !Is64BitOs())

+ if (config.SystemPartition.IsGPT)

+ {

+ STORAGE_DEVICE_NUMBER sdn;

+ GetEfiBootDeviceNumber (&sdn);

+ activePartitionFound = (config.DriveNumber == (int) sdn.DeviceNumber);

+ }

+ else

+ if (AskWarnYesNoString ((wchar_t *) (wstring (GetString ("PAGING_FILE_NOT_ON_SYS_PARTITION"))

+ throw ErrorException (wstring (GetString ("PAGING_FILE_NOT_ON_SYS_PARTITION"))

+ throw ErrorException (wstring (GetString ("USER_PROFILE_NOT_ON_SYS_PARTITION"))

+ throw ErrorException (wstring (GetString ("TEMP_NOT_ON_SYS_PARTITION"))

+ if (!config.SystemPartition.IsGPT) {

+ if (encStatus.VolumeHeaderPresent)

+ {

+ // Verify CRC of header salt

+ Device device(config.DevicePath, true);

+ device.CheckOpened(SRC_POS);

+ byte header[TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE];

+ device.SeekAt(TC_BOOT_VOLUME_HEADER_SECTOR_OFFSET);

+ device.Read(header, sizeof(header));

+ if (encStatus.VolumeHeaderSaltCrc32 != GetCrc32((byte *)header, PKCS5_SALT_SIZE))

+ throw ParameterIncorrect(SRC_POS);

+ }

+ }

+

+ /* The header will be re-encrypted wipePassCount times to prevent adversaries from using

+ byte userConfig = 0;

+ if ( ReadBootSectorConfig (nullptr, 0, &userConfig)

+ && (userConfig & TC_BOOT_USER_CFG_FLAG_DISABLE_PIM)

+ )

+ {

+ }

+ {

+ }

+ InstallBootLoader (device, true, false, pim, cryptoInfo->pkcs5);

+ void BootEncryption::Install (bool hiddenSystem, int hashAlgo)

+ InstallBootLoader (false, hiddenSystem, -1, hashAlgo);

+

+

+

+ Modifications and additions to the original source code (contained in this file)

+#include <Winternl.h>

+

+#define SYSPARTITIONINFORMATION 0x62

+

+typedef NTSTATUS (WINAPI *NtQuerySystemInformationFn)(

+ SYSTEM_INFORMATION_CLASS SystemInformationClass,

+ PVOID SystemInformation,

+ ULONG SystemInformationLength,

+ PULONG ReturnLength

+);

+ File () : Elevated (false), FileOpen (false), ReadOnly (false), FilePointerPosition(0), Handle(INVALID_HANDLE_VALUE), IsDevice(false), LastError(0) { }

+ void GetFileSize (unsigned __int64& size);

+ void GetFileSize (DWORD& dwSize);

+ bool IoCtl(DWORD code, void* inBuf, DWORD inBufSize, void* outBuf, DWORD outBufSize);

+ bool ReadOnly;

+ class EfiBootConf

+ {

+ public:

+

+ int passwordType;

+ string passwordMsg;

+ string passwordPicture;

+ string hashMsg;

+ int hashAlgo;

+ int requestHash;

+ string pimMsg;

+ int pim;

+ int requestPim;

+ int authorizeVisible;

+ int authorizeRetry;

+

+ EfiBootConf();

+

+ static BOOL ReadConfigValue (char* configContent, const char *configKey, char *configValue, int maxValueSize);

+ static int ReadConfigInteger (char* configContent, const char *configKey, int defaultValue);

+ static char *ReadConfigString (char* configContent, const char *configKey, char *defaultValue, char *str, int maxLen);

+ static BOOL WriteConfigString (FILE* configFile, char* configContent, const char *configKey, const char *configValue);

+ static BOOL WriteConfigInteger (FILE* configFile, char* configContent, const char *configKey, int configValue);

+ BOOL Load (const wchar_t* fileName);

+ void Load (char* configContent);

+ BOOL Save (const wchar_t* fileName, HWND hwnd);

+ };

+

+ class EfiBoot {

+ public:

+ EfiBoot();

+

+ void MountBootPartition(WCHAR letter);

+ void DismountBootPartition();

+ bool IsEfiBoot();

+

+ void DeleteStartExec(uint16 statrtOrderNum = 0xDC5B, wchar_t* type = NULL);

+ void SetStartExec(wstring description, wstring execPath, uint16 statrtOrderNum = 0xDC5B, wchar_t* type = NULL, uint32 attr = 1);

+ void SaveFile(wchar_t* name, byte* data, DWORD size);

+ void GetFileSize(const wchar_t* name, unsigned __int64& size);

+ void ReadFile(const wchar_t* name, byte* data, DWORD size);

+ void CopyFile(const wchar_t* name, const wchar_t* targetName);

+

+ BOOL RenameFile(wchar_t* name, wchar_t* nameNew, BOOL bForce);

+ BOOL DelFile(wchar_t* name);

+ BOOL MkDir(wchar_t* name, bool& bAlreadyExists);

+ BOOL ReadConfig (wchar_t* name, EfiBootConf& conf);

+ BOOL UpdateConfig (wchar_t* name, int pim, int hashAlgo, HWND hwndDlg);

+ BOOL WriteConfig (wchar_t* name, bool preserveUserConfig, int pim, int hashAlgo, const char* passPromptMsg, HWND hwndDlg);

+

+ PSTORAGE_DEVICE_NUMBER GetStorageDeviceNumber () { return &sdn;}

+

+ protected:

+ bool m_bMounted;

+ WCHAR EfiBootPartPath[3];

+ STORAGE_DEVICE_NUMBER sdn;

+ PARTITION_INFORMATION_EX partInfo;

+ WCHAR tempBuf[1024];

+ WCHAR systemPartitionPath[MAX_PATH];

+ };

+

+ void Install (bool hiddenSystem, int hashAlgo);

+ void InstallBootLoader (Device& device, bool preserveUserConfig = false, bool hiddenOSCreation = false, int pim = -1, int hashAlg = -1);

+ void InstallBootLoader (bool preserveUserConfig = false, bool hiddenOSCreation = false, int pim = -1, int hashAlg = -1);

+ bool ReadBootSectorConfig (byte *config, size_t bufLength, byte *userConfig = nullptr, string *customUserMessage = nullptr, uint16 *bootLoaderVersion = nullptr);

+ void ReadEfiConfig (byte* confContent, DWORD maxSize, DWORD* pcbRead);

+ bool VerifyRescueDiskImage (const wchar_t* imageFile);

+ void WriteBootSectorUserConfig (byte userConfig, const string &customUserMessage, int pim, int hashAlg);

+ void WriteEfiBootSectorUserConfig (byte userConfig, const string &customUserMessage, int pim, int hashAlg);

+ void GetEfiBootDeviceNumber (PSTORAGE_DEVICE_NUMBER pSdn);

+ void BackupSystemLoader ();

+ void RestoreSystemLoader ();

+ void RegisterFilter (bool registerFilter, FilterType filterType, const GUID *deviceClassGuid = nullptr);

+ byte *RescueZipData;

+ unsigned long RescueZipSize;

+IDD_BENCHMARK_DLG DIALOGEX 0, 0, 330, 247

+CAPTION "VeraCrypt - Algorithms Benchmark"

+ COMBOBOX IDC_BENCHMARK_LIST,55,11,87,53,CBS_DROPDOWNLIST | CBS_AUTOHSCROLL | WS_VSCROLL | WS_TABSTOP

+ COMBOBOX IDC_BENCHMARK_BUFFER_SIZE,209,11,87,129,CBS_DROPDOWNLIST | CBS_AUTOHSCROLL | WS_VSCROLL | WS_TABSTOP

+ EDITTEXT IDC_PIM,209,11,42,14,ES_RIGHT | ES_AUTOHSCROLL | ES_NUMBER | NOT WS_VISIBLE

+ CONTROL "Pre-Boot",IDC_BENCHMARK_PREBOOT,"Button",BS_AUTOCHECKBOX | NOT WS_VISIBLE | WS_TABSTOP,258,14,71,10

+ COMBOBOX IDC_BENCHMARK_SORT_METHOD,55,40,139,74,CBS_DROPDOWNLIST | CBS_AUTOHSCROLL | WS_VSCROLL | WS_TABSTOP

+ DEFPUSHBUTTON "Benchmark",IDC_PERFORM_BENCHMARK,265,60,58,14

+ PUSHBUTTON "Close",IDCLOSE,265,79,58,14

+ CONTROL "",IDC_RESULTS,"SysListView32",LVS_REPORT | LVS_SINGLESEL | LVS_SHOWSELALWAYS | LVS_ALIGNLEFT | LVS_NOSORTHEADER | WS_BORDER | WS_TABSTOP,7,60,249,160

+ LTEXT "Hardware-accelerated AES:",IDC_HW_AES_LABEL_LINK,148,233,108,9,SS_NOTIFY,WS_EX_RIGHT

+ CONTROL "",IDC_HW_AES,"Static",SS_LEFTNOWORDWRAP | WS_GROUP,262,232,57,11,WS_EX_STATICEDGE

+ LTEXT "Parallelization:",IDC_PARALLELIZATION_LABEL_LINK,4,233,67,9,SS_NOTIFY,WS_EX_RIGHT

+ CONTROL "",IDC_PARALLELIZATION,"Static",SS_LEFTNOWORDWRAP | WS_GROUP,77,232,57,11,WS_EX_STATICEDGE

+ CONTROL "",IDC_STATIC,"Static",SS_ETCHEDHORZ,2,32,328,1,WS_EX_STATICEDGE

+ LTEXT "Buffer Size:",IDT_BUFFER_SIZE,154,14,53,8,0,WS_EX_RIGHT

+ LTEXT "Sort Method:",IDT_SORT_METHOD,0,42,53,8,0,WS_EX_RIGHT

+ LTEXT "Speed is affected by CPU load and storage device characteristics.\n\nThese tests take place in RAM.",IDT_BOX_BENCHMARK_INFO,266,107,57,100

+ CONTROL "",IDC_STATIC,"Static",SS_ETCHEDHORZ,2,228,328,1,WS_EX_STATICEDGE

+ LTEXT "Benchmark: ",IDT_BENCHMARK,0,14,53,8,0,WS_EX_RIGHT

+ RTEXT "Volume PIM:",IDT_PIM,154,14,53,8,NOT WS_VISIBLE

+ BOTTOMMARGIN, 240

+IDR_BOOT_SECTOR_CAMELLIA BIN "..\\Boot\\Windows\\Release_Camellia\\BootSector.bin"

+IDR_BOOT_LOADER_CAMELLIA BIN "..\\Boot\\Windows\\Release_Camellia\\BootLoader.com.gz"

+IDR_BOOT_SECTOR_CAMELLIA_SHA2 BIN "..\\Boot\\Windows\\Release_Camellia_SHA2\\BootSector.bin"

+IDR_BOOT_LOADER_CAMELLIA_SHA2 BIN "..\\Boot\\Windows\\Release_Camellia_SHA2\\BootLoader.com.gz"

+IDR_RESCUE_BOOT_SECTOR_CAMELLIA BIN "..\\Boot\\Windows\\Rescue_Camellia\\BootSector.bin"

+IDR_RESCUE_LOADER_CAMELLIA BIN "..\\Boot\\Windows\\Rescue_Camellia\\BootLoader.com.gz"

+IDR_RESCUE_BOOT_SECTOR_CAMELLIA_SHA2 BIN "..\\Boot\\Windows\\Rescue_Camellia_SHA2\\BootSector.bin"

+IDR_RESCUE_LOADER_CAMELLIA_SHA2 BIN "..\\Boot\\Windows\\Rescue_Camellia_SHA2\\BootLoader.com.gz"

+IDR_EFI_DCSBOOT BIN "..\\Boot\\EFI\\DcsBoot.efi"

+IDR_EFI_DCSINT BIN "..\\Boot\\EFI\\DcsInt.efi"

+IDR_EFI_DCSCFG BIN "..\\Boot\\EFI\\DcsCfg.efi"

+IDR_EFI_LEGACYSPEAKER BIN "..\\Boot\\EFI\\LegacySpeaker.efi"

+IDR_EFI_DCSBML BIN "..\\Boot\\EFI\\DcsBml.efi"

+IDR_EFI_DCSRE BIN "..\\Boot\\EFI\\DcsRe.efi"

+1 TEXTINCLUDE

+2 TEXTINCLUDE

+3 TEXTINCLUDE

+ derived from the source code of TrueCrypt 7.1a, which is

+ Copyright (c) 2003-2012 TrueCrypt Developers Association and which is

+ and which is governed by the 'License Agreement for Encryption for the Masses'

+ Modifications and additions to the original source code (contained in this file)

+#if !defined(_UEFI)

+#endif

+#include "cpu.h"

+#pragma warning (disable:4706) // assignment within conditional expression

+ { CAMELLIA, L"Camellia", 16, 32, CAMELLIA_KS },

+#if defined(CIPHER_GOST89)

+ { GOST89, L"GOST89", 16, 32, GOST_KS },

+#endif // defined(CIPHER_GOST89)

+ { KUZNYECHIK, L"Kuznyechik",16, 32, KUZNYECHIK_KS },

+ { { 0, 0 }, { 0, 0}, 0, 0 }, // Must be all-zero

+ { { AES, 0 }, { XTS, 0 }, 1, 1 },

+ { { SERPENT, 0 }, { XTS, 0 }, 1, 1 },

+ { { TWOFISH, 0 }, { XTS, 0 }, 1, 1 },

+ { { CAMELLIA, 0 }, { XTS, 0 }, 1, 1 },

+#if defined(CIPHER_GOST89)

+ { { GOST89, 0 }, { XTS, 0 }, 0, 1 },

+#endif // defined(CIPHER_GOST89)

+ { { KUZNYECHIK, 0 }, { XTS, 0 }, 0, 1 },

+ { { TWOFISH, AES, 0 }, { XTS, 0 }, 1, 1 },

+ { { SERPENT, TWOFISH, AES, 0 }, { XTS, 0 }, 1, 1 },

+ { { AES, SERPENT, 0 }, { XTS, 0 }, 1, 1 },

+ { { AES, TWOFISH, SERPENT, 0 }, { XTS, 0 }, 1, 1 },

+ { { SERPENT, TWOFISH, 0 }, { XTS, 0 }, 1, 1 },

+ { { 0, 0 }, { 0, 0}, 0, 0 } // Must be all-zero

+{ // ID Name Deprecated System Encryption

+ { SHA512, L"SHA-512", FALSE, FALSE },

+ { WHIRLPOOL, L"Whirlpool", FALSE, FALSE },

+ { SHA256, L"SHA-256", FALSE, TRUE },

+ { RIPEMD160, L"RIPEMD-160", TRUE, TRUE },

+ { STREEBOG, L"Streebog", FALSE, FALSE },

+

+#if !defined (TC_WINDOWS_BOOT) || defined (TC_WINDOWS_BOOT_CAMELLIA)

+ case CAMELLIA:

+ camellia_set_key (key, ks);

+ break;

+#endif

+

+#if !defined(TC_WINDOWS_BOOT)

+#if defined(CIPHER_GOST89)

+ case GOST89:

+ gost_set_key(key, (gost_kds*)ks);

+ break;

+#endif // && defined(CIPHER_GOST89)

+ case KUZNYECHIK:

+ kuznyechik_set_key(key, (kuznyechik_kds*)ks);

+ break;

+#endif // !defined(TC_WINDOWS_BOOT)

+

+ case AES:

+#if !defined (TC_WINDOWS_BOOT) || defined (TC_WINDOWS_BOOT_CAMELLIA)

+ case CAMELLIA: camellia_encrypt (data, data, ks); break;

+#endif

+#if !defined(TC_WINDOWS_BOOT)

+#if defined(CIPHER_GOST89)

+ case GOST89: gost_encrypt(data, data, ks, 1); break;

+#endif // defined(CIPHER_GOST89)

+ case KUZNYECHIK: kuznyechik_encrypt_block(data, data, ks); break;

+#endif // !defined(TC_WINDOWS_BOOT)

+ else if (cipher == GOST89) {

+ gost_encrypt(data, data, ks, (int)blockCount);

+ }

+#if !defined (TC_WINDOWS_BOOT) || defined (TC_WINDOWS_BOOT_CAMELLIA)

+ case CAMELLIA: camellia_decrypt (data, data, ks); break;

+#endif

+#if !defined(TC_WINDOWS_BOOT)

+#if defined(CIPHER_GOST89)

+ case GOST89: gost_decrypt(data, data, ks, 1); break;

+#endif // defined(CIPHER_GOST89)

+ case KUZNYECHIK: kuznyechik_decrypt_block(data, data, ks); break;

+#endif // !defined(TC_WINDOWS_BOOT)

+

+

+ else if (cipher == GOST89) {

+ gost_decrypt(data, data, ks, (int)blockCount);

+ }

+ return cipher == AES && IsAesHwCpuSupported() ||

+ cipher == GOST89;

+ to create approximately 11,378,125,361,078,862 (about eleven quadrillion) TrueCrypt volumes (provided

+ default:

+ EAGetName(n, ea, 1);

+#if defined(_UEFI)

+ if (wcscmp(n, name) == 0)

+#else

+ if (_wcsicmp(n, name) == 0)

+#endif

+ if (c == previousModeId)

+ if (c == previousCipherId)

+ if (c == previousCipherId)

+#ifndef TC_WINDOWS_BOOT

+int EAIsMbrSysEncEnabled (int ea)

+{

+ return EncryptionAlgorithms[ea].MbrSysEncEnabled;

+}

+#endif

+#if !defined(DEVICE_DRIVER) && !defined(_UEFI)

+#if !defined(DEVICE_DRIVER) && !defined(_UEFI)

+// len: number of bytes to encrypt; must be divisible by the block size (for cascaded ciphers, divisible

+ default:

+#if !defined(TC_WINDOWS_BOOT) && !defined(_UEFI)

+ default:

+// len: number of bytes to decrypt; must be divisible by the block size (for cascaded ciphers, divisible

+ default:

+#if !defined(TC_WINDOWS_BOOT) && !defined(_UEFI)

+ default:

+#if !defined (TC_WINDOWS_BOOT_AES) && !defined (TC_WINDOWS_BOOT_SERPENT) && !defined (TC_WINDOWS_BOOT_TWOFISH) && !defined (TC_WINDOWS_BOOT_CAMELLIA)

+ aes_encrypt (data, data, ks);

+#elif defined (TC_WINDOWS_BOOT_CAMELLIA)

+ camellia_encrypt (data, data, ks);

+ aes_decrypt (data, data, (aes_decrypt_ctx *) ((byte *) ks + sizeof(aes_encrypt_ctx)));

+#elif defined (TC_WINDOWS_BOOT_CAMELLIA)

+ camellia_decrypt (data, data, ks);

+#ifdef TC_WINDOWS_BOOT_AES

+#else

+ state = g_hasAESNI ? TRUE : FALSE;

+#endif

+ derived from the source code of TrueCrypt 7.1a, which is

+ Copyright (c) 2003-2012 TrueCrypt Developers Association and which is

+ and which is governed by the 'License Agreement for Encryption for the Masses'

+ Modifications and additions to the original source code (contained in this file)

+#define FIRST_PRF_ID 1

+// Hash algorithms (pseudorandom functions).

+ STREEBOG,

+#define LAST_PRF_ID (HASH_ENUM_END_ID - 1)

+#define STREEBOG_BLOCKSIZE 64

+#define STREEBOG_DIGESTSIZE 64

+

+ SERPENT,

+ TWOFISH,

+ CAMELLIA,

+ GOST89,

+ KUZNYECHIK

+#ifndef TC_WINDOWS_BOOT

+ BOOL MbrSysEncEnabled;

+#endif

+# elif defined (TC_WINDOWS_BOOT_CAMELLIA)

+# define MAX_EXPANDED_KEY CAMELLIA_KS

+#ifdef TC_WINDOWS_BOOT

+#define MAX_EXPANDED_KEY max((AES_KS + SERPENT_KS + TWOFISH_KS), CAMELLIA_KS)

+#else

+#define MAX_EXPANDED_KEY max(max(max((AES_KS + SERPENT_KS + TWOFISH_KS), GOST_KS), CAMELLIA_KS), KUZNYECHIK_KS)

+#endif

+# include "Streebog.h"

+# include "GostCipher.h"

+# include "kuznyechik.h"

+# include "Camellia.h"

+#else

+# include "CamelliaSmall.h"

+ CRYPTOPP_ALIGN_DATA(16) __int8 master_keydata[MASTER_KEYDATA_SIZE]; /* Concatenated master primary and secondary key(s) (XTS mode). For LRW (deprecated/legacy), it contains the tweak key before the master key(s). For CBC (deprecated/legacy), it contains the IV seed before the master key(s). */

+ GfCtx gf_ctx;

+ CRYPTOPP_ALIGN_DATA(16) unsigned __int8 master_keydata[MASTER_KEYDATA_SIZE]; /* This holds the volume header area containing concatenated master key(s) and secondary key(s) (XTS mode). For LRW (deprecated/legacy), it contains the tweak key before the master key(s). For CBC (deprecated/legacy), it contains the IV seed before the master key(s). */

+ CRYPTOPP_ALIGN_DATA(16) 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. */

+ int noIterations;

+

+#if defined(_WIN32) || defined(_UEFI)

+#ifndef TC_WINDOWS_BOOT

+int EAIsMbrSysEncEnabled (int ea);

+#endif

+ derived from the source code of TrueCrypt 7.1a, which is

+ Copyright (c) 2003-2012 TrueCrypt Developers Association and which is

+ and which is governed by the 'License Agreement for Encryption for the Masses'

+ Modifications and additions to the original source code (contained in this file)

+char CmdTokenPin [TC_MAX_PATH] = {0};

+// Status of detection of hidden sectors (whole-system-drive encryption).

+int HiddenSectorDetectionStatus = 0;

+/* Globals used by Mount and Format (separately per instance) */

+volatile HANDLE hSysEncMutex = NULL;

+int SystemEncryptionStatus = SYSENC_STATUS_NONE;

+#ifndef BASE_SEARCH_PATH_ENABLE_SAFE_SEARCHMODE

+#define BASE_SEARCH_PATH_ENABLE_SAFE_SEARCHMODE 0x00000001

+#endif

+

+#ifndef BASE_SEARCH_PATH_PERMANENT

+#define BASE_SEARCH_PATH_PERMANENT 0x00008000

+#endif

+

+#ifndef LOAD_LIBRARY_SEARCH_SYSTEM32

+#define LOAD_LIBRARY_SEARCH_SYSTEM32 0x00000800

+#endif

+

+typedef BOOL (WINAPI *SetDllDirectoryPtr)(LPCWSTR lpPathName);

+typedef BOOL (WINAPI *SetSearchPathModePtr)(DWORD Flags);

+typedef BOOL (WINAPI *SetDefaultDllDirectoriesPtr)(DWORD DirectoryFlags);

+

+

+SetDllDirectoryPtr SetDllDirectoryFn = NULL;

+SetSearchPathModePtr SetSearchPathModeFn = NULL;

+SetDefaultDllDirectoriesPtr SetDefaultDllDirectoriesFn = NULL;

+

+enum

+{

+ BENCHMARK_TYPE_ENCRYPTION = 0,

+ BENCHMARK_TYPE_PRF,

+ BENCHMARK_TYPE_HASH

+};

+

+enum

+typedef struct

+int benchmarkType = BENCHMARK_TYPE_ENCRYPTION;

+int benchmarkPim = -1;

+BOOL benchmarkPreBoot = FALSE;

+BOOL benchmarkGPT = FALSE;

+typedef struct

+ burn (&CmdTokenPin, sizeof (CmdTokenPin));

+

+ // Unload driver mode if possible (non-install mode)

+ DWORD dwError = GetLastError ();

+ HDC hdc = GetDC (hwndDlgItem);

+ ReleaseDC (hwndDlgItem, hdc);

+ HDC hdc = GetDC (hwndDlgItem);

+ ReleaseDC (hwndDlgItem, hdc);

+ HDC hdc = GetDC (hwnd);

+ ReleaseDC (hwnd, hdc);

+ GetClientRect (hwndCtrl, &rec);

+ && (!bFirstUpdate || origWidth > width)) // The original width of the field is the maximum allowed size

+

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

+ ReleaseDC (hwndDlg, hDC);

+ // Windows skews the GUI aspect ratio if the user has a non-default DPI. Hence, working with

+ // Resize the logo bitmap if the user has a non-default DPI

+ int msgCounter = maxMessagesToProcess;

+/* Renders the specified bitmap at the specified location and stretches it to fit (anti-aliasing is applied).

+both directions depending on the DPI). If bDirectRender is TRUE, bKeepAspectRatio is ignored.

+deleted by calling DeleteObject() with the handle passed as the parameter.

+Known Windows issues:

+- For some reason, anti-aliasing is not applied if the source bitmap contains less than 16K pixels.

+ hdcRescaled = CreateCompatibleDC (hdcSrc);

+ hbmpRescaled = CreateCompatibleBitmap (hdcSrc, nWidth, nHeight);

+ bitmap.bmWidth,

+ wc.lpfnWndProc = &RedTick;

+

+ AddComboPair (hComboBox, GetString ("WIPE_MODE_NONE"), TC_WIPE_NONE);

+

+BOOL LaunchElevatedProcess (HWND hwndDlg, const wchar_t* szModPath, const wchar_t* args)

+{

+ wchar_t newCmdLine[4096];

+ WNDCLASSEXW wcex;

+ HWND hWnd;

+

+ memset (&wcex, 0, sizeof (wcex));

+ wcex.cbSize = sizeof(WNDCLASSEX);

+ wcex.lpfnWndProc = (WNDPROC) NonInstallUacWndProc;

+ wcex.hInstance = hInst;

+ wcex.lpszClassName = L"VeraCrypt";

+ RegisterClassExW (&wcex);

+

+ // A small transparent window is necessary to bring the new instance to foreground

+ hWnd = CreateWindowExW (WS_EX_TOOLWINDOW | WS_EX_LAYERED,

+ L"VeraCrypt", L"VeraCrypt", 0,

+ GetSystemMetrics (SM_CXSCREEN)/2,

+ GetSystemMetrics (SM_CYSCREEN)/2,

+ 1, 1, NULL, NULL, hInst, NULL);

+

+ SetLayeredWindowAttributes (hWnd, 0, 0, LWA_ALPHA);

+ ShowWindow (hWnd, SW_SHOWNORMAL);

+

+ StringCbCopyW (newCmdLine, sizeof(newCmdLine), L"/q UAC ");

+ StringCbCatW (newCmdLine, sizeof (newCmdLine), args);

+

+ if ((int)ShellExecuteW (hWnd, L"runas", szModPath, newCmdLine, NULL, SW_SHOWNORMAL) <= 32)

+ {

+ if (hwndDlg)

+ handleWin32Error (hwndDlg, SRC_POS);

+ return FALSE;

+ }

+ else

+ {

+ Sleep (2000);

+ return TRUE;

+ }

+}

+

+// Returns TRUE if the mutex is (or had been) successfully acquired (otherwise FALSE).

+// Returns TRUE if the mutex is (or had been) successfully acquired (otherwise FALSE).

+ return (!InstanceHasNonSysInplaceEncMutex ()

+// Returns TRUE if the mutex is (or had been) successfully acquired (otherwise FALSE).

+// Returns TRUE if the mutex is (or had been) successfully acquired (otherwise FALSE).

+// Returns TRUE if a process running on the system has the specified mutex (otherwise FALSE).

+ return TRUE;

+ char langId[6];

+ InitCommonControlsPtr InitCommonControlsFn = NULL;

+

+ /* remove current directory from dll search path */

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

+ SetSearchPathModeFn = (SetSearchPathModePtr) GetProcAddress (GetModuleHandle(L"kernel32.dll"), "SetSearchPathMode");

+ SetDefaultDllDirectoriesFn = (SetDefaultDllDirectoriesPtr) GetProcAddress (GetModuleHandle(L"kernel32.dll"), "SetDefaultDllDirectories");

+ if (SetDllDirectoryFn)

+ SetDllDirectoryFn (L"");

+ if (SetSearchPathModeFn)

+ SetSearchPathModeFn (BASE_SEARCH_PATH_ENABLE_SAFE_SEARCHMODE | BASE_SEARCH_PATH_PERMANENT);

+ if (SetDefaultDllDirectoriesFn)

+ SetDefaultDllDirectoriesFn (LOAD_LIBRARY_SEARCH_SYSTEM32);

+

+ InitOSVersionInfo();

+

+ VirtualLock (&CmdTokenPin, sizeof (CmdTokenPin));

+ if (IsOSAtLeast (WIN_7))

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

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

+ LoadSystemDll (L"msls31.dll", &hMsls31, TRUE, SRC_POS);

+ LoadSystemDll (L"SHLWAPI.DLL", &hShlwapiDll, FALSE, SRC_POS);

+ {

+ {

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

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

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

+ LoadSystemDll (L"bcryptprimitives.dll", &hbcryptprimitivesdll, TRUE, SRC_POS);

+ }

+

+

+ wchar_t modPath[MAX_PATH];

+ if (LaunchElevatedProcess (NULL, modPath, lpszCommandLine))

+ exit (0);

+ else

+

+ if ( bResult

+

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

+ a dangerous operation (such as header backup restore or formatting a supposedly non-system device) never

+ at WM_INITDIALOG or any other GUI events -- instead call IsSystemDevicePath (path, hwndDlg, FALSE) for

+ very fast preliminary GUI checks; also note that right after the "Select Device" dialog exits with an OK

+ || wcslen (SysPartitionDevicePath) <= 1

+ StringCchCopyW (device.IsPartition ? SysPartitionDevicePath : SysDriveDevicePath, TC_MAX_PATH, device.Path.c_str());

+ return (bCachedSysDevicePathsValid

+ && wcslen (SysPartitionDevicePath) > 1

+/* Determines whether the device path is the path of the system partition or of the system drive (or neither).

+If bReliableRequired is TRUE, very fast execution is guaranteed, but the results cannot be relied upon.

+ operation (such as header backup restore or formatting a supposedly non-system device) never at

+ WM_INITDIALOG or any other GUI events (use IsSystemDevicePath(path, hwndDlg, FALSE) for fast

+ preliminary GUI checks; also note that right after the "Select Device" dialog exits with an OK

+is ignored (TRUE implied), repeated executions complete very fast, and the results are always reliable.

+ only before performing a dangerous operation, never at WM_INITDIALOG or any other GUI events.

+0 - it isn't a non-system partition on the system drive

+1 - it's a non-system partition on the system drive

+ // It is a non-system partition on the system drive

+ else

+ // The partition is not on the system drive

+ LVS_EX_FULLROWSELECT|LVS_EX_HEADERDRAGDROP|LVS_EX_TWOCLICKACTIVATE|LVS_EX_LABELTIP

+ );

+ memset (&LvCol,0,sizeof(LvCol));

+ LvCol.mask = LVCF_TEXT|LVCF_WIDTH|LVCF_SUBITEM|LVCF_FMT;

+ LvCol.pszText = GetString ("DRIVE");

+ if (!device.Floppy && (device.Size == 0)

+ item.iItem = line++;

+ item.iItem = line++;

+ memset(&LvItem,0,sizeof(LvItem));

+ LvItem.mask = LVIF_TEXT | LVIF_PARAM;

+ return 1; // non-device line selected

+ // Disallow format if the device contains partitions, but not if the partition is virtual or system

+ else

+

+ goto start;

+ // active, but the driver is not running. This may happen e.g. when the pretest fails and

+

+

+

+static int CALLBACK BrowseCallbackProc(HWND hwnd,UINT uMsg,LPARAM lp, LPARAM pData)

+ case BFFM_INITIALIZED:

+ case BFFM_SELCHANGED:

+ if (SHGetPathFromIDList((LPITEMIDLIST) lp ,szDir))

+ if (SUCCEEDED (SHGetMalloc (&pMalloc)))

+ if (pidl != NULL)

+ if (SHGetPathFromIDList(pidl, dirName))

+

+

+ StringCbPrintfW (wszRegPath, sizeof (wszRegPath), L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\DriveIcons\\%s\\DefaultLabel", driveStr);

+

+ lStatus = RegCreateKeyExW (HKEY_CURRENT_USER, wszRegPath, NULL, NULL, 0,

+ StringCbPrintfW (wszRegPath, sizeof (wszRegPath), L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\DriveIcons\\%s", driveStr);

+ versionString.erase (versionString.length()-1, 1);

+

+

+static void ResetBenchmarkList (HWND hwndDlg)

+{

+ LVCOLUMNW LvCol;

+

+ HWND hList = GetDlgItem (hwndDlg, IDC_RESULTS);

+

+ /* Render the results */

+ // delete data

+ SendMessage (hList, LVM_DELETEALLITEMS, 0, 0);

+ // Delete headers

+ SendMessageW (hList, LVM_DELETECOLUMN, 1, 0);

+ SendMessageW (hList, LVM_DELETECOLUMN, 1, 0);

+ SendMessageW (hList, LVM_DELETECOLUMN, 1, 0);

+

+ memset (&LvCol,0,sizeof(LvCol));

+ LvCol.mask = LVCF_TEXT|LVCF_WIDTH|LVCF_SUBITEM|LVCF_FMT;

+ switch(benchmarkType) {

+ case BENCHMARK_TYPE_ENCRYPTION:

+ // Create headers

+ LvCol.pszText = GetString ("ENCRYPTION");

+ LvCol.cx = CompensateXDPI (80);

+ LvCol.fmt = LVCFMT_RIGHT;

+ SendMessageW (hList,LVM_INSERTCOLUMNW,1,(LPARAM)&LvCol);

+

+ LvCol.pszText = GetString ("DECRYPTION");

+ LvCol.cx = CompensateXDPI (80);

+ LvCol.fmt = LVCFMT_RIGHT;

+ SendMessageW (hList,LVM_INSERTCOLUMNW,2,(LPARAM)&LvCol);

+

+ LvCol.pszText = GetString ("MEAN");

+ LvCol.cx = CompensateXDPI (80);

+ LvCol.fmt = LVCFMT_RIGHT;

+ SendMessageW (hList,LVM_INSERTCOLUMNW,3,(LPARAM)&LvCol);

+ break;

+ case BENCHMARK_TYPE_HASH:

+ LvCol.pszText = GetString ("MEAN");

+ LvCol.cx = CompensateXDPI (80);

+ LvCol.fmt = LVCFMT_RIGHT;

+ SendMessageW (hList,LVM_INSERTCOLUMNW,1,(LPARAM)&LvCol);

+ break;

+ case BENCHMARK_TYPE_PRF:

+ LvCol.pszText = GetString ("TIME");

+ LvCol.cx = CompensateXDPI (80);

+ LvCol.fmt = LVCFMT_RIGHT;

+ SendMessageW (hList,LVM_INSERTCOLUMNW,1,(LPARAM)&LvCol);

+

+ LvCol.pszText = GetString ("ITERATIONS");

+ LvCol.cx = CompensateXDPI (80);

+ LvCol.fmt = LVCFMT_RIGHT;

+ SendMessageW (hList,LVM_INSERTCOLUMNW,2,(LPARAM)&LvCol);

+ break;

+ }

+}

+

+ ResetBenchmarkList (hwndDlg);

+

+

+ if (((benchmarkType == BENCHMARK_TYPE_PRF) && (benchmarkTable[i].meanBytesPerSec > benchmarkTable[i+1].meanBytesPerSec)) ||

+ ((benchmarkType != BENCHMARK_TYPE_PRF) && (benchmarkTable[i].meanBytesPerSec < benchmarkTable[i+1].meanBytesPerSec))

+ )

+

+ SendMessageW (hList, LVM_INSERTITEM, 0, (LPARAM)&LvItem);

+ switch(benchmarkType) {

+ case BENCHMARK_TYPE_ENCRYPTION:

+ GetSpeedString ((unsigned __int64) (benchmarkLastBufferSize / ((float) benchmarkTable[i].encSpeed / benchmarkPerformanceFrequency.QuadPart)), item1, sizeof(item1));

+ LvItem.iSubItem = 1;

+ LvItem.pszText = item1;

+ SendMessageW (hList, LVM_SETITEMW, 0, (LPARAM)&LvItem);

+

+ GetSpeedString ((unsigned __int64) (benchmarkLastBufferSize / ((float) benchmarkTable[i].decSpeed / benchmarkPerformanceFrequency.QuadPart)), item1, sizeof(item1));

+ LvItem.iSubItem = 2;

+ LvItem.pszText = item1;

+ SendMessageW (hList, LVM_SETITEMW, 0, (LPARAM)&LvItem);

+

+ GetSpeedString (benchmarkTable[i].meanBytesPerSec, item1, sizeof(item1));

+ LvItem.iSubItem = 3;

+ LvItem.pszText = item1;

+ SendMessageW (hList, LVM_SETITEMW, 0, (LPARAM)&LvItem);

+ break;

+ case BENCHMARK_TYPE_HASH:

+ GetSpeedString (benchmarkTable[i].meanBytesPerSec, item1, sizeof(item1));

+ LvItem.iSubItem = 1;

+ LvItem.pszText = item1;

+ SendMessageW (hList, LVM_SETITEMW, 0, (LPARAM)&LvItem);

+ break;

+ case BENCHMARK_TYPE_PRF:

+ swprintf_s (item1, sizeof(item1) / sizeof(item1[0]), L"%d ms", benchmarkTable[i].meanBytesPerSec);

+ LvItem.iSubItem = 1;

+ LvItem.pszText = item1;

+ SendMessageW (hList, LVM_SETITEMW, 0, (LPARAM)&LvItem);

+ swprintf_s (item1, sizeof(item1) / sizeof(item1[0]), L"%d", benchmarkTable[i].decSpeed);

+ LvItem.iSubItem = 2;

+ LvItem.pszText = item1;

+ SendMessageW (hList, LVM_SETITEMW, 0, (LPARAM)&LvItem);

+ break;

+ }

+ BOOL bStatus;

+ BYTE *lpTestBuffer = NULL;

+ SYSTEM_INFO sysInfo = {0};

+ GetSystemInfo (&sysInfo);

+ /* set priority to critical only when there are 2 or more CPUs on the system */

+ if (sysInfo.dwNumberOfProcessors > 1)

+ SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);

+

+ if (benchmarkType != BENCHMARK_TYPE_PRF)

+ lpTestBuffer = (BYTE *) _aligned_malloc(benchmarkBufferSize - (benchmarkBufferSize % 16), 16);

+ if (lpTestBuffer == NULL)

+ if (ci)

+ crypto_close (ci);

+ MessageBoxW (hwndDlg, GetString ("ERR_MEM_ALLOC"), lpszTitle, ICON_HAND);

+ return FALSE;

+ VirtualLock (lpTestBuffer, benchmarkBufferSize - (benchmarkBufferSize % 16));

+ WaitCursor ();

+ benchmarkTotalItems = 0;

+ switch(benchmarkType) {

+ case BENCHMARK_TYPE_HASH:

+ /* Measures the speed at which each of the hash algorithms processes the message to produce

+ a single digest.

+ */

+ BYTE *digest [MAX_DIGESTSIZE];

+ WHIRLPOOL_CTX wctx;

+ RMD160_CTX rctx;

+ sha512_ctx s2ctx;

+ sha256_ctx s256ctx;

+ STREEBOG_CTX stctx;

+ int hid, i;

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

+ {

+ if (QueryPerformanceCounter (&performanceCountStart) == 0)

+ goto counter_error;

+ for (i = 1; i <= 2; i++)

+ {

+ switch (hid)

+ {

+ case SHA512:

+ sha512_begin (&s2ctx);

+ sha512_hash (lpTestBuffer, benchmarkBufferSize, &s2ctx);

+ sha512_end ((unsigned char *) digest, &s2ctx);

+ break;

+

+ case SHA256:

+ sha256_begin (&s256ctx);

+ sha256_hash (lpTestBuffer, benchmarkBufferSize, &s256ctx);

+ sha256_end ((unsigned char *) digest, &s256ctx);

+ break;

+

+ case RIPEMD160:

+ RMD160Init(&rctx);

+ RMD160Update(&rctx, lpTestBuffer, benchmarkBufferSize);

+ RMD160Final((unsigned char *) digest, &rctx);

+ break;

+

+ case WHIRLPOOL:

+ WHIRLPOOL_init (&wctx);

+ WHIRLPOOL_add (lpTestBuffer, benchmarkBufferSize, &wctx);

+ WHIRLPOOL_finalize (&wctx, (unsigned char *) digest);

+ break;

+

+ case STREEBOG:

+ STREEBOG_init(&stctx);

+ STREEBOG_add(&stctx, lpTestBuffer, benchmarkBufferSize);

+ STREEBOG_finalize(&stctx, (unsigned char *)digest);

+ break;

+ }

+ }

+ if (QueryPerformanceCounter (&performanceCountEnd) == 0)

+ goto counter_error;

+ benchmarkTable[benchmarkTotalItems].encSpeed = performanceCountEnd.QuadPart - performanceCountStart.QuadPart;

+ benchmarkTable[benchmarkTotalItems].decSpeed = benchmarkTable[benchmarkTotalItems].encSpeed;

+ benchmarkTable[benchmarkTotalItems].id = hid;

+ benchmarkTable[benchmarkTotalItems].meanBytesPerSec = (unsigned __int64) (benchmarkBufferSize / ((float) benchmarkTable[benchmarkTotalItems].encSpeed / benchmarkPerformanceFrequency.QuadPart / 2));

+ StringCbPrintfW (benchmarkTable[benchmarkTotalItems].name, sizeof(benchmarkTable[benchmarkTotalItems].name),L"%s", HashGetName(hid));

+ benchmarkTotalItems++;

+ }

+ break;

+ case BENCHMARK_TYPE_PRF:

+ each of the implemented PRF algorithms.

+ */

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

+ if (benchmarkPreBoot && !benchmarkGPT && !HashForSystemEncryption (thid))

+ continue;

+

+ for (i = 1; i <= 2; i++)

+ derive_key_sha512 ("passphrase-1234567890", 21, tmp_salt, 64, get_pkcs5_iteration_count(thid, benchmarkPim, FALSE, benchmarkPreBoot), dk, MASTER_KEYDATA_SIZE);

+ derive_key_sha256 ("passphrase-1234567890", 21, tmp_salt, 64, get_pkcs5_iteration_count(thid, benchmarkPim, FALSE, benchmarkPreBoot), dk, MASTER_KEYDATA_SIZE);

+ derive_key_ripemd160 ("passphrase-1234567890", 21, tmp_salt, 64, get_pkcs5_iteration_count(thid, benchmarkPim, FALSE, benchmarkPreBoot), dk, MASTER_KEYDATA_SIZE);

+ derive_key_whirlpool ("passphrase-1234567890", 21, tmp_salt, 64, get_pkcs5_iteration_count(thid, benchmarkPim, FALSE, benchmarkPreBoot), dk, MASTER_KEYDATA_SIZE);

+ break;

+

+ case STREEBOG:

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

+ derive_key_streebog("passphrase-1234567890", 21, tmp_salt, 64, get_pkcs5_iteration_count(thid, benchmarkPim, FALSE, benchmarkPreBoot), dk, MASTER_KEYDATA_SIZE);

+ benchmarkTable[benchmarkTotalItems].decSpeed = get_pkcs5_iteration_count(thid, benchmarkPim, FALSE, benchmarkPreBoot);

+ benchmarkTable[benchmarkTotalItems].meanBytesPerSec = (unsigned __int64) (1000 * ((float) benchmarkTable[benchmarkTotalItems].encSpeed / benchmarkPerformanceFrequency.QuadPart / 2));

+ if (benchmarkPreBoot)

+ {

+ /* heuristics for boot times */

+ if (benchmarkGPT)

+ {

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

+ }

+ else

+ {

+ if (thid == SHA256)

+ {

+#ifdef _WIN64

+ benchmarkTable[benchmarkTotalItems].meanBytesPerSec = (benchmarkTable[benchmarkTotalItems].meanBytesPerSec * 26);

+#else

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

+#endif

+ }

+ else

+ {

+#ifdef _WIN64

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

+#else

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

+#endif

+ }

+ }

+ }

+ StringCbPrintfW (benchmarkTable[benchmarkTotalItems].name, sizeof(benchmarkTable[benchmarkTotalItems].name),L"%s", get_pkcs5_prf_name (thid));

+ break;

+ case BENCHMARK_TYPE_ENCRYPTION:

+ {

+ /* Encryption algorithm benchmarks */

+ // CPU "warm up" (an attempt to prevent skewed results on systems where CPU frequency

+ // gradually changes depending on CPU load).

+ ci->ea = EAGetFirst();

+ if (!EAInit (ci->ea, ci->master_keydata, ci->ks))

+ {

+ ci->mode = FIRST_MODE_OF_OPERATION_ID;

+ if (EAInitMode (ci))

+ {

+ int i;

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

+ {

+ EncryptDataUnits (lpTestBuffer, &startDataUnitNo, (TC_LARGEST_COMPILER_UINT) benchmarkBufferSize / ENCRYPTION_DATA_UNIT_SIZE, ci);

+ DecryptDataUnits (lpTestBuffer, &startDataUnitNo, (TC_LARGEST_COMPILER_UINT) benchmarkBufferSize / ENCRYPTION_DATA_UNIT_SIZE, ci);

+ }

+ }

+ }

+ for (ci->ea = EAGetFirst(); ci->ea != 0; ci->ea = EAGetNext(ci->ea))

+ {

+ if (!EAIsFormatEnabled (ci->ea))

+ continue;

+ if (ERR_CIPHER_INIT_FAILURE == EAInit (ci->ea, ci->master_keydata, ci->ks))

+ goto counter_error;

+ ci->mode = FIRST_MODE_OF_OPERATION_ID;

+ if (!EAInitMode (ci))

+ goto counter_error;

+ if (QueryPerformanceCounter (&performanceCountStart) == 0)

+ goto counter_error;

+ EncryptDataUnits (lpTestBuffer, &startDataUnitNo, (TC_LARGEST_COMPILER_UINT) benchmarkBufferSize / ENCRYPTION_DATA_UNIT_SIZE, ci);

+ if (QueryPerformanceCounter (&performanceCountEnd) == 0)

+ goto counter_error;

+ benchmarkTable[benchmarkTotalItems].encSpeed = performanceCountEnd.QuadPart - performanceCountStart.QuadPart;

+ if (QueryPerformanceCounter (&performanceCountStart) == 0)

+ goto counter_error;

+ DecryptDataUnits (lpTestBuffer, &startDataUnitNo, (TC_LARGEST_COMPILER_UINT) benchmarkBufferSize / ENCRYPTION_DATA_UNIT_SIZE, ci);

+ if (QueryPerformanceCounter (&performanceCountEnd) == 0)

+ goto counter_error;

+ benchmarkTable[benchmarkTotalItems].decSpeed = performanceCountEnd.QuadPart - performanceCountStart.QuadPart;

+ benchmarkTable[benchmarkTotalItems].id = ci->ea;

+ benchmarkTable[benchmarkTotalItems].meanBytesPerSec = ((unsigned __int64) (benchmarkBufferSize / ((float) benchmarkTable[benchmarkTotalItems].encSpeed / benchmarkPerformanceFrequency.QuadPart)) + (unsigned __int64) (benchmarkBufferSize / ((float) benchmarkTable[benchmarkTotalItems].decSpeed / benchmarkPerformanceFrequency.QuadPart))) / 2;

+ EAGetName (benchmarkTable[benchmarkTotalItems].name, ci->ea, 1);

+ benchmarkTotalItems++;

+ }

+ }

+ break;

+ if (lpTestBuffer)

+ {

+ VirtualUnlock (lpTestBuffer, benchmarkBufferSize - (benchmarkBufferSize % 16));

+ _aligned_free(lpTestBuffer);

+ }

+

+ if (lpTestBuffer)

+ {

+ VirtualUnlock (lpTestBuffer, benchmarkBufferSize - (benchmarkBufferSize % 16));

+ _aligned_free(lpTestBuffer);

+ }

+ static HWND hCboxSortMethod = NULL, hCboxBufferSize = NULL, hCboxList = NULL;

+ hCboxSortMethod = GetDlgItem (hwndDlg, IDC_BENCHMARK_SORT_METHOD);

+ hCboxBufferSize = GetDlgItem (hwndDlg, IDC_BENCHMARK_BUFFER_SIZE);

+ hCboxList = GetDlgItem (hwndDlg, IDC_BENCHMARK_LIST);

+ benchmarkType = BENCHMARK_TYPE_ENCRYPTION;

+

+ if (lParam)

+ {

+ benchmarkGPT = TRUE;

+ }

+ else

+ benchmarkGPT = FALSE;

+ LVS_EX_FULLROWSELECT|LVS_EX_HEADERDRAGDROP|LVS_EX_LABELTIP

+ );

+ memset (&LvCol,0,sizeof(LvCol));

+ LvCol.mask = LVCF_TEXT|LVCF_WIDTH|LVCF_SUBITEM|LVCF_FMT;

+ ResetBenchmarkList (hwndDlg);

+ // benchmark list

+

+ SendMessage (hCboxList, CB_RESETCONTENT, 0, 0);

+

+ nIndex = SendMessageW (hCboxList, CB_ADDSTRING, 0, (LPARAM) GetString ("ENCRYPTION_ALGORITHM"));

+ SendMessage (hCboxList, CB_SETITEMDATA, nIndex, (LPARAM) 0);

+

+ nIndex = SendMessageW (hCboxList, CB_ADDSTRING, 0, (LPARAM) GetString ("PKCS5_PRF"));

+ SendMessage (hCboxList, CB_SETITEMDATA, nIndex, (LPARAM) 0);

+

+ nIndex = SendMessageW (hCboxList, CB_ADDSTRING, 0, (LPARAM) GetString ("IDT_HASH_ALGO"));

+ SendMessage (hCboxList, CB_SETITEMDATA, nIndex, (LPARAM) 0);

+

+ SendMessage (hCboxList, CB_SETCURSEL, 0, 0); // Default: benchmark of encryption

+

+ int isAesHwSupported = is_aes_hw_cpu_supported();

+ SetDlgItemTextW (hwndDlg, IDC_HW_AES, (wstring (L" ") + (GetString (isAesHwSupported ? ((driverConfig & TC_DRIVER_CONFIG_DISABLE_HARDWARE_ENCRYPTION) ? "UISTR_DISABLED" : "UISTR_YES") : "NOT_APPLICABLE_OR_NOT_AVAILABLE"))).c_str());

+ if (isAesHwSupported && (driverConfig & TC_DRIVER_CONFIG_DISABLE_HARDWARE_ENCRYPTION))

+ case IDC_BENCHMARK_LIST:

+

+ nIndex = SendMessage (hCboxList, CB_GETCURSEL, 0, 0);

+ if (nIndex != benchmarkType)

+ {

+ benchmarkType = (int) nIndex;

+ benchmarkTotalItems = 0;

+ ResetBenchmarkList (hwndDlg);

+ }

+

+ if (benchmarkType == BENCHMARK_TYPE_PRF)

+ {

+ ShowWindow (GetDlgItem (hwndDlg, IDC_BENCHMARK_BUFFER_SIZE), SW_HIDE);

+ ShowWindow (GetDlgItem (hwndDlg, IDT_BUFFER_SIZE), SW_HIDE);

+ ShowWindow (GetDlgItem (hwndDlg, IDC_PIM), SW_SHOW);

+ ShowWindow (GetDlgItem (hwndDlg, IDT_PIM), SW_SHOW);

+ ShowWindow (GetDlgItem (hwndDlg, IDC_BENCHMARK_PREBOOT), SW_SHOW);

+ }

+ else

+ {

+ ShowWindow (GetDlgItem (hwndDlg, IDC_BENCHMARK_BUFFER_SIZE), SW_SHOW);

+ ShowWindow (GetDlgItem (hwndDlg, IDT_BUFFER_SIZE), SW_SHOW);

+ ShowWindow (GetDlgItem (hwndDlg, IDC_PIM), SW_HIDE);

+ ShowWindow (GetDlgItem (hwndDlg, IDT_PIM), SW_HIDE);

+ ShowWindow (GetDlgItem (hwndDlg, IDC_BENCHMARK_PREBOOT), SW_HIDE);

+ }

+ return 1;

+

+ if (benchmarkType == BENCHMARK_TYPE_PRF)

+ {

+ benchmarkPim = GetPim (hwndDlg, IDC_PIM);

+ benchmarkPreBoot = GetCheckBox (hwndDlg, IDC_BENCHMARK_PREBOOT);

+ }

+ else

+ {

+ nIndex = SendMessage (hCboxBufferSize, CB_GETCURSEL, 0, 0);

+ benchmarkBufferSize = (int) SendMessage (hCboxBufferSize, CB_GETITEMDATA, nIndex, 0);

+ }

+

+ tmpByte = (randPool[row * RANDPOOL_DISPLAY_COLUMNS + col] -

+#ifndef VOLFORMAT

+ if (Randinit ())

+ tmpByte = (randPool[row * RANDPOOL_DISPLAY_COLUMNS + col] -

+

+

+ /* Generate the keyfile */

+ }

+ }

+#ifndef VOLFORMAT

+ }

+ CRYPTOPP_ALIGN_DATA(16) char key[128+1], inputtext[128+1], secondaryKey[64+1], dataUnitNo[16+1];

+

+

+ if (ks != CB_ERR && pt != CB_ERR)

+void

+

+ if (idTestCipher == AES || idTestCipher == SERPENT || idTestCipher == TWOFISH || idTestCipher == CAMELLIA

+#if defined(CIPHER_GOST89)

+ || idTestCipher == GOST89

+#endif

+ || idTestCipher == KUZNYECHIK

+ )

+ do

+ nLongestButtonCaptionCharLen = max (nLongestButtonCaptionCharLen,

+ if (nMainTextLenInChars > 200

+ // As the main text is longer than 200 characters, we will "pad" the widest button caption with

+ // spaces (if it is not wide enough) so as to increase the width of the whole dialog window.

+ nLongestButtonCaptionWidth,

+ offset = FindString ((char *) (bResolve ? GetString(*(pStrOrig+1)) : *(pwStrOrig+1)),

+ nMainTextLenInChars * 2,

+ (int) wcslen (L"\n") * 2,

+ if (horizSubOffset > 0

+ || vertMsgHeightOffset > 0

+

+ if ((GetKeyState(VK_CAPITAL) & 1) != 0)

+ L".class", L".dhtm", L".dhtml",L".dlo", L".emf", L".eml", L".flt", L".fot", L".gz", L".hlp", L".htm", L".html", L".ini",

+

+ dbv.dbcv_size = sizeof (dbv);

+ dbv.dbcv_devicetype = DBT_DEVTYP_VOLUME;

+ dbv.dbcv_flags = 0;

+

+ thParam->hwnd = hwndDlg;

+ ::SendMessage(hwndDlg, WM_SETICON, FALSE, (LPARAM)hIconSmall);

+ }

+

+

+

+

+

+

+

+// specific definitions and implementation for support of mount operation

+

+ if ( (path.length() == (3 + 2*VOLUME_ID_SIZE))

+

+ // Ask user

+ // Do not report wrong password, if not instructed to

+ if (WrongPwdRetryCountOverLimit ()

+

+ else if (strcmp(dest, "gost89") == 0)

+ {

+ StringCbCopyA (url, sizeof (url),"https://veracrypt.codeplex.com/wikipage?title=GOST89");

+ }

+ else if (strcmp(dest, "kuznyechik") == 0)

+ {

+ StringCbCopyA (url, sizeof (url),"https://veracrypt.codeplex.com/wikipage?title=Kuznyechik");

+ }

+ else if (strcmp(dest, "camellia") == 0)

+ {

+ StringCbCopyA (url, sizeof (url),"https://veracrypt.codeplex.com/wikipage?title=Camellia");

+ }

+ if (CmdTokenPin[0])

+ {

+ str = CmdTokenPin;

+ }

+ else

+ {

+ HWND hParent = IsWindow (m_hwnd)? m_hwnd : GetActiveWindow();

+ if (!hParent)

+ hParent = GetForegroundWindow ();

+ if (DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_TOKEN_PASSWORD), hParent, (DLGPROC) SecurityTokenPasswordDlgProc, (LPARAM) &str) == IDCANCEL)

+ throw UserAbort (SRC_POS);

+ }

+

+ virtual void notifyIncorrectPin ()

+ {

+ // clear wrong PIN

+ burn (&CmdTokenPin, sizeof (CmdTokenPin));

+ }

+

+BOOL GetFreeDriveLetter(WCHAR* pCh) {

+ DWORD dwUsedDrives = GetLogicalDrives();

+ WCHAR l;

+ for (l = L'A'; l <= L'Z'; l++) {

+ if ((dwUsedDrives & 1) == 0) {

+ *pCh = l;

+ return TRUE;

+ }

+ dwUsedDrives = dwUsedDrives >> 1;

+ }

+ return FALSE;

+}

+

+BOOL RaisePrivileges(void)

+{

+ HANDLE hToken;

+ TOKEN_PRIVILEGES tkp;

+ BOOL bRet = FALSE;

+ DWORD dwLastError = 0;

+

+ if (OpenProcessToken(GetCurrentProcess(),

+ TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,

+ &hToken))

+ {

+ if (LookupPrivilegeValue(NULL, SE_SYSTEM_ENVIRONMENT_NAME,

+ &tkp.Privileges[0].Luid))

+ {

+ DWORD len;

+

+ tkp.PrivilegeCount = 1;

+ tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

+

+ bRet = AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, NULL, &len);

+ if (!bRet)

+ dwLastError = GetLastError ();

+ }

+ else

+ dwLastError = GetLastError ();

+

+ CloseHandle(hToken);

+ }

+ else

+ dwLastError = GetLastError ();

+

+ SetLastError (dwLastError);

+

+ return bRet;

+} \ No newline at end of file

+extern char CmdTokenPin [TC_MAX_PATH];

+BOOL LaunchElevatedProcess (HWND hwndDlg, const wchar_t* szModPath, const wchar_t* args);

+BOOL GetFreeDriveLetter(WCHAR* pCh);

+BOOL RaisePrivileges(void);

+ case STREEBOG:

+ derive_key_streebog(workItem->KeyDerivation.Password, workItem->KeyDerivation.PasswordLength, workItem->KeyDerivation.Salt, PKCS5_SALT_SIZE,

+ workItem->KeyDerivation.IterationCount, workItem->KeyDerivation.DerivedKey, GetMaxPkcs5OutSize());

+ break;

+

+ derived from the source code of TrueCrypt 7.1a, which is

+ Copyright (c) 2003-2012 TrueCrypt Developers Association and which is

+ and which is governed by the 'License Agreement for Encryption for the Masses'

+ Modifications and additions to the original source code (contained in this file)

+#if defined(_WIN32) || defined(_UEFI)

+ ( memPtr += 2, ((( unsigned short ) memPtr[ -2 ] << 8 ) | ( ( unsigned short ) memPtr[ -1 ] )) )

+#endif

+ CRYPTOPP_ALIGN_DATA(16) char temporaryKey[MASTER_KEYDATA_SIZE];

+ BOOL bUpdateBackup = FALSE;

+

+ nStatus = WriteRandomDataToReservedHeaderAreas (hwndDlg, dev, cryptoInfo, dataAreaSize, FALSE, FALSE, FALSE);

+

+ // write fake hidden volume header to protect against attacks that use statistical entropy

+ // analysis to detect presence of hidden volumes.

+

+ while (TRUE)

+ {

+ PCRYPTO_INFO dummyInfo = NULL;

+ LARGE_INTEGER hiddenOffset;

+

+ hiddenOffset.QuadPart = bUpdateBackup ? dataAreaSize + TC_VOLUME_HEADER_GROUP_SIZE + TC_HIDDEN_VOLUME_HEADER_OFFSET: TC_HIDDEN_VOLUME_HEADER_OFFSET;

+

+ nStatus = CreateVolumeHeaderInMemory (hwndDlg, FALSE,

+ header,

+ volParams->ea,

+ FIRST_MODE_OF_OPERATION_ID,

+ NULL,

+ 0,

+ 0,

+ NULL,

+ &dummyInfo,

+ dataAreaSize,

+ dataAreaSize,

+ dataOffset,

+ dataAreaSize,

+ 0,

+ volParams->headerFlags,

+ FormatSectorSize,

+ FALSE);

+

+ if (nStatus != ERR_SUCCESS)

+ goto error;

+

+ crypto_close (dummyInfo);

+

+ if (!SetFilePointerEx ((HANDLE) dev, hiddenOffset, NULL, FILE_BEGIN))

+ {

+ nStatus = ERR_OS_ERROR;

+ goto error;

+ }

+

+ if (!WriteEffectiveVolumeHeader (volParams->bDevice, dev, header))

+ {

+ nStatus = ERR_OS_ERROR;

+ goto error;

+ }

+

+ if (bUpdateBackup)

+ break;

+

+ bUpdateBackup = TRUE;

+ }

+ CRYPTOPP_ALIGN_DATA(16) char temporaryKey[MASTER_KEYDATA_SIZE];

+ CRYPTOPP_ALIGN_DATA(16) char originalK2[MASTER_KEYDATA_SIZE];

+ SecurityToken::GetKeyfileData (SecurityTokenKeyfile (secPath), keyfileData);

+ header--;

+ header++;

+ } while ((header = strchr (header, '\n')) != NULL);

+ <control lang="en" key="IDM_VERIFY_RESCUE_DISK_ISO">Verify Rescue Disk Image</control>

+ <control lang="en" key="IDD_BENCHMARK_DLG">VeraCrypt - Algorithms Benchmark</control>

+ <string lang="en" key="RESCUE_DISK_NON_WIZARD_CREATION_SELECT_PATH">After you click OK, you will select a filename for the new VeraCrypt Rescue Disk image and the location where you wish to place it.</string>

+ <string lang="en" key="RESCUE_DISK_NON_WIZARD_CHECK_INSERT">Please insert your VeraCrypt Rescue Disk and click OK to verify it.</string>

+ <string lang="en" key="RESCUE_DISK_ISO_IMAGE_CHECK_PASSED">The VeraCrypt Rescue Disk image has been successfully verified.</string>

+ <string lang="en" key="RESCUE_DISK_ISO_IMAGE_CHECK_FAILED">The Rescue Disk image verification failed.\n\nIf you attempted to verify a VeraCrypt Rescue Disk image created for a different master key, password, salt, etc., please note that such Rescue Disk image will always fail this verification. To create a new Rescue Disk image fully compatible with your current configuration, select 'System' > 'Create Rescue Disk'.</string>

+ <string lang="en" key="GPT_BOOT_DRIVE_UNSUPPORTED">You are running a 32-bit Windows and your system drive has a GUID partition table (GPT). Currently, only Windows 64-bit is supported for GPT system encryption.</string>

+ <control lang="en" key="IDC_DISABLE_BOOT_LOADER_HASH_PROMPT">Do not request Hash algorithm in the pre-boot authentication screen</control>

+ <string lang="en" key="GOST89_HELP">The GOST block cipher, defined in the standard GOST 28147-89 under name Magma, is a Soviet and Russian government standard symmetric key block cipher.\n\nDeveloped in the 1970s, the standard had been marked "Top Secret" and then downgraded to "Secret" in 1990. It was a Soviet alternative to the United States standard algorithm, DES.</string>

+ <string lang="en" key="KUZNYECHIK_HELP">Kuznyechik is a block cipher first published in 2015 and defined in the National Standard of the Russian Federation GOST R 34.12-2015 and also in RFC 7801. 256-bit key, 128-bit block. Mode of operation is XTS.</string>

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

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

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

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

+ <string lang="en" key="RESCUE_DISK_EFI_INFO">Before you can encrypt the partition, you must create a VeraCrypt Rescue Disk (VRD), which serves the following purposes:\n\n- If the VeraCrypt Boot Loader, master key, or other critical data gets damaged, the VRD allows you to restore it (note, however, that you will still have to enter the correct password then).\n\n- If Windows gets damaged and cannot start, the VRD allows you to permanently decrypt the partition before Windows starts.\n\n- The VRD will contain a backup of the present EFI boot loader and will allow you to restore it if necessary.\n\nThe VeraCrypt Rescue Disk ZIP image will be created in the location specified below.</string>

+ <string 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.</string>

+ <string 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%lsClick Next to continue.</string>

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

+ <string 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.</string>

+ <string lang="en" key="RESCUE_DISK_EFI_NON_WIZARD_CHECK_FAILED">Cannot verify that the Rescue Disk has been correctly extracted.\n\nIf you have extracted the Rescue Disk image to a USB stick, please eject it and reinsert it; then try again. If this does not help, please try other ZIP software and/or medium.\n\nIf you attempted to verify a VeraCrypt Rescue Disk created for a different master key, password, salt, etc., please note that such Rescue Disk will always fail this verification. To create a new Rescue Disk fully compatible with your current configuration, select 'System' > 'Create Rescue Disk'.</string>

+ <string lang="en" key="RESCUE_DISK_EFI_NON_WIZARD_CREATION">The Rescue Disk image has been created and stored in this file:\n%s\n\nNow you need to extract the Rescue Disk image to a USB stick that is formatted as FAT/FAT32.\n\nIMPORTANT: 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\nAfter you create the Rescue Disk, select 'System' > 'Verify Rescue Disk' to verify that it has been correctly created.</string>

+ PCRYPTO_INFO dummyInfo = NULL;

+ LARGE_INTEGER hiddenOffset;

+

+ nStatus = WriteRandomDataToReservedHeaderAreas (hwndDlg, dev, cryptoInfo, cryptoInfo->VolumeSize.Value, !backupHeader, backupHeader, FALSE);

+ if (nStatus != ERR_SUCCESS)

+ goto error;

+

+ // write fake hidden volume header to protect against attacks that use statistical entropy

+ // analysis to detect presence of hidden volumes

+ hiddenOffset.QuadPart = backupHeader ? cryptoInfo->VolumeSize.Value + TC_VOLUME_HEADER_GROUP_SIZE + TC_HIDDEN_VOLUME_HEADER_OFFSET: TC_HIDDEN_VOLUME_HEADER_OFFSET;

+

+ nStatus = CreateVolumeHeaderInMemory (hwndDlg, FALSE,

+ buffer,

+ cryptoInfo->ea,

+ cryptoInfo->mode,

+ NULL,

+ 0,

+ 0,

+ NULL,

+ &dummyInfo,

+ cryptoInfo->VolumeSize.Value,

+ cryptoInfo->VolumeSize.Value,

+ cryptoInfo->EncryptedAreaStart.Value,

+ cryptoInfo->EncryptedAreaLength.Value,

+ truecryptMode? 0 : cryptoInfo->RequiredProgramVersion,

+ cryptoInfo->HeaderFlags,

+ cryptoInfo->SectorSize,

+ wipePass < wipePassCount - 1);

+

+

+ crypto_close (dummyInfo);

+

+ if (!SetFilePointerEx ((HANDLE) dev, hiddenOffset, NULL, FILE_BEGIN))

+ {

+ nStatus = ERR_OS_ERROR;

+ goto error;

+ }

+

+ if (!WriteEffectiveVolumeHeader (bDevice, dev, buffer))

+ {

+ nStatus = ERR_OS_ERROR;

+ goto error;

+ }

+ derived from the source code of TrueCrypt 7.1a, which is

+ Copyright (c) 2003-2012 TrueCrypt Developers Association and which is

+ and which is governed by the 'License Agreement for Encryption for the Masses'

+ Modifications and additions to the original source code (contained in this file)

+#if defined(_WIN32) && !defined(TC_WINDOWS_DRIVER) && !defined(_UEFI)

+BOOL CheckPasswordLength (HWND hwndDlg, unsigned __int32 passwordLength, int pim, BOOL bForBoot, BOOL bSkipPasswordWarning, BOOL bSkipPimWarning);

+BOOL CheckPasswordCharEncoding (HWND hPassword, Password *ptrPw);

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

+ derived from the source code of TrueCrypt 7.1a, which is

+ Copyright (c) 2003-2012 TrueCrypt Developers Association and which is

+ and which is governed by the 'License Agreement for Encryption for the Masses'

+ Modifications and additions to the original source code (contained in this file)

+#if !defined(_UEFI)

+#endif

+#include "cpu.h"

+ int i;

+

+{

+ int ld /* length of data in bytes */

+ if (keylen > RIPEMD160_BLOCKSIZE)

+ }

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

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

+

+{

+ if (pwd_len > RIPEMD160_BLOCKSIZE)

+ for (b=0; b<pwd_len; b++)

+ for (b=0; b<pwd_len; b++)

+ WHIRLPOOL_add ((unsigned char *) d, ld, ctx);

+ WHIRLPOOL_add ((unsigned char *) d, WHIRLPOOL_DIGESTSIZE, ctx);

+#if defined (DEVICE_DRIVER) && !defined (_WIN64)

+ KFLOATING_SAVE floatingPointState;

+ NTSTATUS saveStatus = STATUS_SUCCESS;

+ if (HasISSE())

+ saveStatus = KeSaveFloatingPointState (&floatingPointState);

+#endif

+ WHIRLPOOL_add ((unsigned char *) k, lk, &tctx);

+ WHIRLPOOL_add ((unsigned char *) buf, WHIRLPOOL_BLOCKSIZE, ctx);

+ WHIRLPOOL_add ((unsigned char *) buf, WHIRLPOOL_BLOCKSIZE, ctx);

+

+#if defined (DEVICE_DRIVER) && !defined (_WIN64)

+ if (NT_SUCCESS (saveStatus) && HasISSE())

+ KeRestoreFloatingPointState (&floatingPointState);

+#endif

+ memset (&k[salt_len], 0, 3);

+#if defined (DEVICE_DRIVER) && !defined (_WIN64)

+ KFLOATING_SAVE floatingPointState;

+ NTSTATUS saveStatus = STATUS_SUCCESS;

+ if (HasISSE())

+ saveStatus = KeSaveFloatingPointState (&floatingPointState);

+#endif

+ WHIRLPOOL_add ((unsigned char *) pwd, pwd_len, &tctx);

+ WHIRLPOOL_add ((unsigned char *) buf, WHIRLPOOL_BLOCKSIZE, ctx);

+ WHIRLPOOL_add ((unsigned char *) buf, WHIRLPOOL_BLOCKSIZE, ctx);

+#if defined (DEVICE_DRIVER) && !defined (_WIN64)

+ if (NT_SUCCESS (saveStatus) && HasISSE())

+ KeRestoreFloatingPointState (&floatingPointState);

+#endif

+typedef struct hmac_streebog_ctx_struct

+{

+ STREEBOG_CTX ctx;

+ STREEBOG_CTX inner_digest_ctx; /*pre-computed inner digest context */

+ STREEBOG_CTX outer_digest_ctx; /*pre-computed outer digest context */

+ CRYPTOPP_ALIGN_DATA(16) char k[PKCS5_SALT_SIZE + 4]; /* enough to hold (salt_len + 4) and also the Streebog hash */

+ char u[STREEBOG_DIGESTSIZE];

+} hmac_streebog_ctx;

+

+void hmac_streebog_internal

+(

+ char *k, /* secret key */

+ int lk, /* length of the key in bytes */

+ char *d, /* input/output data. d pointer is guaranteed to be at least 64-bytes long */

+ int ld, /* length of input data in bytes */

+ hmac_streebog_ctx* hmac /* HMAC-Whirlpool context which holds temporary variables */

+)

+{

+ STREEBOG_CTX* ctx = &(hmac->ctx);

+

+ /**** Restore Precomputed Inner Digest Context ****/

+

+ memcpy (ctx, &(hmac->inner_digest_ctx), sizeof (STREEBOG_CTX));

+

+ STREEBOG_add (ctx, (unsigned char *) d, ld);

+

+ STREEBOG_finalize (ctx, (unsigned char *) d);

+

+ /**** Restore Precomputed Outer Digest Context ****/

+

+ memcpy (ctx, &(hmac->outer_digest_ctx), sizeof (STREEBOG_CTX));

+

+ STREEBOG_add (ctx, (unsigned char *) d, STREEBOG_DIGESTSIZE);

+

+ STREEBOG_finalize (ctx, (unsigned char *) d);

+}

+

+void hmac_streebog

+(

+ char *k, /* secret key */

+ int lk, /* length of the key in bytes */

+ char *d, /* input data. d pointer is guaranteed to be at least 32-bytes long */

+ int ld /* length of data in bytes */

+)

+{

+ hmac_streebog_ctx hmac;

+ STREEBOG_CTX* ctx;

+ char* buf = hmac.k;

+ int b;

+ CRYPTOPP_ALIGN_DATA(16) char key[STREEBOG_DIGESTSIZE];

+#if defined (DEVICE_DRIVER) && !defined (_WIN64)

+ KFLOATING_SAVE floatingPointState;

+ NTSTATUS saveStatus = STATUS_SUCCESS;

+ if (HasSSE2() || HasSSE41())

+ saveStatus = KeSaveFloatingPointState (&floatingPointState);

+#endif

+ /* If the key is longer than the hash algorithm block size,

+ let key = streebog(key), as per HMAC specifications. */

+ if (lk > STREEBOG_BLOCKSIZE)

+ {

+ STREEBOG_CTX tctx;

+

+ STREEBOG_init (&tctx);

+ STREEBOG_add (&tctx, (unsigned char *) k, lk);

+ STREEBOG_finalize (&tctx, (unsigned char *) key);

+

+ k = key;

+ lk = STREEBOG_DIGESTSIZE;

+

+ burn (&tctx, sizeof(tctx)); // Prevent leaks

+ }

+

+ /**** Precompute HMAC Inner Digest ****/

+

+ ctx = &(hmac.inner_digest_ctx);

+ STREEBOG_init (ctx);

+

+ /* Pad the key for inner digest */

+ for (b = 0; b < lk; ++b)

+ buf[b] = (char) (k[b] ^ 0x36);

+ memset (&buf[lk], 0x36, STREEBOG_BLOCKSIZE - lk);

+

+ STREEBOG_add (ctx, (unsigned char *) buf, STREEBOG_BLOCKSIZE);

+

+ /**** Precompute HMAC Outer Digest ****/

+

+ ctx = &(hmac.outer_digest_ctx);

+ STREEBOG_init (ctx);

+

+ for (b = 0; b < lk; ++b)

+ buf[b] = (char) (k[b] ^ 0x5C);

+ memset (&buf[lk], 0x5C, STREEBOG_BLOCKSIZE - lk);

+

+ STREEBOG_add (ctx, (unsigned char *) buf, STREEBOG_BLOCKSIZE);

+

+ hmac_streebog_internal(k, lk, d, ld, &hmac);

+

+#if defined (DEVICE_DRIVER) && !defined (_WIN64)

+ if (NT_SUCCESS (saveStatus) && (HasSSE2() || HasSSE41()))

+ KeRestoreFloatingPointState (&floatingPointState);

+#endif

+ /* Prevent leaks */

+ burn(&hmac, sizeof(hmac));

+}

+

+static void derive_u_streebog (char *pwd, int pwd_len, char *salt, int salt_len, uint32 iterations, int b, hmac_streebog_ctx* hmac)

+{

+ char* u = hmac->u;

+ char* k = hmac->k;

+ uint32 c, i;

+

+ /* iteration 1 */

+ memcpy (k, salt, salt_len); /* salt */

+ /* big-endian block number */

+ memset (&k[salt_len], 0, 3);

+ k[salt_len + 3] = (char) b;

+

+ hmac_streebog_internal (pwd, pwd_len, k, salt_len + 4, hmac);

+ memcpy (u, k, STREEBOG_DIGESTSIZE);

+

+ /* remaining iterations */

+ for (c = 1; c < iterations; c++)

+ {

+ hmac_streebog_internal (pwd, pwd_len, k, STREEBOG_DIGESTSIZE, hmac);

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

+ {

+ u[i] ^= k[i];

+ }

+ }

+}

+

+void derive_key_streebog (char *pwd, int pwd_len, char *salt, int salt_len, uint32 iterations, char *dk, int dklen)

+{

+ hmac_streebog_ctx hmac;

+ STREEBOG_CTX* ctx;

+ char* buf = hmac.k;

+ char key[STREEBOG_DIGESTSIZE];

+ int b, l, r;

+#if defined (DEVICE_DRIVER) && !defined (_WIN64)

+ KFLOATING_SAVE floatingPointState;

+ NTSTATUS saveStatus = STATUS_SUCCESS;

+ if (HasSSE2() || HasSSE41())

+ saveStatus = KeSaveFloatingPointState (&floatingPointState);

+#endif

+ /* If the password is longer than the hash algorithm block size,

+ let pwd = streebog(pwd), as per HMAC specifications. */

+ if (pwd_len > STREEBOG_BLOCKSIZE)

+ {

+ STREEBOG_CTX tctx;

+

+ STREEBOG_init (&tctx);

+ STREEBOG_add (&tctx, (unsigned char *) pwd, pwd_len);

+ STREEBOG_finalize (&tctx, (unsigned char *) key);

+

+ pwd = key;

+ pwd_len = STREEBOG_DIGESTSIZE;

+

+ burn (&tctx, sizeof(tctx)); // Prevent leaks

+ }

+

+ if (dklen % STREEBOG_DIGESTSIZE)

+ {

+ l = 1 + dklen / STREEBOG_DIGESTSIZE;

+ }

+ else

+ {

+ l = dklen / STREEBOG_DIGESTSIZE;

+ }

+

+ r = dklen - (l - 1) * STREEBOG_DIGESTSIZE;

+

+ /**** Precompute HMAC Inner Digest ****/

+

+ ctx = &(hmac.inner_digest_ctx);

+ STREEBOG_init (ctx);

+

+ /* Pad the key for inner digest */

+ for (b = 0; b < pwd_len; ++b)

+ buf[b] = (char) (pwd[b] ^ 0x36);

+ memset (&buf[pwd_len], 0x36, STREEBOG_BLOCKSIZE - pwd_len);

+

+ STREEBOG_add (ctx, (unsigned char *) buf, STREEBOG_BLOCKSIZE);

+

+ /**** Precompute HMAC Outer Digest ****/

+

+ ctx = &(hmac.outer_digest_ctx);

+ STREEBOG_init (ctx);

+

+ for (b = 0; b < pwd_len; ++b)

+ buf[b] = (char) (pwd[b] ^ 0x5C);

+ memset (&buf[pwd_len], 0x5C, STREEBOG_BLOCKSIZE - pwd_len);

+

+ STREEBOG_add (ctx, (unsigned char *) buf, STREEBOG_BLOCKSIZE);

+

+ /* first l - 1 blocks */

+ for (b = 1; b < l; b++)

+ {

+ derive_u_streebog (pwd, pwd_len, salt, salt_len, iterations, b, &hmac);

+ memcpy (dk, hmac.u, STREEBOG_DIGESTSIZE);

+ dk += STREEBOG_DIGESTSIZE;

+ }

+

+ /* last block */

+ derive_u_streebog (pwd, pwd_len, salt, salt_len, iterations, b, &hmac);

+ memcpy (dk, hmac.u, r);

+

+#if defined (DEVICE_DRIVER) && !defined (_WIN64)

+ if (NT_SUCCESS (saveStatus) && (HasSSE2() || HasSSE41()))

+ KeRestoreFloatingPointState (&floatingPointState);

+#endif

+

+ /* Prevent possible leaks. */

+ burn (&hmac, sizeof(hmac));

+ burn (key, sizeof(key));

+}

+

+ case SHA512:

+ case SHA256:

+ case RIPEMD160:

+ case WHIRLPOOL:

+ case STREEBOG:

+ return L"HMAC-STREEBOG";

+

+ default:

+ case RIPEMD160:

+ case SHA512:

+ case WHIRLPOOL:

+ case STREEBOG:

+ if (truecryptMode)

+ return 1000;

+ else if (pim == 0)

+ return bBoot? 200000 : 500000;

+ else

+ {

+ return bBoot? pim * 2048 : 15000 + pim * 1000;

+ }

+

+ default:

+void hmac_streebog (char *k, int32 lk, char *d, int32 ld);

+void derive_key_streebog (char *pwd, int pwd_len, char *salt, int salt_len, uint32 iterations, char *dk, int dklen);

+

+ STREEBOG_CTX stctx;

+ case STREEBOG:

+ digestSize = STREEBOG_DIGESTSIZE;

+ break;

+

+ WHIRLPOOL_add (pRandPool, RNG_POOL_SIZE, &wctx);

+ case STREEBOG:

+ STREEBOG_init (&stctx);

+ STREEBOG_add (&stctx, pRandPool, RNG_POOL_SIZE);

+ STREEBOG_finalize (&stctx, hashOutputBuffer);

+ break;

+

+ case STREEBOG:

+ burn (&stctx, sizeof(sctx));

+ break;

+

+#define IDR_BOOT_SECTOR_CAMELLIA 558

+#define IDR_BOOT_LOADER_CAMELLIA 559

+#define IDR_RESCUE_BOOT_SECTOR_CAMELLIA 560

+#define IDR_RESCUE_LOADER_CAMELLIA 561

+#define IDR_BOOT_SECTOR_CAMELLIA_SHA2 562

+#define IDR_BOOT_LOADER_CAMELLIA_SHA2 563

+#define IDR_RESCUE_BOOT_SECTOR_CAMELLIA_SHA2 564

+#define IDR_RESCUE_LOADER_CAMELLIA_SHA2 565

+#define IDR_EFI_DCSBOOT 566

+#define IDR_EFI_DCSINT 567

+#define IDR_EFI_DCSCFG 568

+#define IDR_EFI_LEGACYSPEAKER 569

+#define IDR_EFI_DCSBML 570

+#define IDR_EFI_DCSRE 571

+#define IDT_BENCHMARK 5138

+#define IDC_BENCHMARK_LIST 5139

+#define IDC_BENCHMARK_PREBOOT 5140

+//

+#define _APS_NEXT_RESOURCE_VALUE 572

+#define _APS_NEXT_CONTROL_VALUE 5141

+ SecurityTokenKeyfile::SecurityTokenKeyfile (const SecurityTokenKeyfilePath &path)

+ vector <SecurityTokenKeyfile> keyfiles = SecurityToken::GetAvailableKeyfiles (&SlotId, Id);

+ vector <SecurityTokenKeyfile> SecurityToken::GetAvailableKeyfiles (CK_SLOT_ID *slotIdFilter, const wstring keyfileIdFilter)

+ LoginUserIfRequired (slotId);

+ LoginUserIfRequired (keyfile.SlotId);

+ void SecurityToken::LoginUserIfRequired (CK_SLOT_ID slotId)

+ PinCallback->notifyIncorrectPin ();

+ SecurityTokenKeyfile (const SecurityTokenKeyfilePath &path);

+ virtual void notifyIncorrectPin () = 0;

+ static vector <SecurityTokenKeyfile> GetAvailableKeyfiles (CK_SLOT_ID *slotIdFilter = nullptr, const wstring keyfileIdFilter = wstring());

+ static void LoginUserIfRequired (CK_SLOT_ID slotId);

+#if defined(_UEFI)

+#undef _WIN32

+#undef _WIN64

+#undef _DEBUG

+

+#include <Uefi.h>

+#include <Library/BaseLib.h>

+#include <Library/BaseMemoryLib.h>

+

+void* VeraCryptMemAlloc(IN UINTN size);

+void VeraCryptMemFree(IN VOID* ptr);

+

+#define BOOL int

+#ifndef FALSE

+#define FALSE 0

+#define TRUE 1

+#endif

+

+#define max(a,b) ((a)>(b))?(a):(b)

+#define min(a,b) ((a)<(b))?(a):(b)

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+extern unsigned __int64 __cdecl _rotl64(unsigned __int64,int);

+extern unsigned __int64 __cdecl _rotr64(unsigned __int64,int);

+extern unsigned int __cdecl _rotl(unsigned int,int);

+extern unsigned int __cdecl _rotr(unsigned int,int);

+extern unsigned char _rotr8(unsigned char value, unsigned char shift);

+extern unsigned short _rotr16(unsigned short value, unsigned char shift);

+extern unsigned char _rotl8(unsigned char value, unsigned char shift);

+extern unsigned short _rotl16(unsigned short value, unsigned char shift);

+#ifdef __cplusplus

+}

+#endif

+

+#endif // defined(_UEFI)

+

+// Version displayed to user

+#define VERSION_STRING "1.18-BETA9"