return true;

}

{

BOOL bRet = FALSE;

const char* g_szStr1 = "Invalid partition table";

const char* g_szStr2 = "Error loading operating system";

const char* g_szStr3 = "Missing operating system";

}

}

{

Elevate();

}

}

{

Elevate();

public:

static void AddReference () { }

static void CallDriver (DWORD ioctl, void *input, DWORD inputSize, void *output, DWORD outputSize) { throw ParameterIncorrect (SRC_POS); }

static void RegisterFilterDriver (bool registerDriver, BootEncryption::FilterType filterType) { throw ParameterIncorrect (SRC_POS); }

static void Release () { }

static void SetDriverServiceStartType (DWORD startType) { 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 UpdateSetupConfigFile (bool bForInstall) { throw ParameterIncorrect (SRC_POS); }

static void GetSecureBootConfig (BOOL* pSecureBootEnabled, BOOL *pVeraCryptKeysLoaded) { throw ParameterIncorrect (SRC_POS); }

};

FileOpen = false;

}

{

DWORD bytesRead;

dwSize = (DWORD) size64;

}

{

DWORD bytesWritten;

return version;

}

{

BootLoaderFingerprintRequest request;

CallDriver (VC_IOCTL_GET_BOOT_LOADER_FINGERPRINT, NULL, 0, &request, sizeof (request));

}

{

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

device.CheckOpened (SRC_POS);

device.SeekAt (0);

device.Read (mbrBuf, sizeof (mbrBuf));

continue;

}

return true;

}

}

{

uint32 sum = 0;

}

{

if (bufferSize < TC_BOOT_LOADER_AREA_SIZE - TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE)

throw ParameterIncorrect (SRC_POS);

// Boot sector

DWORD size;

if (!bootSecResourceImg || size != TC_SECTOR_SIZE_BIOS)

throw ParameterIncorrect (SRC_POS);

{

Device device (GetSystemDriveConfiguration().DevicePath);

device.CheckOpened (SRC_POS);

device.SeekAt (HiddenOSCandidatePartition.Info.StartingOffset.QuadPart + HiddenOSCandidatePartition.Info.PartitionLength.QuadPart - TC_VOLUME_HEADER_GROUP_SIZE + TC_VOLUME_HEADER_EFFECTIVE_SIZE);

device.Read (headerSector, sizeof (headerSector));

}

// Decompressor

if (!decompressor || size > TC_BOOT_LOADER_DECOMPRESSOR_SECTOR_COUNT * TC_SECTOR_SIZE_BIOS)

throw ParameterIncorrect (SRC_POS);

memcpy (buffer + TC_SECTOR_SIZE_BIOS, decompressor, size);

// Compressed boot loader

if (!bootLoader || size > TC_MAX_BOOT_LOADER_SECTOR_COUNT * TC_SECTOR_SIZE_BIOS)

throw ParameterIncorrect (SRC_POS);

}

// return false when the user cancel an elevation request

{

bool bCanceled = false, bExceptionOccured = false;

try

}

{

Device device (GetSystemDriveConfiguration().DevicePath);

device.CheckOpened (SRC_POS);

device.SeekAt (0);

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

device.SeekAt (0);

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

device.SeekAt (0);

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

throw ErrorException ("ERROR_MBR_PROTECTED", SRC_POS);

}

{

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

{

}

}

{

if (GetSystemDriveConfiguration().SystemPartition.IsGPT)

{

{

Device device (GetSystemDriveConfiguration().DevicePath);

device.CheckOpened (SRC_POS);

device.SeekAt (0);

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

device.SeekAt (0);

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

device.SeekAt (0);

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

unsigned int BootEncryption::GetHiddenOSCreationPhase ()

{

ReadBootSectorConfig (configFlags, sizeof(configFlags));

#if TC_BOOT_CFG_FLAG_AREA_SIZE != 1

# error TC_BOOT_CFG_FLAG_AREA_SIZE != 1; revise GetHiddenOSCreationPhase() and SetHiddenOSCreationPhase()

#endif

ReadBootSectorConfig (configFlags, sizeof(configFlags));

configFlags[0] |= newPhase;

Device device (GetSystemDriveConfiguration().DevicePath);

device.CheckOpened(SRC_POS);

device.SeekAt (0);

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

# error PRAND_DISK_WIPE_PASSES > RNG_POOL_SIZE

#endif

if (!RandgetBytes (ParentWindow, randData, sizeof (randData), FALSE))

throw ParameterIncorrect (SRC_POS);

mbr[TC_BOOT_SECTOR_OUTER_VOLUME_BAK_HEADER_CRC_OFFSET + i] = randData[wipePass];

}

mbr[TC_BOOT_SECTOR_CONFIG_OFFSET] |= randData[wipePass] & TC_BOOT_CFG_MASK_HIDDEN_OS_CREATION_PHASE;

if (wipePass == PRAND_DISK_WIPE_PASSES - 1)

if (loaderSize > 32768)

{

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

uint32 varSize = 56;

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

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

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

*(uint32 *)pVar = attr;

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

// Type

// SubType

// HDD dev path length

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

pVar += 16;

// MbrType

// SigType

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

*(uint16 *)pVar = 0x0404;

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

// only set value if it doesn't already exist

DWORD existingVarLen = GetFirmwareEnvironmentVariableW (varName, EfiVarGuid, existingVar, varSize);

if ((existingVarLen != varSize) || (0 != memcmp (existingVar, startVar, varSize)))

SetFirmwareEnvironmentVariable(varName, EfiVarGuid, startVar, varSize);

wchar_t varName[256];

StringCchPrintfW(varName, ARRAYSIZE (varName), L"%s%04X", type == NULL ? L"Boot" : type, startOrder[0]);

DWORD existingVarLen = GetFirmwareEnvironmentVariableW (varName, EfiVarGuid, existingVar, 512);

if (existingVarLen > 0)

{

if (size1 == size2)

{

// same size, so now we compare content

DWORD remainingBytes = size1, dataToRead;

while (remainingBytes)

return bRet;

}

{

bool bRet = false;

if (existingSize == size)

{

DWORD remainingBytes = size, dataOffset = 0, dataToRead;

while (remainingBytes)

return bRet;

}

wstring path = EfiBootPartPath;

path += name;

f.Close();

}

wstring path = EfiBootPartPath;

path += name;

File f(path, true);

}

DWORD sizeDcsBoot;

#ifdef _WIN64

#else

#endif

if (!dcsBootImg)

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

DWORD sizeDcsInt;

#ifdef _WIN64

#else

#endif

if (!dcsIntImg)

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

DWORD sizeDcsCfg;

#ifdef _WIN64

#else

#endif

if (!dcsCfgImg)

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

DWORD sizeLegacySpeaker;

#ifdef _WIN64

#else

#endif

if (!LegacySpeakerImg)

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

#ifdef VC_EFI_CUSTOM_MODE

DWORD sizeBootMenuLocker;

#ifdef _WIN64

#else

#endif

if (!BootMenuLockerImg)

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

#endif

DWORD sizeDcsInfo;

#ifdef _WIN64

#else

#endif

if (!DcsInfoImg)

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

{

if (loaderSize > 32768)

{

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

// DcsBoot.efi is always smaller than 32KB

if (loaderSize > 32768)

{

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

{

// look for bootmgfw.efi identifiant string

EfiBootInst.GetFileSize(loaderPath.c_str(), loaderSize);

EfiBootInst.ReadFile(loaderPath.c_str(), &bootLoaderBuf[0], (DWORD) loaderSize);

EfiBootInst.GetFileSize(szStdEfiBootloader, loaderSize);

if (loaderSize > 32768)

{

EfiBootInst.ReadFile(szStdEfiBootloader, &bootLoaderBuf[0], (DWORD) loaderSize);

// check if standard bootloader under EFI\Boot is Microsoft one or if it is ours

// if both cases, replace it with our bootloader otherwise do nothing

EfiBootInst.GetFileSize(szStdEfiBootloader, loaderSize);

EfiBootInst.ReadFile(szStdEfiBootloader, &bootLoaderBuf[0], (DWORD) loaderSize);

// look for bootmgfw.efi or VeraCrypt identifiant strings

{

try

{

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

// Write MBR

device.SeekAt (0);

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

device.SeekAt (0);

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

device.SeekAt (0);

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

if (config.SystemPartition.IsGPT)

return true;

bool bRet = false;

try

// create EFI disk structure

DWORD sizeDcsBoot;

#ifdef _WIN64

#else

#endif

if (!dcsBootImg)

throw ParameterIncorrect (SRC_POS);

DWORD sizeDcsInt;

#ifdef _WIN64

#else

#endif

if (!dcsIntImg)

throw ParameterIncorrect (SRC_POS);

DWORD sizeDcsCfg;

#ifdef _WIN64

#else

#endif

if (!dcsCfgImg)

throw ParameterIncorrect (SRC_POS);

DWORD sizeLegacySpeaker;

#ifdef _WIN64

#else

#endif

if (!LegacySpeakerImg)

throw ParameterIncorrect (SRC_POS);

#ifdef VC_EFI_CUSTOM_MODE

DWORD sizeBootMenuLocker;

#ifdef _WIN64

#else

#endif

if (!BootMenuLockerImg)

throw ParameterIncorrect (SRC_POS);

#endif

DWORD sizeDcsRescue;

#ifdef _WIN64

#else

#endif

if (!DcsRescueImg)

throw ParameterIncorrect (SRC_POS);

DWORD sizeDcsInfo;

#ifdef _WIN64

#else

#endif

if (!DcsInfoImg)

throw ParameterIncorrect (SRC_POS);

finally_do_arg (FILE*, ftmpFile, { fclose (finally_arg); });

unsigned long ulZipSize = (unsigned long) _filelength (_fileno (ftmpFile));

if (!RescueZipData)

throw bad_alloc();

{

Buffer imageBuf (RescueIsoImageSize);

memset (image, 0, RescueIsoImageSize);

// Primary volume descriptor

// Boot loader backup

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

if (!RescueIsoImage)

throw bad_alloc();

memcpy (RescueIsoImage, image, RescueIsoImageSize);

if (GetHeaderField32 (RescueVolumeHeader, TC_HEADER_OFFSET_MAGIC) != 0x56455241)

throw ParameterIncorrect (SRC_POS);

mputInt64 (fieldPos, volumeSize);

// CRC of the header fields

device.CheckOpened (SRC_POS);

device.SeekAt (TC_BOOT_VOLUME_HEADER_SECTOR_OFFSET);

}

}

}

unsigned __int64 loaderSize = 0;

const wchar_t * szStdMsBootloader = L"\\EFI\\Microsoft\\Boot\\bootmgfw.efi";

const wchar_t * szBackupMsBootloader = L"\\EFI\\Microsoft\\Boot\\bootmgfw_ms.vc";

const char* g_szMsBootString = "bootmgfw.pdb";

{

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

device.CheckOpened (SRC_POS);

device.SeekAt (0);

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

const char* g_szMsBootString = "bootmgfw.pdb";

unsigned __int64 loaderSize = 0;

EfiBootInst.GetFileSize(loaderPath.c_str(), loaderSize);

EfiBootInst.ReadFile(loaderPath.c_str(), &bootLoaderBuf[0], (DWORD) loaderSize);

}

else

{

File backupFile (GetSystemLoaderBackupPath(), true);

backupFile.CheckOpened(SRC_POS);

device.CheckOpened (SRC_POS);

// Preserve current partition table

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

// Register class filter below all other filters in the stack

size_t strSize = filter.size() + 1;

DWORD size = (DWORD) (sizeof (regKeyBuf) - strSize);

// SetupInstallFromInfSection() does not support prepending of values so we have to modify the registry directly

// read initial value

DWORD strSize = (DWORD) filter.size() + 1, expectedSize;

Buffer expectedRegKeyBuf(65536), outputRegKeyBuf(65536);

DWORD initialSize = (DWORD) (expectedRegKeyBuf.Size() - strSize - 2);

if (RegQueryValueExA (regKey, filterReg.c_str(), NULL, NULL, pbExpectedRegKeyBuf, &initialSize) != ERROR_SUCCESS)

// remove value in case it was not done properly

Buffer regKeyBuf(65536);

DWORD initialSize = (DWORD) regKeyBuf.Size() - 2;

// Verify CRC of header salt

Device device(config.DevicePath, true);

device.CheckOpened(SRC_POS);

device.SeekAt(TC_BOOT_VOLUME_HEADER_SECTOR_OFFSET);

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

throw ParameterIncorrect(SRC_POS);

}

}

}

device.SeekAt (headerOffset);

PCRYPTO_INFO cryptoInfo = NULL;

}

device.SeekAt (headerOffset);

headerUpdated = true;

}

try

{

// check if PIM is stored in MBR

if ( ReadBootSectorConfig (nullptr, 0, &userConfig)

&& (userConfig & TC_BOOT_USER_CFG_FLAG_DISABLE_PIM)

)

return configMap;

}

{

WriteBootDriveSectorRequest request;

request.Offset.QuadPart = offset;