/*

Derived from source code of TrueCrypt 7.1a, which is

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

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

and all other portions of this file are Copyright (c) 2013-2017 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

code distribution packages.

*/

#ifndef TC_HEADER_Boot_BootCommon

#define TC_HEADER_Boot_BootCommon

#include "Common/Password.h"

#include "BootDefs.h"

// The user will be advised to upgrade the rescue disk if upgrading from the following or any previous version

#define TC_RESCUE_DISK_UPGRADE_NOTICE_MAX_VERSION 0x0125

#define TC_BOOT_LOADER_AREA_SIZE (TC_BOOT_LOADER_AREA_SECTOR_COUNT * TC_SECTOR_SIZE_BIOS)

#define TC_BOOT_VOLUME_HEADER_SECTOR (TC_BOOT_LOADER_AREA_SECTOR_COUNT - 1)

#define TC_BOOT_VOLUME_HEADER_SECTOR_OFFSET (TC_BOOT_VOLUME_HEADER_SECTOR * TC_SECTOR_SIZE_BIOS)

#define TC_CD_BOOTSECTOR_OFFSET 0xd000

#define TC_CD_BOOT_LOADER_SECTOR 26

#define TC_ORIG_BOOT_LOADER_BACKUP_SECTOR TC_BOOT_LOADER_AREA_SECTOR_COUNT

#define TC_ORIG_BOOT_LOADER_BACKUP_SECTOR_OFFSET (TC_ORIG_BOOT_LOADER_BACKUP_SECTOR * TC_SECTOR_SIZE_BIOS)

#define TC_BOOT_LOADER_BACKUP_RESCUE_DISK_SECTOR (TC_ORIG_BOOT_LOADER_BACKUP_SECTOR + TC_BOOT_LOADER_AREA_SECTOR_COUNT)

#define TC_BOOT_LOADER_BACKUP_RESCUE_DISK_SECTOR_OFFSET (TC_BOOT_LOADER_BACKUP_RESCUE_DISK_SECTOR * TC_SECTOR_SIZE_BIOS)

#define TC_MBR_SECTOR 0

#define TC_MAX_MBR_BOOT_CODE_SIZE 440

#define TC_MAX_EXTRA_BOOT_PARTITION_SIZE (512UL * 1024UL * 1024UL)

#pragma pack (1)

typedef struct

{

uint8 Flags;

} BootSectorConfiguration;

// Modifying this value can introduce incompatibility with previous versions

#define TC_BOOT_LOADER_ARGS_OFFSET 0x10

typedef struct

{

// Modifying this structure can introduce incompatibility with previous versions

char Signature[8];

uint16 BootLoaderVersion;

uint16 CryptoInfoOffset;

uint16 CryptoInfoLength;

uint32 HeaderSaltCrc32;

uint64 HiddenSystemPartitionStart;

uint64 DecoySystemPartitionStart;

uint32 Flags;

uint32 BootDriveSignature;

uint32 BootArgumentsCrc32;

} BootArguments;

// Modifying these values can introduce incompatibility with previous versions

#define TC_BOOT_ARGS_FLAG_EXTRA_BOOT_PARTITION 0x1

#pragma pack ()

// Boot arguments signature should not be defined as a static string

// Modifying these values can introduce incompatibility with previous versions

#define TC_SET_BOOT_ARGUMENTS_SIGNATURE(SG) do { SG[0] = 'T'; SG[1] = 'R'; SG[2] = 'U'; SG[3] = 'E'; SG[4] = 0x11; SG[5] = 0x23; SG[6] = 0x45; SG[7] = 0x66; } while (FALSE)

#define TC_IS_BOOT_ARGUMENTS_SIGNATURE(SG) (SG[0] == 'T' && SG[1] == 'R' && SG[2] == 'U' && SG[3] == 'E' && SG[4] == 0x11 && SG[5] == 0x23 && SG[6] == 0x45 && SG[7] == 0x66)

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

#define DCS_DISK_ENTRY_LIST_HEADER_SIGN SIGNATURE_64 ('D','C','S','D','E','L','S','T')

#ifndef CSTATIC_ASSERT

#define CSTATIC_ASSERT(b, name) typedef int StaticAssertFailed##name[b ? 1 : -1];

#endif

#define DE_IDX_CRYPTOHEADER 0

#define DE_IDX_LIST 1

#define DE_IDX_DISKID 2

{

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 (...) { }

}

return false;

}

#ifndef SETUP

void BootEncryption::CreateVolumeHeader (uint64 volumeSize, uint64 encryptedAreaStart, Password *password, int ea, int mode, int pkcs5, int pim)

{

PCRYPTO_INFO cryptoInfo = NULL;

if (!IsRandomNumberGeneratorStarted())

throw ParameterIncorrect (SRC_POS);

volumeSize, 0, encryptedAreaStart, 0, TC_SYSENC_KEYSCOPE_MIN_REQ_PROG_VERSION, TC_HEADER_FLAG_ENCRYPTED_SYSTEM, TC_SECTOR_SIZE_BIOS, FALSE) != 0);

finally_do_arg (PCRYPTO_INFO*, &cryptoInfo, { crypto_close (*finally_arg); });

// Initial rescue disk assumes encryption of the drive has been completed (EncryptedAreaLength == volumeSize)

memcpy (RescueVolumeHeader, VolumeHeader, sizeof (RescueVolumeHeader));

throw ParameterIncorrect (SRC_POS);

DecryptBuffer (RescueVolumeHeader + HEADER_ENCRYPTED_DATA_OFFSET, HEADER_ENCRYPTED_DATA_SIZE, cryptoInfo);

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

throw ParameterIncorrect (SRC_POS);

uint8 *fieldPos = RescueVolumeHeader + TC_HEADER_OFFSET_ENCRYPTED_AREA_LENGTH;

mputInt64 (fieldPos, volumeSize);

// CRC of the header fields

uint32 crc = GetCrc32 (RescueVolumeHeader + TC_HEADER_OFFSET_MAGIC, TC_HEADER_OFFSET_HEADER_CRC - TC_HEADER_OFFSET_MAGIC);

fieldPos = RescueVolumeHeader + TC_HEADER_OFFSET_HEADER_CRC;

mputLong (fieldPos, crc);

EncryptBuffer (RescueVolumeHeader + HEADER_ENCRYPTED_DATA_OFFSET, HEADER_ENCRYPTED_DATA_SIZE, cryptoInfo);

VolumeHeaderValid = true;

RescueVolumeHeaderValid = true;

}

void BootEncryption::InstallVolumeHeader ()

{

if (!VolumeHeaderValid)

throw ParameterIncorrect (SRC_POS);

Device device (GetSystemDriveConfiguration().DevicePath);

device.CheckOpened (SRC_POS);

RegisterSystemFavoritesService (FALSE);

}

catch (...) { }

try

{

if (displayWaitDialog)

DisplayStaticModelessWaitDlg (ParentWindow);

finally_do_arg (bool, displayWaitDialog, { if (finally_arg) CloseStaticModelessWaitDlg(); });

RestoreSystemLoader ();

}

catch (Exception &e)

{

e.Show (ParentWindow);

throw ErrorException ("SYS_LOADER_RESTORE_FAILED", SRC_POS);

}

}

int BootEncryption::ChangePassword (Password *oldPassword, int old_pkcs5, int old_pim, Password *newPassword, int pkcs5, int pim, int wipePassCount, HWND hwndDlg)

{

BootEncryptionStatus encStatus = GetStatus();

if (encStatus.SetupInProgress || (wipePassCount <= 0))

throw ParameterIncorrect (SRC_POS);

SystemDriveConfiguration config = GetSystemDriveConfiguration ();

Device device (config.DevicePath);

device.CheckOpened (SRC_POS);

// Only one algorithm is currently supported

if (pkcs5 != 0)

throw ParameterIncorrect (SRC_POS);

int64 headerOffset = TC_BOOT_VOLUME_HEADER_SECTOR_OFFSET;

int64 backupHeaderOffset = -1;

if (encStatus.HiddenSystem)

{

headerOffset = encStatus.HiddenSystemPartitionStart + TC_HIDDEN_VOLUME_HEADER_OFFSET;

// Find hidden system partition

foreach (const Partition &partition, config.Partitions)

{

if (partition.Info.StartingOffset.QuadPart == encStatus.HiddenSystemPartitionStart)

{

backupHeaderOffset = partition.Info.StartingOffset.QuadPart + partition.Info.PartitionLength.QuadPart - TC_VOLUME_HEADER_SIZE;

break;

}

}

if (backupHeaderOffset == -1)

throw ParameterIncorrect (SRC_POS);

}

device.SeekAt (headerOffset);

PCRYPTO_INFO cryptoInfo = NULL;

int status = ReadVolumeHeader (!encStatus.HiddenSystem, header, oldPassword, old_pkcs5, old_pim, &cryptoInfo, NULL);

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

// if the XTS master key is vulnerable, return error and do not allow the user to change the password since the master key will not be changed

if ((status == 0) && cryptoInfo->bVulnerableMasterKey)

status = ERR_SYSENC_XTS_MASTERKEY_VULNERABLE;

if (status != 0)

{

handleError (hwndDlg, status, SRC_POS);

return status;

}

// Change the PKCS-5 PRF if requested by user

if (pkcs5 != 0)

{

cryptoInfo->pkcs5 = pkcs5;

RandSetHashFunction (pkcs5);

}

if (Randinit() != 0)

{

if (CryptoAPILastError == ERROR_SUCCESS)

throw RandInitFailed (SRC_POS, GetLastError ());

else

throw CryptoApiFailed (SRC_POS, CryptoAPILastError);

}

#include "Fat.h"

#include "Volumes.h"

#include "Apidrvr.h"

#include "Common.h"

#include "Cache.h"

Password CachedPasswords[CACHE_SIZE];

int CachedPim[CACHE_SIZE];

int cacheEmpty = 1;

static int nPasswordIdx = 0;

#ifdef _WIN64

uint64 VcGetPasswordEncryptionID (Password* pPassword)

{

return ((uint64) pPassword->Text) + ((uint64) pPassword);

}

void VcProtectPassword (Password* pPassword, uint64 encID)

{

VcProtectMemory (encID, (unsigned char*) pPassword->Text, sizeof(pPassword->Text), (unsigned char*) &pPassword->Length, sizeof (pPassword->Length));

}

void VcUnprotectPassword (Password* pPassword, uint64 encID)

{

VcProtectPassword (pPassword, encID);

}

#endif

{

int nReturnCode = ERR_PASSWORD_WRONG;

int i, effectivePim;

/* Attempt to recognize volume using mount password */

if (password->Length > 0)

{

nReturnCode = ReadVolumeHeader (bBoot, header, password, pkcs5_prf, pim, retInfo, NULL);

/* Save mount passwords back into cache if asked to do so */

if (bCache && (nReturnCode == 0 || nReturnCode == ERR_CIPHER_INIT_WEAK_KEY))

{

#ifdef _WIN64

Password tmpPass;

#endif

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

{

Password* pCurrentPassword = &CachedPasswords[i];

#ifdef _WIN64

if (IsRamEncryptionEnabled())

{

memcpy (&tmpPass, pCurrentPassword, sizeof (Password));

VcUnprotectPassword (&tmpPass, VcGetPasswordEncryptionID (pCurrentPassword));

pCurrentPassword = &tmpPass;

}

#endif

if (memcmp (pCurrentPassword, password, sizeof (Password)) == 0)

break;

}

/*

Legal Notice: Some portions of the source code contained in this file were

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

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

governed by the TrueCrypt License 3.0, also from the source code of

Encryption for the Masses 2.02a, which is Copyright (c) 1998-2000 Paul Le Roux

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)

and all other portions of this file are Copyright (c) 2013-2017 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

code distribution packages. */

#include "Common.h"

#ifndef CACHE_SIZE

/* WARNING: Changing this value might not be safe (some items may be hard coded for 4)! Inspection necessary. */

#define CACHE_SIZE 4

#endif

extern int cacheEmpty;

void AddPasswordToCache (Password *password, int pim, BOOL bCachePim);

void AddLegacyPasswordToCache (PasswordLegacy *password, int pim);

void WipeCache (void);

while (i = EAGetNextCipher (ea, i))

{

size += CipherGetKeySize (i);

}

return size;

}

#ifndef TC_WINDOWS_BOOT

// Returns the first mode of operation of EA

int EAGetFirstMode (int ea)

{

return (EncryptionAlgorithms[ea].Modes[0]);

}

int EAGetNextMode (int ea, int previousModeId)

{

int c, i = 0;

while (c = EncryptionAlgorithms[ea].Modes[i++])

{

if (c == previousModeId)

return EncryptionAlgorithms[ea].Modes[i];

}

return 0;

}

{

switch (mode)

{

case XTS:

return L"XTS";

}

}

#endif // TC_WINDOWS_BOOT

// Returns sum of key schedule sizes of all ciphers of the EA

int EAGetKeyScheduleSize (int ea)

{

int i = EAGetFirstCipher(ea);

int size = CipherGetKeyScheduleSize (i);

while (i = EAGetNextCipher(ea, i))

{

size += CipherGetKeyScheduleSize (i);

}

return size;

}

#ifndef TC_WINDOWS_BOOT

// Returns number of ciphers in EA

int EAGetCipherCount (int ea)

{

int i = 0;

while (EncryptionAlgorithms[ea].Ciphers[i++]);

return i - 1;

}

{

#ifndef TC_WINDOWS_BOOT

/* Do the crt allocation */

PCRYPTO_INFO cryptoInfo = (PCRYPTO_INFO) TCalloc (sizeof (CRYPTO_INFO));

if (cryptoInfo == NULL)

return NULL;

memset (cryptoInfo, 0, sizeof (CRYPTO_INFO));

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

VirtualLock (cryptoInfo, sizeof (CRYPTO_INFO));

#endif

cryptoInfo->ea = -1;

return cryptoInfo;

#else // TC_WINDOWS_BOOT

#if 0

if (CryptoInfoBufferInUse)

TC_THROW_FATAL_EXCEPTION;

#endif

CryptoInfoBufferInUse = 1;

return &CryptoInfoBuffer;

#endif // TC_WINDOWS_BOOT

}

#ifndef TC_WINDOWS_BOOT

{

keyInfo->keyLength = nUserKeyLen;

burn (keyInfo->userKey, sizeof (keyInfo->userKey));

memcpy (keyInfo->userKey, lpszUserKey, nUserKeyLen);

}

void crypto_eraseKeys (PCRYPTO_INFO cryptoInfo)

{

burn (cryptoInfo->ks, sizeof (cryptoInfo->ks));

burn (cryptoInfo->ks2, sizeof (cryptoInfo->ks2));

#ifdef TC_WINDOWS_DRIVER

burn (cryptoInfo->master_keydata_hash, sizeof (cryptoInfo->master_keydata_hash));

#else

burn (cryptoInfo->master_keydata, sizeof (cryptoInfo->master_keydata));

burn (cryptoInfo->k2, sizeof (cryptoInfo->k2));

#endif

burn (&cryptoInfo->noIterations, sizeof (cryptoInfo->noIterations));

burn (&cryptoInfo->volumePim, sizeof (cryptoInfo->volumePim));

}

#endif

void crypto_close (PCRYPTO_INFO cryptoInfo)

{

#ifndef TC_WINDOWS_BOOT

if (cryptoInfo != NULL)

{

burn (cryptoInfo, sizeof (CRYPTO_INFO));

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

VirtualUnlock (cryptoInfo, sizeof (CRYPTO_INFO));

return 0;

#else

return (HasAESNI() && !HwEncryptionDisabled)? TRUE : FALSE;

#endif

}

void EnableHwEncryption (BOOL enable)

{

#if defined (TC_WINDOWS_BOOT)

if (enable)

aes_hw_cpu_enable_sse();

#endif

HwEncryptionDisabled = !enable;

}

BOOL IsHwEncryptionEnabled ()

{

return !HwEncryptionDisabled;

}

#endif // !TC_WINDOWS_BOOT

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

static BOOL CpuRngDisabled = TRUE;

static BOOL RamEncryptionEnabled = FALSE;

BOOL IsCpuRngSupported ()

{

if (HasRDSEED() || HasRDRAND())

return TRUE;

else

return FALSE;

}

void EnableCpuRng (BOOL enable)

{

CpuRngDisabled = !enable;

}

BOOL IsCpuRngEnabled ()

{

return !CpuRngDisabled;

}

BOOL IsRamEncryptionSupported ()

{

#ifdef _WIN64

if (t1ha_selfcheck__t1ha2() == 0)

return TRUE;

else

return FALSE;

#else

return FALSE;

#endif

}

void EnableRamEncryption (BOOL enable)

{

RamEncryptionEnabled = enable;

}

return 0x7F;

if (count >= 32)

return 0x3F;

if (count >= 16)

return 0x1F;

if (count >= 8)

return 0x0F;

if (count >= 4)

return 0x07;

if (count >= 2)

return 0x03;

return 1;

}

uint8 GetRandomIndex (ChaCha20RngCtx* pCtx, uint8 elementsCount)

{

uint8 index = 0;

uint8 mask = GetRngMask (elementsCount);

while (TRUE)

{

ChaCha20RngGetBytes (pCtx, &index, 1);

index &= mask;

if (index < elementsCount)

break;

}

return index;

}

/* declaration of variables and functions used for RAM encryption on 64-bit build */

static uint8* pbKeyDerivationArea = NULL;

static ULONG cbKeyDerivationArea = 0;

static uint64 HashSeedMask = 0;

static uint64 CipherIVMask = 0;

#ifdef TC_WINDOWS_DRIVER

ULONG AllocTag = 'MMCV';

#endif

#if !defined(PAGE_SIZE)

#define PAGE_SIZE 4096

#endif

BOOL InitializeSecurityParameters(GetRandSeedFn rngCallback)

{

ChaCha20RngCtx ctx;

uint8 pbSeed[CHACHA20RNG_KEYSZ + CHACHA20RNG_IVSZ];

#ifdef TC_WINDOWS_DRIVER

uint8 i;

char randomStr[4];

Dump ("InitializeSecurityParameters BEGIN\n");

#endif

rngCallback (pbSeed, sizeof (pbSeed));

ChaCha20RngInit (&ctx, pbSeed, rngCallback, 0);

#ifdef TC_WINDOWS_DRIVER

#include "blake2.h"

#ifndef TC_WINDOWS_BOOT

# include "Sha2.h"

# include "Whirlpool.h"

# include "Streebog.h"

# include "kuznyechik.h"

# include "Camellia.h"

#if !defined (_UEFI)

# include "chachaRng.h"

# ifdef _WIN64

# include "t1ha.h"

# endif

#endif

#else

# include "CamelliaSmall.h"

#endif

#include "GfMul.h"

#include "Password.h"

#ifndef TC_WINDOWS_BOOT

#include "config.h"

typedef struct keyInfo_t

{

int noIterations; /* Number of times to iterate (PKCS-5) */

int keyLength; /* Length of the key */

uint64 dummy; /* Dummy field to ensure 16-byte alignment of this structure */

} KEY_INFO, *PKEY_INFO;

#endif

typedef struct CRYPTO_INFO_t

{

int ea; /* Encryption algorithm ID */

int mode; /* Mode of operation (e.g., XTS) */

int pkcs5; /* PRF algorithm */

unsigned __int8 ks[MAX_EXPANDED_KEY]; /* Primary key schedule (if it is a cascade, it conatins multiple concatenated keys) */

unsigned __int8 ks2[MAX_EXPANDED_KEY]; /* Secondary key schedule (if cascade, multiple concatenated) for XTS mode. */

BOOL hiddenVolume; // Indicates whether the volume is mounted/mountable as hidden volume

#ifndef TC_WINDOWS_BOOT

uint16 HeaderVersion;

#ifdef TC_WINDOWS_DRIVER

unsigned __int8 master_keydata_hash[BLAKE2S_DIGESTSIZE];

#else

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

#endif

int noIterations;

int volumePim;

BOOL bProtectHiddenVolume; // Indicates whether the volume contains a hidden volume to be protected against overwriting

BOOL bHiddenVolProtectionAction; // TRUE if a write operation has been denied by the driver in order to prevent the hidden volume from being overwritten (set to FALSE upon volume mount).

#endif // !TC_WINDOWS_BOOT

UINT64_STRUCT VolumeSize;

UINT64_STRUCT EncryptedAreaStart;

UINT64_STRUCT EncryptedAreaLength;

uint32 HeaderFlags;

} CRYPTO_INFO, *PCRYPTO_INFO;

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

#pragma pack (push)

#pragma pack(1)

typedef struct BOOT_CRYPTO_HEADER_t

{

__int16 ea; /* Encryption algorithm ID */

__int16 mode; /* Mode of operation (e.g., XTS) */

__int16 pkcs5; /* PRF algorithm */

} BOOT_CRYPTO_HEADER, *PBOOT_CRYPTO_HEADER;

#pragma pack (pop)

#endif

PCRYPTO_INFO crypto_open (void);

#ifndef TC_WINDOWS_BOOT

void crypto_eraseKeys (PCRYPTO_INFO cryptoInfo);

#endif

void crypto_close (PCRYPTO_INFO cryptoInfo);

int CipherGetBlockSize (int cipher);

int CipherGetKeySize (int cipher);

int CipherGetKeyScheduleSize (int cipher);

BOOL CipherSupportsIntraDataUnitParallelization (int cipher);

#ifndef TC_WINDOWS_BOOT

const wchar_t * CipherGetName (int cipher);

#endif

int CipherInit (int cipher, unsigned char *key, unsigned char *ks);

#ifndef TC_WINDOWS_BOOT_SINGLE_CIPHER_MODE

int EAInit (int ea, unsigned char *key, unsigned char *ks);

#else

int EAInit (unsigned char *key, unsigned char *ks);

#endif

BOOL EAInitMode (PCRYPTO_INFO ci, unsigned char* key2);

void EncipherBlock(int cipher, void *data, void *ks);

void DecipherBlock(int cipher, void *data, void *ks);

#ifndef TC_WINDOWS_BOOT

void EncipherBlocks (int cipher, void *dataPtr, void *ks, size_t blockCount);

void DecipherBlocks (int cipher, void *dataPtr, void *ks, size_t blockCount);

#endif

int EAGetFirst ();

int EAGetCount (void);

int EAGetNext (int previousEA);

#ifndef TC_WINDOWS_BOOT

wchar_t * EAGetName (wchar_t *buf, size_t bufLen, int ea, int guiDisplay);

int EAGetByName (wchar_t *name);

#endif

int EAGetKeySize (int ea);

int EAGetFirstMode (int ea);

int EAGetNextMode (int ea, int previousModeId);

#ifndef TC_WINDOWS_BOOT

#endif

int EAGetKeyScheduleSize (int ea);

int EAGetLargestKey ();

int EAGetLargestKeyForMode (int mode);

int EAGetCipherCount (int ea);

int EAGetFirstCipher (int ea);

int EAGetLastCipher (int ea);

int EAGetNextCipher (int ea, int previousCipherId);

int EAGetPreviousCipher (int ea, int previousCipherId);

#ifndef TC_WINDOWS_BOOT

int EAIsFormatEnabled (int ea);

int EAIsMbrSysEncEnabled (int ea);

#endif

BOOL EAIsModeSupported (int ea, int testedMode);

#ifndef TC_WINDOWS_BOOT

const wchar_t *HashGetName (int hash_algo_id);

#ifdef _WIN32

int HashGetIdByName (wchar_t *name);

#endif

Hash *HashGet (int id);

void HashGetName2 (wchar_t *buf, size_t bufLen, int hashId);

BOOL HashIsDeprecated (int hashId);

BOOL HashForSystemEncryption (int hashId);

int GetMaxPkcs5OutSize (void);

#endif

GENERIC_READ,

FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);

if (src == INVALID_HANDLE_VALUE)

return FALSE;

dst = CreateFileW (destinationFile,

GENERIC_WRITE,

0, NULL, CREATE_ALWAYS, 0, NULL);

if (dst == INVALID_HANDLE_VALUE)

{

CloseHandle (src);

return FALSE;

}

return TCCopyFileBase (src, dst);

}

BOOL VerifyModuleSignature (const wchar_t* path)

{

#if defined(NDEBUG) && !defined (VC_SKIP_OS_DRIVER_REQ_CHECK)

BOOL bResult = FALSE;

HRESULT hResult;

GUID gActionID = WINTRUST_ACTION_GENERIC_VERIFY_V2;

WINTRUST_FILE_INFO fileInfo = {0};

WINTRUST_DATA WVTData = {0};

wchar_t filePath [TC_MAX_PATH + 1024];

// Strip quotation marks (if any)

if (path [0] == L'"')

{

StringCbCopyW (filePath, sizeof(filePath), path + 1);

}

else

{

StringCbCopyW (filePath, sizeof(filePath), path);

}

// Strip quotation marks (if any)

if (filePath [wcslen (filePath) - 1] == L'"')

filePath [wcslen (filePath) - 1] = 0;

fileInfo.cbStruct = sizeof(WINTRUST_FILE_INFO);

fileInfo.pcwszFilePath = filePath;

fileInfo.hFile = NULL;

WVTData.cbStruct = sizeof(WINTRUST_DATA);

WVTData.dwUIChoice = WTD_UI_NONE;

WVTData.fdwRevocationChecks = WTD_REVOKE_NONE;

WVTData.dwUnionChoice = WTD_CHOICE_FILE;

WVTData.pFile = &fileInfo;

WVTData.dwStateAction = WTD_STATEACTION_VERIFY;

WVTData.dwProvFlags = WTD_REVOCATION_CHECK_NONE | WTD_CACHE_ONLY_URL_RETRIEVAL;

hResult = WinVerifyTrust(0, &gActionID, &WVTData);

if (0 == hResult)

{

PCRYPT_PROVIDER_DATA pProviderData = WTHelperProvDataFromStateData (WVTData.hWVTStateData);

// activate process mitigations (currently only ASLR, dynamic code and extensions points)

ActivateProcessMitigations();

#ifndef SETUP

// call ActivateMemoryProtection if corresponding setting has been enabled (default is enabled)

if (ReadMemoryProtectionConfig())

{

ActivateMemoryProtection();

}

#endif

return wWinMainCRTStartup();

}

}

#endif

/* InitApp - initialize the application, this function is called once in the

applications WinMain function, but before the main dialog has been created */

void InitApp (HINSTANCE hInstance, wchar_t *lpszCommandLine)

{

WNDCLASSW wc;

char langId[6];

SetDefaultDllDirectoriesPtr SetDefaultDllDirectoriesFn = NULL;

#if !defined(SETUP)

wchar_t modPath[MAX_PATH];

#endif

INITCOMMONCONTROLSEX InitCtrls;

InitOSVersionInfo();

{

}

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

if (!SetDefaultDllDirectoriesFn)

{

// This can happen only if KB2533623 is missing from Windows 7

AbortProcessDirect(L"VeraCrypt requires KB2533623 to be installed on Windows 7 and Windows Server 2008 R2 in order to run.");

}

VirtualLock (&CmdTokenPin, sizeof (CmdTokenPin));

InitGlobalLocks ();

// call InitCommonControlsEx function to initialize the common controls

InitCtrls.dwSize = sizeof (InitCtrls);

InitCtrls.dwICC = ICC_WIN95_CLASSES | ICC_PAGESCROLLER_CLASS | ICC_NATIVEFNTCTL_CLASS | ICC_STANDARD_CLASSES | ICC_LINK_CLASS;

InitCommonControlsEx (&InitCtrls);

// Load RichEdit library in order to be able to use RichEdit20W class

LoadLibraryEx (L"Riched20.dll", NULL, LOAD_LIBRARY_SEARCH_SYSTEM32);

#if !defined(SETUP)

GetModuleFileNameW (NULL, modPath, ARRAYSIZE (modPath));

if (!VerifyModuleSignature (modPath))

AbortProcessDirect (L"This distribution package is damaged. Please try downloading it again (preferably from the official VeraCrypt website at https://www.veracrypt.fr).");

#endif

#ifndef SETUP

/* enable drag-n-drop when we are running elevated */

AllowMessageInUIPI (WM_DROPFILES);

STREEBOG_init(&stctx);

STREEBOG_add(&stctx, lpTestBuffer, benchmarkBufferSize);

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

break;

}

#endif

}

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:

/* Measures the time that it takes for the PKCS-5 routine to derive a header key using

each of the implemented PRF algorithms.

*/

{

int thid, i;

char *tmp_salt = {"\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF\x01\x23\x45\x67\x89\xAB\xCD\xEF\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF\x01\x23\x45\x67\x89\xAB\xCD\xEF\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF"};

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

{

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

continue;

if (QueryPerformanceCounter (&performanceCountStart) == 0)

goto counter_error;

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

{

switch (thid)

{

case SHA512:

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

break;

case SHA256:

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

break;

#ifndef WOLFCRYPT_BACKEND

case BLAKE2S:

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

break;

case WHIRLPOOL:

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

break;

case STREEBOG:

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

break;

}

#endif

}

if (QueryPerformanceCounter (&performanceCountEnd) == 0)

goto counter_error;

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

benchmarkTable[benchmarkTotalItems].id = thid;

benchmarkTable[benchmarkTotalItems].decSpeed = get_pkcs5_iteration_count(thid, benchmarkPim, 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

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

if (EAGetCipherCount (ci->ea) == 1 && EAGetFirstCipher (ci->ea) == idTestCipher)

break;

if ((tmpRetVal = EAInit (ci->ea, (unsigned char *) key, ci->ks)) != ERR_SUCCESS)

{

handleError (hwndDlg, tmpRetVal, SRC_POS);

crypto_close (ci);

return 1;

}

memcpy (&ci->k2, secondaryKey, sizeof (secondaryKey));

if (!EAInitMode (ci, ci->k2))

{

crypto_close (ci);

return 1;

}

structDataUnitNo.Value = BE64(((unsigned __int64 *)dataUnitNo)[0]);

if (bEncrypt)

EncryptBufferXTS ((unsigned char *) tmp, pt, &structDataUnitNo, blockNo, (unsigned char *) (ci->ks), (unsigned char *) ci->ks2, idTestCipher);

else

DecryptBufferXTS ((unsigned char *) tmp, pt, &structDataUnitNo, blockNo, (unsigned char *) (ci->ks), (unsigned char *) ci->ks2, idTestCipher);

crypto_close (ci);

}

else

{

if (bEncrypt)

{

EncipherBlock(idTestCipher, tmp, ks_tmp);

}

else

{

DecipherBlock(idTestCipher, tmp, ks_tmp);

}

}

*szTmp = 0;

for (n = 0; n < pt; n ++)

{

wchar_t szTmp2[3];

StringCbPrintfW(szTmp2, sizeof(szTmp2), L"%02x", (int)((unsigned char)tmp[n]));

StringCbCatW(szTmp, sizeof(szTmp), szTmp2);

}

if (bEncrypt)

SetWindowText(GetDlgItem(hwndDlg,IDC_CIPHERTEXT), szTmp);

else

SetWindowText(GetDlgItem(hwndDlg,IDC_PLAINTEXT), szTmp);

}

return 1;

}

if (lw == IDCLOSE || lw == IDCANCEL)

return (BYTE *) LockResource (hResL);

}

void InconsistencyResolved (char *techInfo)

{

wchar_t finalMsg[8024];

StringCbPrintfW (finalMsg, sizeof(finalMsg), GetString ("INCONSISTENCY_RESOLVED"), techInfo);

MessageBoxW (MainDlg, finalMsg, lpszTitle, MB_ICONWARNING | MB_SETFOREGROUND | MB_TOPMOST);

}

void ReportUnexpectedState (const char *techInfo)

{

wchar_t finalMsg[8024];

StringCbPrintfW (finalMsg, sizeof(finalMsg), GetString ("UNEXPECTED_STATE"), techInfo);

MessageBoxW (MainDlg, finalMsg, lpszTitle, MB_ICONERROR | MB_SETFOREGROUND | MB_TOPMOST);

}

#ifndef SETUP

int OpenVolume (OpenVolumeContext *context, const wchar_t *volumePath, Password *password, int pkcs5_prf, int pim, BOOL write, BOOL preserveTimestamps, BOOL useBackupHeader)

{

int status = ERR_PARAMETER_INCORRECT;

int volumeType;

wchar_t szDiskFile[TC_MAX_PATH], szCFDevice[TC_MAX_PATH];

wchar_t szDosDevice[TC_MAX_PATH];

LARGE_INTEGER headerOffset;

DWORD dwResult;

DISK_GEOMETRY_EX deviceGeometry;

context->VolumeIsOpen = FALSE;

context->CryptoInfo = NULL;

context->HostFileHandle = INVALID_HANDLE_VALUE;

context->TimestampsValid = FALSE;

CreateFullVolumePath (szDiskFile, sizeof(szDiskFile), volumePath, &context->IsDevice);

if (context->IsDevice)

{

status = FakeDosNameForDevice (szDiskFile, szDosDevice, sizeof(szDosDevice), szCFDevice, sizeof(szCFDevice), FALSE);

if (status != 0)

return status;

preserveTimestamps = FALSE;

if (!GetDriveGeometry (volumePath, &deviceGeometry))

{

status = ERR_OS_ERROR;

goto error;

}

}

else

StringCbCopyW (szCFDevice, sizeof(szCFDevice), szDiskFile);

context->HostFileHandle = CreateFile (szCFDevice, GENERIC_READ | (write ? GENERIC_WRITE : (!context->IsDevice && preserveTimestamps? FILE_WRITE_ATTRIBUTES : 0)), FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);

SetLastError (sysError);

return status;

}

void CloseVolume (OpenVolumeContext *context)

{

if (!context->VolumeIsOpen)

return;

if (context->HostFileHandle != INVALID_HANDLE_VALUE)

{

if (context->TimestampsValid)

SetFileTime (context->HostFileHandle, &context->CreationTime, &context->LastAccessTime, &context->LastWriteTime);

CloseHandle (context->HostFileHandle);

context->HostFileHandle = INVALID_HANDLE_VALUE;

}

if (context->CryptoInfo)

{

crypto_close (context->CryptoInfo);

context->CryptoInfo = NULL;

}

context->VolumeIsOpen = FALSE;

}

{

CRYPTO_INFO *newCryptoInfo = NULL;

RandSetHashFunction (cryptoInfo->pkcs5);

if (Randinit() != ERR_SUCCESS)

{

if (CryptoAPILastError == ERROR_SUCCESS)

return ERR_RAND_INIT_FAILED;

else

return ERR_CAPI_INIT_FAILED;

}

UserEnrichRandomPool (NULL);

int status = CreateVolumeHeaderInMemory (hwndDlg, bBoot,

buffer,

cryptoInfo->ea,

cryptoInfo->mode,

password,

cryptoInfo->pkcs5,

pim,

(char *) cryptoInfo->master_keydata,

&newCryptoInfo,

cryptoInfo->VolumeSize.Value,

cryptoInfo->hiddenVolume ? cryptoInfo->hiddenVolumeSize : 0,

cryptoInfo->EncryptedAreaStart.Value,

cryptoInfo->EncryptedAreaLength.Value,

cryptoInfo->RequiredProgramVersion,

cryptoInfo->HeaderFlags,

BOOL CALLBACK CloseTCWindowsEnum( HWND hwnd, LPARAM lParam);

BOOL CALLBACK FindTCWindowEnum (HWND hwnd, LPARAM lParam);

BYTE *MapResource (wchar_t *resourceType, int resourceId, PDWORD size);

void InconsistencyResolved (char *msg);

void ReportUnexpectedState (const char *techInfo);

void OpenOnlineHelp ();

BOOL GetPartitionInfo (const wchar_t *deviceName, PPARTITION_INFORMATION rpartInfo);

BOOL GetDeviceInfo (const wchar_t *deviceName, DISK_PARTITION_INFO_STRUCT *info);

BOOL GetDriveGeometry (const wchar_t *deviceName, PDISK_GEOMETRY_EX diskGeometry);

BOOL GetPhysicalDriveGeometry (int driveNumber, PDISK_GEOMETRY diskGeometry);

BOOL IsVolumeDeviceHosted (const wchar_t *lpszDiskFile);

int CompensateXDPI (int val);

int CompensateYDPI (int val);

int CompensateDPIFont (int val);

int GetTextGfxWidth (HWND hwndDlgItem, const wchar_t *text, HFONT hFont);

int GetTextGfxHeight (HWND hwndDlgItem, const wchar_t *text, HFONT hFont);

BOOL ToHyperlink (HWND hwndDlg, UINT ctrlId);

BOOL ToCustHyperlink (HWND hwndDlg, UINT ctrlId, HFONT hFont);

void DisableCloseButton (HWND hwndDlg);

void EnableCloseButton (HWND hwndDlg);

void ToBootPwdField (HWND hwndDlg, UINT ctrlId);

void ToNormalPwdField (HWND hwndDlg, UINT ctrlId);

void AccommodateTextField (HWND hwndDlg, UINT ctrlId, BOOL bFirstUpdate, HFONT hFont);

void AccommodateCheckBoxTextWidth (HWND hwndDlg, UINT ctrlId);

void MakeControlsContiguous(HWND hwndDlg, UINT ctrl1ID, UINT ctrl2ID);

BOOL GetDriveLabel (int driveNo, wchar_t *label, int labelSize);

BOOL GetSysDevicePaths (HWND hwndDlg);

BOOL DoDriverInstall (HWND hwndDlg);

int OpenVolume (OpenVolumeContext *context, const wchar_t *volumePath, Password *password, int pkcs5_prf, int pim, BOOL write, BOOL preserveTimestamps, BOOL useBackupHeader);

void CloseVolume (OpenVolumeContext *context);

BOOL IsPagingFileActive (BOOL checkNonWindowsPartitionsOnly);

BOOL IsPagingFileWildcardActive ();

BOOL DisablePagingFile ();

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

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

BOOL InitSecurityTokenLibrary (HWND hwndDlg);

BOOL FileHasReadOnlyAttribute (const wchar_t *path);

BOOL IsFileOnReadOnlyFilesystem (const wchar_t *path);

void CheckFilesystem (HWND hwndDlg, int driveNo, BOOL fixErrors);

BOOL BufferContainsPattern (const uint8 *buffer, size_t bufferSize, const uint8 *pattern, size_t patternSize);

BOOL BufferContainsString (const uint8 *buffer, size_t bufferSize, const char *str);

BOOL BufferContainsWideString (const uint8 *buffer, size_t bufferSize, const wchar_t *str);

int AskNonSysInPlaceEncryptionResume (HWND hwndDlg, BOOL* pbDecrypt);

BOOL RemoveDeviceWriteProtection (HWND hwndDlg, wchar_t *devicePath);

void EnableElevatedCursorChange (HWND parent);

BOOL DisableFileCompression (HANDLE file);

BOOL VolumePathExists (const wchar_t *volumePath);

BOOL IsWindowsIsoBurnerAvailable ();

BOOL LaunchWindowsIsoBurner (HWND hwnd, const wchar_t *isoPath);

BOOL IsApplicationInstalled (const wchar_t *appName);

int GetPim (HWND hwndDlg, UINT ctrlId, int defaultPim);

void SetPim (HWND hwndDlg, UINT ctrlId, int pim);

BOOL GetPassword (HWND hwndDlg, UINT ctrlID, char* passValue, int bufSize, BOOL bLegacyPassword, BOOL bShowError);

void SetPassword (HWND hwndDlg, UINT ctrlID, char* passValue);

void HandleShowPasswordFieldAction (HWND hwndDlg, UINT checkBoxId, UINT edit1Id, UINT edit2Id);

HKEY OpenDeviceClassRegKey (const GUID *deviceClassGuid);

LSTATUS DeleteRegistryKey (HKEY, LPCTSTR);

HIMAGELIST CreateImageList(int cx, int cy, UINT flags, int cInitial, int cGrow);

int AddBitmapToImageList(HIMAGELIST himl, HBITMAP hbmImage, HBITMAP hbmMask);

HRESULT VCStrDupW(LPCWSTR psz, LPWSTR *ppwsz);

WorkItemReady,

WorkItemBusy

} WorkItemState;

typedef struct EncryptionThreadPoolWorkItemStruct

{

WorkItemState State;

EncryptionThreadPoolWorkType Type;

TC_EVENT ItemCompletedEvent;

struct EncryptionThreadPoolWorkItemStruct *FirstFragment;

LONG OutstandingFragmentCount;

union

{

struct

{

PCRYPTO_INFO CryptoInfo;

uint8 *Data;

UINT64_STRUCT StartUnitNo;

uint32 UnitCount;

} Encryption;

struct

{

TC_EVENT *CompletionEvent;

LONG *CompletionFlag;

int IterationCount;

TC_EVENT *NoOutstandingWorkItemEvent;

LONG *OutstandingWorkItemCount;

int PasswordLength;

int Pkcs5Prf;

} KeyDerivation;

struct

{

TC_EVENT *KeyDerivationCompletedEvent;

TC_EVENT *NoOutstandingWorkItemEvent;

LONG *outstandingWorkItemCount;

void* keyInfoBuffer;

int keyInfoBufferSize;

void* keyDerivationWorkItems;

int keyDerivationWorkItemsSize;

} ReadVolumeHeaderFinalization;

};

} EncryptionThreadPoolWorkItem;

static volatile BOOL ThreadPoolRunning = FALSE;

static volatile BOOL StopPending = FALSE;

static uint32 ThreadCount;

static TC_THREAD_HANDLE ThreadHandles[TC_ENC_THREAD_POOL_MAX_THREAD_COUNT];

static WORD ThreadProcessorGroups[TC_ENC_THREAD_POOL_MAX_THREAD_COUNT];

static EncryptionThreadPoolWorkItem WorkItemQueue[TC_ENC_THREAD_POOL_QUEUE_SIZE];

static volatile int EnqueuePosition;

static volatile int DequeuePosition;

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

{

#ifdef DEVICE_DRIVER

TCStopThread (ThreadHandles[i], &WorkItemReadyEvent);

#else

TC_WAIT_EVENT (ThreadHandles[i]);

#endif

}

ThreadCount = 0;

#ifndef DEVICE_DRIVER

CloseHandle (DequeueMutex);

CloseHandle (EnqueueMutex);

CloseHandle (WorkItemReadyEvent);

CloseHandle (WorkItemCompletedEvent);

for (i = 0; i < sizeof (WorkItemQueue) / sizeof (WorkItemQueue[0]); ++i)

{

if (WorkItemQueue[i].ItemCompletedEvent)

CloseHandle (WorkItemQueue[i].ItemCompletedEvent);

}

#endif

ThreadPoolRunning = FALSE;

}

{

EncryptionThreadPoolWorkItem *workItem;

if (!ThreadPoolRunning)

TC_THROW_FATAL_EXCEPTION;

TC_ACQUIRE_MUTEX (&EnqueueMutex);

workItem = &WorkItemQueue[EnqueuePosition++];

if (EnqueuePosition >= ThreadQueueSize)

EnqueuePosition = 0;

while (GetWorkItemState (workItem) != WorkItemFree)

{

TC_WAIT_EVENT (WorkItemCompletedEvent);

}

workItem->Type = DeriveKeyWork;

workItem->KeyDerivation.CompletionEvent = completionEvent;

workItem->KeyDerivation.CompletionFlag = completionFlag;

workItem->KeyDerivation.DerivedKey = derivedKey;

workItem->KeyDerivation.IterationCount = iterationCount;

workItem->KeyDerivation.NoOutstandingWorkItemEvent = noOutstandingWorkItemEvent;

workItem->KeyDerivation.OutstandingWorkItemCount = outstandingWorkItemCount;

workItem->KeyDerivation.Password = password;

workItem->KeyDerivation.PasswordLength = passwordLength;

workItem->KeyDerivation.Pkcs5Prf = pkcs5Prf;

workItem->KeyDerivation.Salt = salt;

InterlockedIncrement (outstandingWorkItemCount);

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

and all other portions of this file are Copyright (c) 2013-2017 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

code distribution packages.

*/

#ifndef TC_HEADER_ENCRYPTION_THREAD_POOL

#define TC_HEADER_ENCRYPTION_THREAD_POOL

#include "Tcdefs.h"

#include "Crypto.h"

#ifdef __cplusplus

extern "C" {

#endif

typedef enum

{

EncryptDataUnitsWork,

DecryptDataUnitsWork,

DeriveKeyWork,

ReadVolumeHeaderFinalizationWork

} EncryptionThreadPoolWorkType;

#ifndef DEVICE_DRIVER

size_t GetCpuCount (WORD* pGroupCount);

#endif

void EncryptionThreadPoolBeginReadVolumeHeaderFinalization (TC_EVENT *keyDerivationCompletedEvent, TC_EVENT *noOutstandingWorkItemEvent, LONG* outstandingWorkItemCount, void* keyInfoBuffer, int keyInfoBufferSize, void* keyDerivationWorkItems, int keyDerivationWorkItemsSize);

void EncryptionThreadPoolDoWork (EncryptionThreadPoolWorkType type, uint8 *data, const UINT64_STRUCT *startUnitNo, uint32 unitCount, PCRYPTO_INFO cryptoInfo);

BOOL EncryptionThreadPoolStart (size_t encryptionFreeCpuCount);

void EncryptionThreadPoolStop ();

size_t GetEncryptionThreadCount ();

size_t GetMaxEncryptionThreadCount ();

BOOL IsEncryptionThreadPoolRunning ();

#ifdef __cplusplus

}

#endif

#endif // TC_HEADER_ENCRYPTION_THREAD_POOL

# error TC_HIDDEN_VOLUME_HOST_FS_RESERVED_END_AREA_SIZE too large for very small volumes. Revise the code.

#endif

#if TC_HIDDEN_VOLUME_HOST_FS_RESERVED_END_AREA_SIZE_HIGH < TC_MAX_VOLUME_SECTOR_SIZE

# error TC_HIDDEN_VOLUME_HOST_FS_RESERVED_END_AREA_SIZE_HIGH too small.

#endif

if (volumeSize < TC_VOLUME_SMALL_SIZE_THRESHOLD)

reservedSize = TC_HIDDEN_VOLUME_HOST_FS_RESERVED_END_AREA_SIZE;

else

reservedSize = TC_HIDDEN_VOLUME_HOST_FS_RESERVED_END_AREA_SIZE_HIGH; // Ensure size of a hidden volume larger than TC_VOLUME_SMALL_SIZE_THRESHOLD is a multiple of the maximum supported sector size

}

else

{

reservedSize = TC_TOTAL_VOLUME_HEADERS_SIZE;

}

if (volumeSize < reservedSize)

return 0;

return volumeSize - reservedSize;

}

int TCFormatVolume (volatile FORMAT_VOL_PARAMETERS *volParams)

{

int nStatus;

PCRYPTO_INFO cryptoInfo = NULL;

HANDLE dev = INVALID_HANDLE_VALUE;

DWORD dwError;

unsigned __int64 num_sectors, startSector;

fatparams ft;

FILETIME ftCreationTime;

FILETIME ftLastWriteTime;

FILETIME ftLastAccessTime;

BOOL bTimeStampValid = FALSE;

BOOL bInstantRetryOtherFilesys = FALSE;

WCHAR dosDev[TC_MAX_PATH] = { 0 };

WCHAR devName[MAX_PATH] = { 0 };

int driveLetter = -1;

WCHAR deviceName[MAX_PATH];

uint64 dataOffset, dataAreaSize;

LARGE_INTEGER offset;

BOOL bFailedRequiredDASD = FALSE;

HWND hwndDlg = volParams->hwndDlg;

#ifdef _WIN64

CRYPTO_INFO tmpCI;

PCRYPTO_INFO cryptoInfoBackup = NULL;

#endif

FormatSectorSize = volParams->sectorSize;

if (FormatSectorSize < TC_MIN_VOLUME_SECTOR_SIZE

|| FormatSectorSize > TC_MAX_VOLUME_SECTOR_SIZE

|| FormatSectorSize % ENCRYPTION_DATA_UNIT_SIZE != 0)

{

Error ("SECTOR_SIZE_UNSUPPORTED", hwndDlg);

return ERR_DONT_REPORT;

}

return FALSE;

}

#ifndef _DEBUG

if (!bSkipPasswordWarning && (MessageBoxW (hwndDlg, GetString ("PASSWORD_LENGTH_WARNING"), lpszTitle, MB_YESNO|MB_ICONWARNING|MB_DEFBUTTON2) != IDYES))

return FALSE;

#endif

}

#ifndef _DEBUG

else if (bCustomPimSmall)

{

if (!bSkipPimWarning && AskWarnNoYes ("PIM_SMALL_WARNING", hwndDlg) != IDYES)

return FALSE;

}

#endif

if ((pim != 0) && (pim > (bootPimCondition? 98 : 485)))

{

// warn that mount/boot will take more time

Warning ("PIM_LARGE_WARNING", hwndDlg);

}

return TRUE;

}

int ChangePwd (const wchar_t *lpszVolume, Password *oldPassword, int old_pkcs5, int old_pim, Password *newPassword, int pkcs5, int pim, int wipePassCount, HWND hwndDlg)

{

int nDosLinkCreated = 1, nStatus = ERR_OS_ERROR;

wchar_t szDiskFile[TC_MAX_PATH], szCFDevice[TC_MAX_PATH];

wchar_t szDosDevice[TC_MAX_PATH];

PCRYPTO_INFO cryptoInfo = NULL, ci = NULL;

void *dev = INVALID_HANDLE_VALUE;

DWORD dwError;

DWORD bytesRead;

BOOL bDevice;

unsigned __int64 hostSize = 0;

int volumeType;

int wipePass;

FILETIME ftCreationTime;

FILETIME ftLastWriteTime;

FILETIME ftLastAccessTime;

BOOL bTimeStampValid = FALSE;

LARGE_INTEGER headerOffset;

BOOL backupHeader;

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

if (wipePassCount <= 0)

{

nStatus = ERR_PARAMETER_INCORRECT;

handleError (hwndDlg, nStatus, SRC_POS);

return nStatus;

}

if (!lpszVolume)

{

nStatus = ERR_OUTOFMEMORY;

handleError (hwndDlg, nStatus, SRC_POS);

return nStatus;

}

#include <memory.h>

#include <stdlib.h>

#endif

#include "blake2.h"

#ifndef TC_WINDOWS_BOOT

#include "Sha2.h"

#include "Whirlpool.h"

#include "cpu.h"

#include "misc.h"

#else

#pragma optimize ("t", on)

#include <string.h>

#if defined( _MSC_VER )

# ifndef DEBUG

# pragma intrinsic( memcpy )

# pragma intrinsic( memset )

# endif

#endif

#include "Sha2Small.h"

#endif

#include "Pkcs5.h"

#include "Crypto.h"

#if !defined(TC_WINDOWS_BOOT) || defined(TC_WINDOWS_BOOT_SHA2)

typedef struct hmac_sha256_ctx_struct

{

sha256_ctx ctx;

sha256_ctx inner_digest_ctx; /*pre-computed inner digest context */

sha256_ctx outer_digest_ctx; /*pre-computed outer digest context */

} hmac_sha256_ctx;

void hmac_sha256_internal

(

int ld, /* length of input data in bytes */

hmac_sha256_ctx* hmac /* HMAC-SHA256 context which holds temporary variables */

)

{

sha256_ctx* ctx = &(hmac->ctx);

/**** Restore Precomputed Inner Digest Context ****/

memcpy (ctx, &(hmac->inner_digest_ctx), sizeof (sha256_ctx));

/**** Restore Precomputed Outer Digest Context ****/

memcpy (ctx, &(hmac->outer_digest_ctx), sizeof (sha256_ctx));

}

#ifndef TC_WINDOWS_BOOT

void hmac_sha256

(

int lk, /* length of the key in bytes */

int ld /* length of data in bytes */

)

{

hmac_sha256_ctx hmac;

sha256_ctx* ctx;

int b;

NTSTATUS saveStatus = STATUS_INVALID_PARAMETER;

XSTATE_SAVE SaveState;

if (IsCpuIntel() && HasSAVX())

saveStatus = KeSaveExtendedProcessorStateVC(XSTATE_MASK_GSSE, &SaveState);

#endif

/* If the key is longer than the hash algorithm block size,

let key = sha256(key), as per HMAC specifications. */

if (lk > SHA256_BLOCKSIZE)

{

sha256_ctx tctx;

sha256_begin (&tctx);

k = key;

lk = SHA256_DIGESTSIZE;

burn (&tctx, sizeof(tctx)); // Prevent leaks

}

/**** Precompute HMAC Inner Digest ****/

ctx = &(hmac.inner_digest_ctx);

sha256_begin (ctx);

/* Pad the key for inner digest */

for (b = 0; b < lk; ++b)

memset (&buf[lk], 0x36, SHA256_BLOCKSIZE - lk);

/**** Precompute HMAC Outer Digest ****/

ctx = &(hmac.outer_digest_ctx);

sha256_begin (ctx);

for (b = 0; b < lk; ++b)

memset (&buf[lk], 0x5C, SHA256_BLOCKSIZE - lk);

hmac_sha256_internal(d, ld, &hmac);

if (NT_SUCCESS (saveStatus))

KeRestoreExtendedProcessorStateVC(&SaveState);

#endif

/* Prevent leaks */

burn(&hmac, sizeof(hmac));

burn(key, sizeof(key));

}

#endif

{

uint32 c;

int i;

#ifdef TC_WINDOWS_BOOT

/* In bootloader mode, least significant bit of iterations is a boolean (TRUE for boot derivation mode, FALSE otherwise)

* and the most significant 16 bits hold the pim value

* This enables us to save code space needed for implementing other features.

*/

c = iterations >> 16;

i = ((int) iterations) & 0x01;

if (i)

c = (c == 0)? 200000 : c << 11;

else

c = (c == 0)? 500000 : 15000 + c * 1000;

#else

c = iterations;

#endif

/* iteration 1 */

memcpy (k, salt, salt_len); /* salt */

/* big-endian block number */

#ifdef TC_WINDOWS_BOOT

/* specific case of 16-bit bootloader: b is a 16-bit integer that is always < 256 */

memset (&k[salt_len], 0, 3);

#else

b = bswap_32 (b);

memcpy (&k[salt_len], &b, 4);

#endif

hmac_sha256_internal (k, salt_len + 4, hmac);

memcpy (u, k, SHA256_DIGESTSIZE);

/* remaining iterations */

while (c > 1)

{

hmac_sha256_internal (k, SHA256_DIGESTSIZE, hmac);

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

{

u[i] ^= k[i];

}

c--;

}

}

{

hmac_sha256_ctx hmac;

sha256_ctx* ctx;

int b, l, r;

#ifndef TC_WINDOWS_BOOT

NTSTATUS saveStatus = STATUS_INVALID_PARAMETER;

XSTATE_SAVE SaveState;

if (IsCpuIntel() && HasSAVX())

saveStatus = KeSaveExtendedProcessorStateVC(XSTATE_MASK_GSSE, &SaveState);

#endif

/* If the password is longer than the hash algorithm block size,

let pwd = sha256(pwd), as per HMAC specifications. */

if (pwd_len > SHA256_BLOCKSIZE)

{

sha256_ctx tctx;

sha256_begin (&tctx);

pwd = key;

pwd_len = SHA256_DIGESTSIZE;

burn (&tctx, sizeof(tctx)); // Prevent leaks

}

#endif

if (dklen % SHA256_DIGESTSIZE)

{

l = 1 + dklen / SHA256_DIGESTSIZE;

}

else

{

l = dklen / SHA256_DIGESTSIZE;

}

r = dklen - (l - 1) * SHA256_DIGESTSIZE;

/**** Precompute HMAC Inner Digest ****/

ctx = &(hmac.inner_digest_ctx);

sha256_begin (ctx);

/* Pad the key for inner digest */

for (b = 0; b < pwd_len; ++b)

memset (&buf[pwd_len], 0x36, SHA256_BLOCKSIZE - pwd_len);

/**** Precompute HMAC Outer Digest ****/

ctx = &(hmac.outer_digest_ctx);

sha256_begin (ctx);

for (b = 0; b < pwd_len; ++b)

memset (&buf[pwd_len], 0x5C, SHA256_BLOCKSIZE - pwd_len);

/* first l - 1 blocks */

for (b = 1; b < l; b++)

{

derive_u_sha256 (salt, salt_len, iterations, b, &hmac);

memcpy (dk, hmac.u, SHA256_DIGESTSIZE);

dk += SHA256_DIGESTSIZE;

}

/* last block */

derive_u_sha256 (salt, salt_len, iterations, b, &hmac);

memcpy (dk, hmac.u, r);

if (NT_SUCCESS (saveStatus))

KeRestoreExtendedProcessorStateVC(&SaveState);

#endif

/* Prevent possible leaks. */

burn (&hmac, sizeof(hmac));

#ifndef TC_WINDOWS_BOOT

burn (key, sizeof(key));

#endif

}

#endif

#ifndef TC_WINDOWS_BOOT

typedef struct hmac_sha512_ctx_struct

{

sha512_ctx ctx;

sha512_ctx inner_digest_ctx; /*pre-computed inner digest context */

sha512_ctx outer_digest_ctx; /*pre-computed outer digest context */

} hmac_sha512_ctx;

void hmac_sha512_internal

(

int ld, /* length of data in bytes */

hmac_sha512_ctx* hmac

)

{

sha512_ctx* ctx = &(hmac->ctx);

/**** Restore Precomputed Inner Digest Context ****/

memcpy (ctx, &(hmac->inner_digest_ctx), sizeof (sha512_ctx));

/**** Restore Precomputed Outer Digest Context ****/

memcpy (ctx, &(hmac->outer_digest_ctx), sizeof (sha512_ctx));

}

void hmac_sha512

(

int lk, /* length of the key in bytes */

int ld /* length of data in bytes */

)

{

hmac_sha512_ctx hmac;

sha512_ctx* ctx;

int b;

NTSTATUS saveStatus = STATUS_INVALID_PARAMETER;

XSTATE_SAVE SaveState;

if (IsCpuIntel() && HasSAVX())

saveStatus = KeSaveExtendedProcessorStateVC(XSTATE_MASK_GSSE, &SaveState);

#endif

/* If the key is longer than the hash algorithm block size,

let key = sha512(key), as per HMAC specifications. */

if (lk > SHA512_BLOCKSIZE)

{

sha512_ctx tctx;

sha512_begin (&tctx);

k = key;

lk = SHA512_DIGESTSIZE;

burn (&tctx, sizeof(tctx)); // Prevent leaks

}

/**** Precompute HMAC Inner Digest ****/

ctx = &(hmac.inner_digest_ctx);

sha512_begin (ctx);

/* Pad the key for inner digest */

for (b = 0; b < lk; ++b)

memset (&buf[lk], 0x36, SHA512_BLOCKSIZE - lk);

/**** Precompute HMAC Outer Digest ****/

ctx = &(hmac.outer_digest_ctx);

sha512_begin (ctx);

for (b = 0; b < lk; ++b)

memset (&buf[lk], 0x5C, SHA512_BLOCKSIZE - lk);

hmac_sha512_internal (d, ld, &hmac);

if (NT_SUCCESS (saveStatus))

KeRestoreExtendedProcessorStateVC(&SaveState);

#endif

/* Prevent leaks */

burn (&hmac, sizeof(hmac));

burn (key, sizeof(key));

}

{

uint32 c, i;

/* iteration 1 */

memcpy (k, salt, salt_len); /* salt */

/* big-endian block number */

b = bswap_32 (b);

memcpy (&k[salt_len], &b, 4);

hmac_sha512_internal (k, salt_len + 4, hmac);

memcpy (u, k, SHA512_DIGESTSIZE);

/* remaining iterations */

for (c = 1; c < iterations; c++)

{

hmac_sha512_internal (k, SHA512_DIGESTSIZE, hmac);

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

{

u[i] ^= k[i];

}

}

}

{

hmac_sha512_ctx hmac;

sha512_ctx* ctx;

int b, l, r;

NTSTATUS saveStatus = STATUS_INVALID_PARAMETER;

XSTATE_SAVE SaveState;

if (IsCpuIntel() && HasSAVX())

saveStatus = KeSaveExtendedProcessorStateVC(XSTATE_MASK_GSSE, &SaveState);

#endif

/* If the password is longer than the hash algorithm block size,

let pwd = sha512(pwd), as per HMAC specifications. */

if (pwd_len > SHA512_BLOCKSIZE)

{

sha512_ctx tctx;

sha512_begin (&tctx);

pwd = key;

pwd_len = SHA512_DIGESTSIZE;

burn (&tctx, sizeof(tctx)); // Prevent leaks

}

if (dklen % SHA512_DIGESTSIZE)

{

l = 1 + dklen / SHA512_DIGESTSIZE;

}

else

{

l = dklen / SHA512_DIGESTSIZE;

}

r = dklen - (l - 1) * SHA512_DIGESTSIZE;

/**** Precompute HMAC Inner Digest ****/

ctx = &(hmac.inner_digest_ctx);

sha512_begin (ctx);

/* Pad the key for inner digest */

for (b = 0; b < pwd_len; ++b)

memset (&buf[pwd_len], 0x36, SHA512_BLOCKSIZE - pwd_len);

/**** Precompute HMAC Outer Digest ****/

ctx = &(hmac.outer_digest_ctx);

sha512_begin (ctx);

for (b = 0; b < pwd_len; ++b)

memset (&buf[pwd_len], 0x5C, SHA512_BLOCKSIZE - pwd_len);

/* first l - 1 blocks */

for (b = 1; b < l; b++)

{

derive_u_sha512 (salt, salt_len, iterations, b, &hmac);

memcpy (dk, hmac.u, SHA512_DIGESTSIZE);

dk += SHA512_DIGESTSIZE;

}

/* last block */

derive_u_sha512 (salt, salt_len, iterations, b, &hmac);

memcpy (dk, hmac.u, r);

if (NT_SUCCESS (saveStatus))

KeRestoreExtendedProcessorStateVC(&SaveState);

#endif

/* Prevent possible leaks. */

burn (&hmac, sizeof(hmac));

burn (key, sizeof(key));

}

#endif // TC_WINDOWS_BOOT

#if !defined(TC_WINDOWS_BOOT) || defined(TC_WINDOWS_BOOT_BLAKE2S)

typedef struct hmac_blake2s_ctx_struct

{

blake2s_state ctx;

blake2s_state inner_digest_ctx; /*pre-computed inner digest context */

blake2s_state outer_digest_ctx; /*pre-computed outer digest context */

} hmac_blake2s_ctx;

void hmac_blake2s_internal

(

int ld, /* length of input data in bytes */

hmac_blake2s_ctx* hmac /* HMAC-BLAKE2S context which holds temporary variables */

)

{

blake2s_state* ctx = &(hmac->ctx);

/**** Restore Precomputed Inner Digest Context ****/

memcpy (ctx, &(hmac->inner_digest_ctx), sizeof (blake2s_state));

blake2s_update (ctx, d, ld);

/**** Restore Precomputed Outer Digest Context ****/

memcpy (ctx, &(hmac->outer_digest_ctx), sizeof (blake2s_state));

blake2s_update (ctx, d, BLAKE2S_DIGESTSIZE);

}

#ifndef TC_WINDOWS_BOOT

void hmac_blake2s

(

int lk, /* length of the key in bytes */

int ld /* length of data in bytes */

)

{

hmac_blake2s_ctx hmac;

blake2s_state* ctx;

int b;

NTSTATUS saveStatus = STATUS_INVALID_PARAMETER;

XSTATE_SAVE SaveState;

if (IsCpuIntel() && HasSAVX())

saveStatus = KeSaveExtendedProcessorStateVC(XSTATE_MASK_GSSE, &SaveState);

#endif

/* If the key is longer than the hash algorithm block size,

let key = blake2s(key), as per HMAC specifications. */

if (lk > BLAKE2S_BLOCKSIZE)

{

blake2s_state tctx;

blake2s_init (&tctx);

blake2s_update (&tctx, k, lk);

k = key;

lk = BLAKE2S_DIGESTSIZE;

burn (&tctx, sizeof(tctx)); // Prevent leaks

}

/**** Precompute HMAC Inner Digest ****/

ctx = &(hmac.inner_digest_ctx);

blake2s_init (ctx);

/* Pad the key for inner digest */

for (b = 0; b < lk; ++b)

memset (&buf[lk], 0x36, BLAKE2S_BLOCKSIZE - lk);

/**** Precompute HMAC Outer Digest ****/

ctx = &(hmac.outer_digest_ctx);

blake2s_init (ctx);

for (b = 0; b < lk; ++b)

memset (&buf[lk], 0x5C, BLAKE2S_BLOCKSIZE - lk);

hmac_blake2s_internal(d, ld, &hmac);

if (NT_SUCCESS (saveStatus))

KeRestoreExtendedProcessorStateVC(&SaveState);

#endif

/* Prevent leaks */

burn(&hmac, sizeof(hmac));

burn(key, sizeof(key));

}

#endif

{

uint32 c;

int i;

#ifdef TC_WINDOWS_BOOT

/* In bootloader mode, least significant bit of iterations is a boolean (TRUE for boot derivation mode, FALSE otherwise)

* and the most significant 16 bits hold the pim value

* This enables us to save code space needed for implementing other features.

*/

c = iterations >> 16;

i = ((int) iterations) & 0x01;

if (i)

c = (c == 0)? 200000 : c << 11;

else

c = (c == 0)? 500000 : 15000 + c * 1000;

#else

c = iterations;

#endif

/* iteration 1 */

memcpy (k, salt, salt_len); /* salt */

/* big-endian block number */

#ifdef TC_WINDOWS_BOOT

/* specific case of 16-bit bootloader: b is a 16-bit integer that is always < 256 */

memset (&k[salt_len], 0, 3);

#else

b = bswap_32 (b);

memcpy (&k[salt_len], &b, 4);

#endif

hmac_blake2s_internal (k, salt_len + 4, hmac);

memcpy (u, k, BLAKE2S_DIGESTSIZE);

/* remaining iterations */

while (c > 1)

{

hmac_blake2s_internal (k, BLAKE2S_DIGESTSIZE, hmac);

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

{

u[i] ^= k[i];

}

c--;

}

}

{

hmac_blake2s_ctx hmac;

blake2s_state* ctx;

int b, l, r;

#ifndef TC_WINDOWS_BOOT

NTSTATUS saveStatus = STATUS_INVALID_PARAMETER;

XSTATE_SAVE SaveState;

if (IsCpuIntel() && HasSAVX())

saveStatus = KeSaveExtendedProcessorStateVC(XSTATE_MASK_GSSE, &SaveState);

KFLOATING_SAVE floatingPointState;

if (HasSSE2())

saveStatus = KeSaveFloatingPointState (&floatingPointState);

#endif

/* If the password is longer than the hash algorithm block size,

let pwd = blake2s(pwd), as per HMAC specifications. */

if (pwd_len > BLAKE2S_BLOCKSIZE)

{

blake2s_state tctx;

blake2s_init (&tctx);

blake2s_update (&tctx, pwd, pwd_len);

pwd = key;

pwd_len = BLAKE2S_DIGESTSIZE;

burn (&tctx, sizeof(tctx)); // Prevent leaks

}

#endif

if (dklen % BLAKE2S_DIGESTSIZE)

{

l = 1 + dklen / BLAKE2S_DIGESTSIZE;

}

else

{

l = dklen / BLAKE2S_DIGESTSIZE;

}

r = dklen - (l - 1) * BLAKE2S_DIGESTSIZE;

/**** Precompute HMAC Inner Digest ****/

ctx = &(hmac.inner_digest_ctx);

blake2s_init (ctx);

/* Pad the key for inner digest */

for (b = 0; b < pwd_len; ++b)

memset (&buf[pwd_len], 0x36, BLAKE2S_BLOCKSIZE - pwd_len);

blake2s_update (ctx, buf, BLAKE2S_BLOCKSIZE);

/**** Precompute HMAC Outer Digest ****/

ctx = &(hmac.outer_digest_ctx);

blake2s_init (ctx);

for (b = 0; b < pwd_len; ++b)

memset (&buf[pwd_len], 0x5C, BLAKE2S_BLOCKSIZE - pwd_len);

blake2s_update (ctx, buf, BLAKE2S_BLOCKSIZE);

/* first l - 1 blocks */

for (b = 1; b < l; b++)

{

derive_u_blake2s (salt, salt_len, iterations, b, &hmac);

memcpy (dk, hmac.u, BLAKE2S_DIGESTSIZE);

dk += BLAKE2S_DIGESTSIZE;

}

/* last block */

derive_u_blake2s (salt, salt_len, iterations, b, &hmac);

memcpy (dk, hmac.u, r);

if (NT_SUCCESS (saveStatus))

KeRestoreExtendedProcessorStateVC(&SaveState);

#endif

/* Prevent possible leaks. */

burn (&hmac, sizeof(hmac));

#ifndef TC_WINDOWS_BOOT

burn (key, sizeof(key));

#endif

}

#endif

#ifndef TC_WINDOWS_BOOT

typedef struct hmac_whirlpool_ctx_struct

{

WHIRLPOOL_CTX ctx;

WHIRLPOOL_CTX inner_digest_ctx; /*pre-computed inner digest context */

WHIRLPOOL_CTX outer_digest_ctx; /*pre-computed outer digest context */

} hmac_whirlpool_ctx;

void hmac_whirlpool_internal

(

int ld, /* length of input data in bytes */

hmac_whirlpool_ctx* hmac /* HMAC-Whirlpool context which holds temporary variables */

)

{

WHIRLPOOL_CTX* ctx = &(hmac->ctx);

/**** Restore Precomputed Inner Digest Context ****/

memcpy (ctx, &(hmac->inner_digest_ctx), sizeof (WHIRLPOOL_CTX));

/**** Restore Precomputed Outer Digest Context ****/

memcpy (ctx, &(hmac->outer_digest_ctx), sizeof (WHIRLPOOL_CTX));

}

void hmac_whirlpool

(

int lk, /* length of the key in bytes */

int ld /* length of data in bytes */

)

{

hmac_whirlpool_ctx hmac;

WHIRLPOOL_CTX* ctx;

int b;

/* If the key is longer than the hash algorithm block size,

let key = whirlpool(key), as per HMAC specifications. */

if (lk > WHIRLPOOL_BLOCKSIZE)

{

WHIRLPOOL_CTX tctx;

WHIRLPOOL_init (&tctx);

k = key;

lk = WHIRLPOOL_DIGESTSIZE;

burn (&tctx, sizeof(tctx)); // Prevent leaks

}

/**** Precompute HMAC Inner Digest ****/

ctx = &(hmac.inner_digest_ctx);

WHIRLPOOL_init (ctx);

/* Pad the key for inner digest */

for (b = 0; b < lk; ++b)

memset (&buf[lk], 0x36, WHIRLPOOL_BLOCKSIZE - lk);

/**** Precompute HMAC Outer Digest ****/

ctx = &(hmac.outer_digest_ctx);

WHIRLPOOL_init (ctx);

for (b = 0; b < lk; ++b)

memset (&buf[lk], 0x5C, WHIRLPOOL_BLOCKSIZE - lk);

hmac_whirlpool_internal(d, ld, &hmac);

/* Prevent leaks */

burn(&hmac, sizeof(hmac));

}

{

uint32 c, i;

/* iteration 1 */

memcpy (k, salt, salt_len); /* salt */

/* big-endian block number */

b = bswap_32 (b);

memcpy (&k[salt_len], &b, 4);

hmac_whirlpool_internal (k, salt_len + 4, hmac);

memcpy (u, k, WHIRLPOOL_DIGESTSIZE);

/* remaining iterations */

for (c = 1; c < iterations; c++)

{

hmac_whirlpool_internal (k, WHIRLPOOL_DIGESTSIZE, hmac);

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

{

u[i] ^= k[i];

}

}

}

{

hmac_whirlpool_ctx hmac;

WHIRLPOOL_CTX* ctx;

int b, l, r;

/* If the password is longer than the hash algorithm block size,

let pwd = whirlpool(pwd), as per HMAC specifications. */

if (pwd_len > WHIRLPOOL_BLOCKSIZE)

{

WHIRLPOOL_CTX tctx;

WHIRLPOOL_init (&tctx);

pwd = key;

pwd_len = WHIRLPOOL_DIGESTSIZE;

burn (&tctx, sizeof(tctx)); // Prevent leaks

}

if (dklen % WHIRLPOOL_DIGESTSIZE)

{

l = 1 + dklen / WHIRLPOOL_DIGESTSIZE;

}

else

{

l = dklen / WHIRLPOOL_DIGESTSIZE;

}

r = dklen - (l - 1) * WHIRLPOOL_DIGESTSIZE;

/**** Precompute HMAC Inner Digest ****/

ctx = &(hmac.inner_digest_ctx);

WHIRLPOOL_init (ctx);

/* Pad the key for inner digest */

for (b = 0; b < pwd_len; ++b)

memset (&buf[pwd_len], 0x36, WHIRLPOOL_BLOCKSIZE - pwd_len);

/**** Precompute HMAC Outer Digest ****/

ctx = &(hmac.outer_digest_ctx);

WHIRLPOOL_init (ctx);

for (b = 0; b < pwd_len; ++b)

memset (&buf[pwd_len], 0x5C, WHIRLPOOL_BLOCKSIZE - pwd_len);

/* first l - 1 blocks */

for (b = 1; b < l; b++)

{

derive_u_whirlpool (salt, salt_len, iterations, b, &hmac);

memcpy (dk, hmac.u, WHIRLPOOL_DIGESTSIZE);

dk += WHIRLPOOL_DIGESTSIZE;

}

/* last block */

derive_u_whirlpool (salt, salt_len, iterations, b, &hmac);

memcpy (dk, hmac.u, r);

/* Prevent possible leaks. */

burn (&hmac, sizeof(hmac));

burn (key, sizeof(key));

}

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 */

} hmac_streebog_ctx;

void hmac_streebog_internal

(

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

/**** Restore Precomputed Outer Digest Context ****/

memcpy (ctx, &(hmac->outer_digest_ctx), sizeof (STREEBOG_CTX));

}

void hmac_streebog

(

int lk, /* length of the key in bytes */

int ld /* length of data in bytes */

)

{

hmac_streebog_ctx hmac;

STREEBOG_CTX* ctx;

int b;

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

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)

memset (&buf[lk], 0x36, STREEBOG_BLOCKSIZE - lk);

/**** Precompute HMAC Outer Digest ****/

ctx = &(hmac.outer_digest_ctx);

STREEBOG_init (ctx);

for (b = 0; b < lk; ++b)

memset (&buf[lk], 0x5C, STREEBOG_BLOCKSIZE - lk);

hmac_streebog_internal(d, ld, &hmac);

/* Prevent leaks */

burn(&hmac, sizeof(hmac));

}

{

uint32 c, i;

/* iteration 1 */

memcpy (k, salt, salt_len); /* salt */

/* big-endian block number */

b = bswap_32 (b);

memcpy (&k[salt_len], &b, 4);

hmac_streebog_internal (k, salt_len + 4, hmac);

memcpy (u, k, STREEBOG_DIGESTSIZE);

/* remaining iterations */

for (c = 1; c < iterations; c++)

{

hmac_streebog_internal (k, STREEBOG_DIGESTSIZE, hmac);

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

{

u[i] ^= k[i];

}

}

}

{

hmac_streebog_ctx hmac;

STREEBOG_CTX* ctx;

int b, l, r;

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

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)

memset (&buf[pwd_len], 0x36, STREEBOG_BLOCKSIZE - pwd_len);

/**** Precompute HMAC Outer Digest ****/

ctx = &(hmac.outer_digest_ctx);

STREEBOG_init (ctx);

for (b = 0; b < pwd_len; ++b)

memset (&buf[pwd_len], 0x5C, STREEBOG_BLOCKSIZE - pwd_len);

/* first l - 1 blocks */

for (b = 1; b < l; b++)

{

derive_u_streebog (salt, salt_len, iterations, b, &hmac);

memcpy (dk, hmac.u, STREEBOG_DIGESTSIZE);

dk += STREEBOG_DIGESTSIZE;

}

/* last block */

derive_u_streebog (salt, salt_len, iterations, b, &hmac);

memcpy (dk, hmac.u, r);

/* Prevent possible leaks. */

burn (&hmac, sizeof(hmac));

burn (key, sizeof(key));

}

wchar_t *get_pkcs5_prf_name (int pkcs5_prf_id)

{

switch (pkcs5_prf_id)

{

case SHA512:

return L"HMAC-SHA-512";

case SHA256:

return L"HMAC-SHA-256";

case BLAKE2S:

return L"HMAC-BLAKE2s-256";

case WHIRLPOOL:

return L"HMAC-Whirlpool";

case STREEBOG:

return L"HMAC-STREEBOG";

default:

return L"(Unknown)";

}

}

/*

Legal Notice: Some portions of the source code contained in this file were

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

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

governed by the TrueCrypt License 3.0, also from the source code of

Encryption for the Masses 2.02a, which is Copyright (c) 1998-2000 Paul Le Roux

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)

and all other portions of this file are Copyright (c) 2013-2017 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

code distribution packages. */

#ifndef TC_HEADER_PKCS5

#define TC_HEADER_PKCS5

#include "Tcdefs.h"

#if defined(__cplusplus)

extern "C"

{

#endif

/* output written to input_digest which must be at lease 32 bytes long */

/* output written to d which must be at lease 32 bytes long */

#ifndef TC_WINDOWS_BOOT

/* output written to d which must be at lease 64 bytes long */

/* output written to d which must be at lease 64 bytes long */

int get_pkcs5_iteration_count (int pkcs5_prf_id, int pim, BOOL bBoot);

wchar_t *get_pkcs5_prf_name (int pkcs5_prf_id);

/* check if given PRF supported.*/

typedef enum

{

PRF_BOOT_NO = 0,

PRF_BOOT_MBR,

PRF_BOOT_GPT

} PRF_BOOT_TYPE;

int is_pkcs5_prf_supported (int pkcs5_prf_id, PRF_BOOT_TYPE bootType);

#endif

#if defined(__cplusplus)

}

#endif

#endif // TC_HEADER_PKCS5

/*

Legal Notice: Some portions of the source code contained in this file were

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

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

governed by the TrueCrypt License 3.0, also from the source code of

Encryption for the Masses 2.02a, which is Copyright (c) 1998-2000 Paul Le Roux

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)

and all other portions of this file are Copyright (c) 2013-2017 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

code distribution packages. */

#include "Tcdefs.h"

#include "Crc.h"

#include "Random.h"

#include "Dlgcode.h"

#include "Crypto\cpu.h"

#include "Crypto\jitterentropy.h"

#include "Crypto\rdrand.h"

#include <Strsafe.h>

static unsigned __int8 buffer[RNG_POOL_SIZE];

static unsigned char *pRandPool = NULL;

static BOOL bRandDidInit = FALSE;

static int nRandIndex = 0, randPoolReadIndex = 0;

static int HashFunction = DEFAULT_HASH_ALGORITHM;

static BOOL bDidSlowPoll = FALSE;

BOOL volatile bFastPollEnabled = TRUE; /* Used to reduce CPU load when performing benchmarks */

BOOL volatile bRandmixEnabled = TRUE; /* Used to reduce CPU load when performing benchmarks */

static BOOL RandomPoolEnrichedByUser = FALSE;

static HANDLE PeriodicFastPollThreadHandle = NULL;

/* Macro to add a single byte to the pool */

#define RandaddByte(x) {\

if (nRandIndex == RNG_POOL_SIZE) nRandIndex = 0;\

pRandPool[nRandIndex] = (unsigned char) ((unsigned char)x + pRandPool[nRandIndex]); \

if (nRandIndex % RANDMIX_BYTE_INTERVAL == 0) Randmix();\

nRandIndex++; \

}

/* Macro to add four bytes to the pool */

#define RandaddInt32(x) RandAddInt((unsigned __int32)x);

#ifdef _WIN64

#define RandaddIntPtr(x) RandAddInt64((unsigned __int64)x);

#else

#define RandaddIntPtr(x) RandAddInt((unsigned __int32)x);

#endif

void RandAddInt (unsigned __int32 x)

RandaddByte((x >> 8));

RandaddByte((x >> 16));

RandaddByte((x >> 24));

RandaddByte((x >> 32));

RandaddByte((x >> 40));

RandaddByte((x >> 48));

RandaddByte((x >> 56));

}

#include <tlhelp32.h>

#include "Dlgcode.h"

#ifndef SRC_POS

#define SRC_POS (__FUNCTION__ ":" TC_TO_STRING(__LINE__))

#endif

HHOOK hMouse = NULL; /* Mouse hook for the random number generator */

HHOOK hKeyboard = NULL; /* Keyboard hook for the random number generator */

DWORD ProcessedMouseEventsCounter = 0;

/* Variables for thread control, the thread is used to gather up info about

the system in in the background */

CRITICAL_SECTION critRandProt; /* The critical section */

BOOL volatile bThreadTerminate = FALSE; /* This variable is shared among thread's so its made volatile */

/* Network library handle for the SlowPoll function */

HANDLE hNetAPI32 = NULL;

// CryptoAPI

DWORD CryptoAPILastError = ERROR_SUCCESS;

/* Init the random number generator, setup the hooks, and start the thread */

int RandinitWithCheck ( int* pAlreadyInitialized)

{

BOOL bIgnoreHookError = FALSE;

DWORD dwLastError = ERROR_SUCCESS;

if (GetMaxPkcs5OutSize() > RNG_POOL_SIZE)

TC_THROW_FATAL_EXCEPTION;

if(bRandDidInit)

{

if (pAlreadyInitialized)

*pAlreadyInitialized = 1;

return 0;

}

if (pAlreadyInitialized)

*pAlreadyInitialized = 0;

InitializeCriticalSection (&critRandProt);

bRandDidInit = TRUE;

CryptoAPILastError = ERROR_SUCCESS;

ProcessedMouseEventsCounter = 0;

if (pRandPool == NULL)

{

pRandPool = (unsigned char *) _aligned_malloc (RANDOMPOOL_ALLOCSIZE, 16);

if (pRandPool == NULL)

goto error;

bDidSlowPoll = FALSE;

RandomPoolEnrichedByUser = FALSE;

memset (pRandPool, 0, RANDOMPOOL_ALLOCSIZE);

VirtualLock (pRandPool, RANDOMPOOL_ALLOCSIZE);

}

bIgnoreHookError = IsThreadInSecureDesktop(GetCurrentThreadId());

hKeyboard = SetWindowsHookEx (WH_KEYBOARD, (HOOKPROC)&KeyboardProc, NULL, GetCurrentThreadId ());

if (hKeyboard == 0 && !bIgnoreHookError) handleWin32Error (0, SRC_POS);

hMouse = SetWindowsHookEx (WH_MOUSE, (HOOKPROC)&MouseProc, NULL, GetCurrentThreadId ());

if (hMouse == 0 && !bIgnoreHookError)

{

handleWin32Error (0, SRC_POS);

goto error;

}

goto error;

}

else

if (!(PeriodicFastPollThreadHandle = (HANDLE) _beginthreadex (NULL, 0, PeriodicFastPollThreadProc, NULL, 0, NULL)))

goto error;

return 0;

error:

dwLastError = GetLastError();

RandStop (TRUE);

SetLastError (dwLastError);

return 1;

}

int Randinit ()

{

return RandinitWithCheck (NULL);

}

/* Close everything down, including the thread which is closed down by

setting a flag which eventually causes the thread function to exit */

void RandStop (BOOL freePool)

{

if (!bRandDidInit && freePool && pRandPool)

goto freePool;

if (bRandDidInit == FALSE)

return;

EnterCriticalSection (&critRandProt);

if (hMouse != 0)

UnhookWindowsHookEx (hMouse);

if (hKeyboard != 0)

UnhookWindowsHookEx (hKeyboard);

bThreadTerminate = TRUE;

LeaveCriticalSection (&critRandProt);

if (PeriodicFastPollThreadHandle)

WaitForSingleObject (PeriodicFastPollThreadHandle, INFINITE);

if (hNetAPI32 != 0)

{

FreeLibrary (hNetAPI32);

hNetAPI32 = NULL;

}

hMouse = NULL;

hKeyboard = NULL;

bThreadTerminate = FALSE;

DeleteCriticalSection (&critRandProt);

bRandDidInit = FALSE;

freePool:

if (freePool)

{

bDidSlowPoll = FALSE;

RandomPoolEnrichedByUser = FALSE;

if (pRandPool != NULL)

{

burn (pRandPool, RANDOMPOOL_ALLOCSIZE);

_aligned_free (pRandPool);

pRandPool = NULL;

}

}

}

BOOL IsRandomNumberGeneratorStarted ()

{

return bRandDidInit;

}

void RandSetHashFunction (int hash_algo_id)

{

}

}

/* Type definitions for function pointers to call NetAPI32 functions */

typedef

DWORD (WINAPI * NETSTATISTICSGET) (LPWSTR szServer, LPWSTR szService,

DWORD dwLevel, DWORD dwOptions,

LPBYTE * lpBuffer);

typedef

DWORD (WINAPI * NETAPIBUFFERSIZE) (LPVOID lpBuffer, LPDWORD cbBuffer);

typedef

DWORD (WINAPI * NETAPIBUFFERFREE) (LPVOID lpBuffer);

NETSTATISTICSGET pNetStatisticsGet = NULL;

NETAPIBUFFERSIZE pNetApiBufferSize = NULL;

NETAPIBUFFERFREE pNetApiBufferFree = NULL;

/* This is the slowpoll function which gathers up network/hard drive

performance data for the random pool */

BOOL SlowPoll (void)

{

static int isWorkstation = -1;

static int cbPerfData = 0x10000;

HANDLE hDevice;

LPBYTE lpBuffer;

DWORD dwSize, status;

LPWSTR lpszLanW, lpszLanS;

int nDrive;

/* Find out whether this is an NT server or workstation if necessary */

if (isWorkstation == -1)

{

HKEY hKey;

if (RegOpenKeyEx (HKEY_LOCAL_MACHINE,

L"SYSTEM\\CurrentControlSet\\Control\\ProductOptions",

0, KEY_READ, &hKey) == ERROR_SUCCESS)

{

wchar_t szValue[32];

dwSize = sizeof (szValue);

isWorkstation = TRUE;

status = RegQueryValueEx (hKey, L"ProductType", 0, NULL,

(LPBYTE) szValue, &dwSize);

if (status == ERROR_SUCCESS && _wcsicmp (szValue, L"WinNT"))

/* Note: There are (at least) three cases for

ProductType: WinNT = NT Workstation,

ServerNT = NT Server, LanmanNT = NT Server

acting as a Domain Controller */

isWorkstation = FALSE;

RegCloseKey (hKey);

}

}

/* Initialize the NetAPI32 function pointers if necessary */

if (hNetAPI32 == NULL)

{

RandaddBuf ((unsigned char *) lpBuffer, dwSize);

pNetApiBufferFree (lpBuffer);

}

/* Get disk I/O statistics for all the hard drives */

for (nDrive = 0;; nDrive++)

{

DISK_PERFORMANCE diskPerformance;

wchar_t szDevice[24];

/* Check whether we can access this device */

StringCchPrintfW (szDevice, ARRAYSIZE(szDevice), L"\\\\.\\PhysicalDrive%d", nDrive);

hDevice = CreateFile (szDevice, 0, FILE_SHARE_READ | FILE_SHARE_WRITE,

NULL, OPEN_EXISTING, 0, NULL);

if (hDevice == INVALID_HANDLE_VALUE)

break;

/* Note: This only works if you have turned on the disk

performance counters with 'diskperf -y'. These counters

are off by default */

if (DeviceIoControl (hDevice, IOCTL_DISK_PERFORMANCE, NULL, 0,

&diskPerformance, sizeof (DISK_PERFORMANCE),

&dwSize, NULL))

{

RandaddBuf ((unsigned char *) &diskPerformance, dwSize);

}

CloseHandle (hDevice);

}

{

RandaddBuf (buffer, sizeof (buffer));

}

else

{

return FALSE;

}

/* use JitterEntropy library to get good quality random bytes based on CPU timing jitter */

if (0 == jent_entropy_init ())

{

struct rand_data *ec = jent_entropy_collector_alloc (1, 0);

if (ec)

{

ssize_t rndLen = jent_read_entropy (ec, (char*) buffer, sizeof (buffer));

if (rndLen > 0)

RandaddBuf (buffer, (int) rndLen);

jent_entropy_collector_free (ec);

}

}

// use RDSEED or RDRAND from CPU as source of entropy if present

if ( IsCpuRngEnabled() &&

( (HasRDSEED() && RDSEED_getBytes (buffer, sizeof (buffer)))

|| (HasRDRAND() && RDRAND_getBytes (buffer, sizeof (buffer)))

))

{

RandaddBuf (buffer, sizeof (buffer));

}

burn(buffer, sizeof (buffer));

Randmix();

return TRUE;

}

/* This is the fastpoll function which gathers up info by calling various api's */

BOOL FastPoll (void)

{

int nOriginalRandIndex = nRandIndex;

static BOOL addedFixedItems = FALSE;

FILETIME creationTime, exitTime, kernelTime, userTime;

SIZE_T minimumWorkingSetSize, maximumWorkingSetSize;

LARGE_INTEGER performanceCount;

MEMORYSTATUSEX memoryStatus;

HANDLE handle;

POINT point;

/* Get various basic pieces of system information */

RandaddIntPtr (GetActiveWindow ()); /* Handle of active window */

RandaddIntPtr (GetCapture ()); /* Handle of window with mouse

capture */

RandaddIntPtr (GetClipboardOwner ()); /* Handle of clipboard owner */

RandaddIntPtr (GetClipboardViewer ()); /* Handle of start of

clpbd.viewer list */

RandaddIntPtr (GetCurrentProcess ()); /* Pseudohandle of current

process */

RandaddInt32 (GetCurrentProcessId ()); /* Current process ID */

RandaddIntPtr (GetCurrentThread ()); /* Pseudohandle of current

thread */

RandaddInt32 (GetCurrentThreadId ()); /* Current thread ID */

RandaddInt32 (GetCurrentTime ()); /* Milliseconds since Windows

started */

RandaddIntPtr (GetDesktopWindow ()); /* Handle of desktop window */

RandaddIntPtr (GetFocus ()); /* Handle of window with kb.focus */

RandaddInt32 (GetInputState ()); /* Whether sys.queue has any events */

RandaddInt32 (GetMessagePos ()); /* Cursor pos.for last message */

RandaddInt32 (GetMessageTime ()); /* 1 ms time for last message */

RandaddIntPtr (GetOpenClipboardWindow ()); /* Handle of window with

clpbd.open */

RandaddIntPtr (GetProcessHeap ()); /* Handle of process heap */

RandaddIntPtr (GetProcessWindowStation ()); /* Handle of procs

window station */

RandaddInt32 (GetQueueStatus (QS_ALLEVENTS)); /* Types of events in

input queue */

/* Get multiword system information */

&maximumWorkingSetSize);

RandaddIntPtr (minimumWorkingSetSize);

RandaddIntPtr (maximumWorkingSetSize);

/* The following are fixed for the lifetime of the process so we only

add them once */

if (addedFixedItems == 0)

{

STARTUPINFO startupInfo;

/* Get name of desktop, console window title, new window

position and size, window flags, and handles for stdin,

stdout, and stderr */

startupInfo.cb = sizeof (STARTUPINFO);

GetStartupInfo (&startupInfo);

RandaddBuf ((unsigned char *) &startupInfo, sizeof (STARTUPINFO));

addedFixedItems = TRUE;

}

/* The docs say QPC can fail if appropriate hardware is not

available. It works on 486 & Pentium boxes, but hasn't been tested

for 386 or RISC boxes */

if (QueryPerformanceCounter (&performanceCount))

RandaddBuf ((unsigned char *) &performanceCount, sizeof (LARGE_INTEGER));

else

{

/* Millisecond accuracy at best... */

DWORD dwTicks = GetTickCount ();

RandaddBuf ((unsigned char *) &dwTicks, sizeof (dwTicks));

}

{

RandaddBuf (buffer, sizeof (buffer));

}

else

{

return FALSE;

}

// use RDSEED or RDRAND from CPU as source of entropy if enabled

if ( IsCpuRngEnabled() &&

( (HasRDSEED() && RDSEED_getBytes (buffer, sizeof (buffer)))

|| (HasRDRAND() && RDRAND_getBytes (buffer, sizeof (buffer)))

))

{

RandaddBuf (buffer, sizeof (buffer));

}

burn (buffer, sizeof(buffer));

/* Apply the pool mixing function */

Randmix();

/* Restore the original pool cursor position. If this wasn't done, mouse coordinates

could be written to a limited area of the pool, especially when moving the mouse

uninterruptedly. The severity of the problem would depend on the length of data

written by FastPoll (if it was equal to the size of the pool, mouse coordinates

would be written only to a particular 4-byte area, whenever moving the mouse

uninterruptedly). */

nRandIndex = nOriginalRandIndex;

return TRUE;

}

# ifdef __cplusplus

extern "C"

# endif

void ThrowFatalException (int line);

# define TC_THROW_FATAL_EXCEPTION ThrowFatalException (__LINE__)

#elif defined (TC_WINDOWS_DRIVER)

# define TC_THROW_FATAL_EXCEPTION KeBugCheckEx (SECURITY_SYSTEM, __LINE__, 0, 0, 'VC')

#elif defined(_UEFI)

void ThrowFatalException(int line);

# define TC_THROW_FATAL_EXCEPTION ThrowFatalException (__LINE__)

#elif (defined(__clang__) && __has_builtin(__builtin_trap)) \

|| (defined(__GNUC__ ) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3))) \

|| (__has_builtin(__builtin_trap))

# define TC_THROW_FATAL_EXCEPTION __builtin_trap()

#else

# define TC_THROW_FATAL_EXCEPTION *(char *) 0 = 0

#endif

#ifdef __COVERITY__

#undef TC_THROW_FATAL_EXCEPTION

#define TC_THROW_FATAL_EXCEPTION __coverity_panic__()

#endif

#ifdef TC_WINDOWS_DRIVER

#include <ntifs.h>

#include <ntddk.h> /* Standard header file for nt drivers */

#include <ntdddisk.h> /* Standard I/O control codes */

extern ULONG AllocTag;

#define TCfree(memblock) ExFreePoolWithTag( memblock, AllocTag )

#define DEVICE_DRIVER

#ifndef BOOL

typedef int BOOL;

#endif

#ifndef WORD

typedef USHORT WORD;

#endif

#ifndef BOOLEAN

typedef unsigned char BOOLEAN;

#endif

#ifndef TRUE

#define TRUE 1

#endif

#ifndef FALSE

#define FALSE !TRUE

#endif

typedef NTSTATUS (NTAPI *KeSaveExtendedProcessorStateFn) (

__in ULONG64 Mask,

PXSTATE_SAVE XStateSave

);

const char* hexOutput;

} HashTestVector;

typedef int (__cdecl HashFunction) (unsigned char* input, unsigned long inputLen, unsigned char* output);

unsigned char HexCharToByte (char c)

{

if (c >= ('0') && c <= ('9'))

return c - ('0');

else if (c >= ('A') && c <= ('F'))

return c - ('A') + 10;

else if (c >= ('a') && c <= ('f'))

return c - ('a') + 10;

else

return 0xFF;

}

unsigned long HexStringToByteArray(const char* hexStr, unsigned char* pbData)

{

unsigned long count = 0;

while (*hexStr)

{

*pbData++ = (HexCharToByte(hexStr[0]) << 4) | HexCharToByte(hexStr[1]);

hexStr += 2;

count++;

}

return count;

}

{

CRYPTOPP_ALIGN_DATA (16) unsigned char input[256];

unsigned char output[64];

unsigned char digest[64];

unsigned long i = 0, inputLen, outputLen, digestLen;

BOOL bRet = TRUE;

while (vector[i].hexInput && vector[i].hexOutput)

{

inputLen = HexStringToByteArray (vector[i].hexInput, input);

outputLen = HexStringToByteArray (vector[i].hexOutput, output);

digestLen = fn (input, inputLen, digest);

if ((digestLen != outputLen) || (0 != memcmp (digest, output, digestLen)))

{

bRet = FALSE;

break;

}

i++;

}

return bRet;

}

/* https://www.streebog.net/src/trunk/examples/ */

HashTestVector Streebog512TestVectors[] = {

/* M1 */

{"303132333435363738393031323334353637383930313233343536373839303132333435363738393031323334353637383930313233343536373839303132",

"1b54d01a4af5b9d5cc3d86d68d285462b19abc2475222f35c085122be4ba1ffa00ad30f8767b3a82384c6574f024c311e2a481332b08ef7f41797891c1646f48"

},

/* M2 */

{"d1e520e2e5f2f0e82c20d1f2f0e8e1eee6e820e2edf3f6e82c20e2e5fef2fa20f120eceef0ff20f1f2f0e5ebe0ece820ede020f5f0e0e1f0fbff20efebfaeafb20c8e3eef0e5e2fb",

"1e88e62226bfca6f9994f1f2d51569e0daf8475a3b0fe61a5300eee46d961376035fe83549ada2b8620fcd7c496ce5b33f0cb9dddc2b6460143b03dabac9fb28"

},

/* M3 */

{"",

"8e945da209aa869f0455928529bcae4679e9873ab707b55315f56ceb98bef0a7362f715528356ee83cda5f2aac4c6ad2ba3a715c1bcd81cb8e9f90bf4c1c1a8a"

},

/* M4 */

{"00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",

"b0fd29ac1b0df441769ff3fdb8dc564df67721d6ac06fb28ceffb7bbaa7948c6c014ac999235b58cb26fb60fb112a145d7b4ade9ae566bf2611402c552d20db7"

},

{NULL, NULL}

};

/* https://github.com/openssl/openssl/blob/2d0b44126763f989a4cbffbffe9d0c7518158bb7/test/evptests.txt */

HashTestVector Blake2sTestVectors[] = {

{"",

"69217a3079908094e11121d042354a7c1f55b6482ca1a51e1b250dfd1ed0eef9"

},

{"61",

"4a0d129873403037c2cd9b9048203687f6233fb6738956e0349bd4320fec3e90"

},

{"616263",

"508c5e8c327c14e2e1a72ba34eeb452f37458b209ed63a294d999b4c86675982"

},

{"6d65737361676520646967657374",

"fa10ab775acf89b7d3c8a6e823d586f6b67bdbac4ce207fe145b7d3ac25cd28c"

},

{"6162636465666768696a6b6c6d6e6f707172737475767778797a",

"bdf88eb1f86a0cdf0e840ba88fa118508369df186c7355b4b16cf79fa2710a12"

},

{"4142434445464748494a4b4c4d4e4f505152535455565758595a6162636465666768696a6b6c6d6e6f707172737475767778797a30313233343536373839",

"c75439ea17e1de6fa4510c335dc3d3f343e6f9e1ce2773e25b4174f1df8b119b"

},

{"3132333435363738393031323334353637383930313233343536373839303132333435363738393031323334353637383930313233343536373839303132333435363738393031323334353637383930",

"fdaedb290a0d5af9870864fec2e090200989dc9cd53a3c092129e8535e8b4f66"

},

{NULL, NULL}

};

unsigned char ks_tmp[MAX_EXPANDED_KEY];

{

switch (cipher)

{

case AES:

CipherInit(cipher,key,ks);

break;

case SERPENT:

CipherInit(cipher,key,ks);

break;

case TWOFISH:

CipherInit(cipher,key,ks);

break;

case CAMELLIA:

CipherInit(cipher,key,ks);

break;

case KUZNYECHIK:

CipherInit(cipher, key, ks);

break;

default:

/* Unknown/wrong ID */

TC_THROW_FATAL_EXCEPTION;

}

}

BOOL TestSectorBufEncryption (PCRYPTO_INFO ci)

}

else if (wcscmp (name, L"Kuznyechik-AES") == 0)

{

if (crc != 0x4641234a)

return FALSE;

nTestsPerformed++;

}

else if (wcscmp (name, L"Kuznyechik-Serpent-Camellia") == 0)

{

if (crc != 0x755dad72)

return FALSE;

nTestsPerformed++;

}

#endif

if (crc == 0x9f5edd58)

return FALSE;

DecryptBuffer (buf, sizeof (buf), ci);

if (GetCrc32 (buf, sizeof (buf)) != 0x9f5edd58)

return FALSE;

nTestsPerformed++;

}

return (nTestsPerformed == 150);

}

static BOOL DoAutoTestAlgorithms (void)

{

PCRYPTO_INFO ci;

unsigned char tmp[16];

BOOL bFailed = FALSE;

int i;

ci = crypto_open ();

if (!ci)

return FALSE;

memset (ci, 0, sizeof (*ci));

/* AES */

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

{

int cipher = AES;

memcpy(key, aes_ecb_vectors[i].key, 32);

memcpy(tmp, aes_ecb_vectors[i].plaintext, 16);

CipherInit(cipher, key, ks_tmp);

EncipherBlock(cipher, tmp, ks_tmp);

if (memcmp(aes_ecb_vectors[i].ciphertext, tmp, 16) != 0)

break;

DecipherBlock(cipher, tmp, ks_tmp);

if (memcmp(aes_ecb_vectors[i].plaintext, tmp, 16) != 0)

break;

}

if (i != AES_TEST_COUNT)

bFailed = TRUE;

// AES EncipherBlocks()/DecipherBlocks()

{

uint8 testData[1024];

uint32 origCrc;

for (i = 0; i < sizeof (testData); ++i)

{

testData[i] = (uint8) i;

}

origCrc = GetCrc32 (testData, sizeof (testData));

CipherInit (AES, testData, ks_tmp);

EncipherBlocks (AES, testData, ks_tmp, sizeof (testData) / CipherGetBlockSize (AES));

if (GetCrc32 (testData, sizeof (testData)) != 0xb5cd5631)

bFailed = TRUE;

DecipherBlocks (AES, testData, ks_tmp, sizeof (testData) / CipherGetBlockSize (AES));

if (origCrc != GetCrc32 (testData, sizeof (testData)))

bFailed = TRUE;

}

#ifndef WOLFCRYPT_BACKEND

/* Serpent */

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

{

int cipher = SERPENT;

memcpy(key, serpent_vectors[i].key, 32);

memcpy(tmp, serpent_vectors[i].plaintext, 16);

CipherInit(cipher, key, ks_tmp);

{

exceptionCatched = TRUE;

}

if (exceptionCatched)

{

/* unexepected exception raised. Disable all CPU extended feature and try again */

EnableHwEncryption (hwEncryptionEnabled);

DisableCPUExtendedFeatures ();

__try

{

result = DoAutoTestAlgorithms();

}

__except (EXCEPTION_EXECUTE_HANDLER)

{

/* exception still occuring. Report failure. */

result = FALSE;

}

}

#endif

return result;

}

BOOL test_hmac_sha256 ()

{

unsigned int i;

int nTestsPerformed = 0;

for (i = 0; i < sizeof (hmac_sha256_test_data) / sizeof(char *); i++)

{

size_t dataLen = strlen (hmac_sha256_test_data[i]);

if (dataLen <= sizeof(digest))

{

memcpy (digest, hmac_sha256_test_data[i], dataLen);

if (memcmp (digest, hmac_sha256_test_vectors[i], SHA256_DIGESTSIZE) != 0)

return FALSE;

else

nTestsPerformed++;

}

else

{

return FALSE;

}

}

return (nTestsPerformed == 6);

}

BOOL test_hmac_sha512 ()

{

unsigned int i;

int nTestsPerformed = 0;

for (i = 0; i < sizeof (hmac_sha512_test_data) / sizeof(char *); i++)

{

size_t dataLen = strlen (hmac_sha512_test_data[i]);

if (dataLen <= sizeof(digest))

{

memcpy (digest, hmac_sha512_test_data[i], dataLen );

if (memcmp (digest, hmac_sha512_test_vectors[i], SHA512_DIGESTSIZE) != 0)

return FALSE;

else

nTestsPerformed++;

}

else

{

return FALSE;

}

}

return (nTestsPerformed == 6);

}

#ifndef WOLFCRYPT_BACKEND

BOOL test_hmac_blake2s ()

{

unsigned int i;

int nTestsPerformed = 0;

for (i = 0; i < sizeof (hmac_blake2s_test_data) / sizeof(char *); i++)

{

size_t dataLen = strlen (hmac_blake2s_test_data[i]);

if (dataLen <= sizeof(digest))

{

memcpy (digest, hmac_blake2s_test_data[i], dataLen);

if (memcmp (digest, hmac_blake2s_test_vectors[i], BLAKE2S_DIGESTSIZE) != 0)

return FALSE;

else

nTestsPerformed++;

}

else

{

return FALSE;

}

}

return (nTestsPerformed == 6);

}

int __cdecl Blake2sHash (unsigned char* input, unsigned long inputLen, unsigned char* output)

{

blake2s(output, input, (size_t) inputLen);

return BLAKE2S_DIGESTSIZE;

}

BOOL test_hmac_whirlpool ()

{

unsigned char digest[1024]; /* large enough to hold digets and test vector inputs */

memcpy (digest, hmac_whirlpool_test_data, strlen (hmac_whirlpool_test_data));

if (memcmp (digest, hmac_whirlpool_test_vectors, WHIRLPOOL_DIGESTSIZE) != 0)

return FALSE;

return TRUE;

}

#endif

/* http://www.tc26.ru/methods/recommendation/%D0%A2%D0%9A26%D0%90%D0%9B%D0%93.pdf */

/* https://tools.ietf.org/html/draft-smyshlyaev-gost-usage-00 */

/* https://datatracker.ietf.org/doc/rfc7836/?include_text=1 */

static const unsigned char gost3411_2012_hmac_k1[] = {

0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,

0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,

0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,

0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f

};

static const unsigned char gost3411_2012_hmac_m1[] = {

0x01, 0x26, 0xbd, 0xb8, 0x78, 0x00, 0xaf, 0x21,

0x43, 0x41, 0x45, 0x65, 0x63, 0x78, 0x01, 0x00

};

static const unsigned char gost3411_2012_hmac_r1[] = {

0xA5, 0x9B, 0xAB, 0x22, 0xEC, 0xAE, 0x19, 0xC6, 0x5F, 0xBD, 0xE6, 0xE5,

0xF4, 0xE9, 0xF5, 0xD8, 0x54, 0x9D, 0x31, 0xF0, 0x37, 0xF9, 0xDF, 0x9B,

0x90, 0x55, 0x00, 0xE1, 0x71, 0x92, 0x3A, 0x77, 0x3D, 0x5F, 0x15, 0x30,

0xF2, 0xED, 0x7E, 0x96, 0x4C, 0xB2, 0xEE, 0xDC, 0x29, 0xE9, 0xAD, 0x2F,

0x3A, 0xFE, 0x93, 0xB2, 0x81, 0x4F, 0x79, 0xF5, 0x00, 0x0F, 0xFC, 0x03,

0x66, 0xC2, 0x51, 0xE6

};

#ifndef WOLFCRYPT_BACKEND

BOOL test_hmac_streebog ()

{

memcpy (digest, gost3411_2012_hmac_m1, sizeof (gost3411_2012_hmac_m1));

if (memcmp (digest, gost3411_2012_hmac_r1, STREEBOG_DIGESTSIZE) != 0)

return FALSE;

return TRUE;

}

int __cdecl StreebogHash (unsigned char* input, unsigned long inputLen, unsigned char* output)

{

STREEBOG_CTX ctx;

STREEBOG_init (&ctx);

STREEBOG_add (&ctx, input, inputLen);

STREEBOG_finalize (&ctx, output);

return STREEBOG_DIGESTSIZE;

}

#endif

BOOL test_pkcs5 ()

{

/* HMAC-SHA-256 tests */

if (!test_hmac_sha256())

return FALSE;

/* HMAC-SHA-512 tests */

if (!test_hmac_sha512())

return FALSE;

#ifndef WOLFCRYPT_BACKEND

/* HMAC-BLAKE2s tests */

if (test_hmac_blake2s() == FALSE)

return FALSE;

/* Blake2s hash tests */

return FALSE;

/* HMAC-Whirlpool tests */

if (test_hmac_whirlpool() == FALSE)

return FALSE;

/* HMAC-STREEBOG tests */

if (test_hmac_streebog() == FALSE)

return FALSE;

/* STREEBOG hash tests */

return FALSE;

#endif

/* PKCS-5 test 1 with HMAC-SHA-256 used as the PRF (https://tools.ietf.org/html/draft-josefsson-scrypt-kdf-00) */

if (memcmp (dk, "\x55\xac\x04\x6e\x56\xe3\x08\x9f\xec\x16\x91\xc2\x25\x44\xb6\x05\xf9\x41\x85\x21\x6d\xde\x04\x65\xe6\x8b\x9d\x57\xc2\x0d\xac\xbc\x49\xca\x9c\xcc\xf1\x79\xb6\x45\x99\x16\x64\xb3\x9d\x77\xef\x31\x7c\x71\xb8\x45\xb1\xe3\x0b\xd5\x09\x11\x20\x41\xd3\xa1\x97\x83", 64) != 0)

return FALSE;

/* PKCS-5 test 2 with HMAC-SHA-256 used as the PRF (https://stackoverflow.com/questions/5130513/pbkdf2-hmac-sha2-test-vectors) */

if (memcmp (dk, "\xae\x4d\x0c\x95\xaf\x6b\x46\xd3\x2d\x0a\xdf\xf9\x28\xf0\x6d\xd0\x2a\x30\x3f\x8e\xf3\xc2\x51\xdf\xd6\xe2\xd8\x5a\x95\x47\x4c\x43", 32) != 0)

return FALSE;

/* PKCS-5 test 3 with HMAC-SHA-256 used as the PRF (MS CryptoAPI) */

if (memcmp (dk, "\xf2\xa0\x4f\xb2", 4) != 0)

return FALSE;

/* PKCS-5 test 4 with HMAC-SHA-256 used as the PRF (MS CryptoAPI) */

if (memcmp (dk, "\xf2\xa0\x4f\xb2\xd3\xe9\xa5\xd8\x51\x0b\x5c\x06\xdf\x70\x8e\x24\xe9\xc7\xd9\x15\x3d\x22\xcd\xde\xb8\xa6\xdb\xfd\x71\x85\xc6\x99\x32\xc0\xee\x37\x27\xf7\x24\xcf\xea\xa6\xac\x73\xa1\x4c\x4e\x52\x9b\x94\xf3\x54\x06\xfc\x04\x65\xa1\x0a\x24\xfe\xf0\x98\x1d\xa6\x22\x28\xeb\x24\x55\x74\xce\x6a\x3a\x28\xe2\x04\x3a\x59\x13\xec\x3f\xf2\xdb\xcf\x58\xdd\x53\xd9\xf9\x17\xf6\xda\x74\x06\x3c\x0b\x66\xf5\x0f\xf5\x58\xa3\x27\x52\x8c\x5b\x07\x91\xd0\x81\xeb\xb6\xbc\x30\x69\x42\x71\xf2\xd7\x18\x42\xbe\xe8\x02\x93\x70\x66\xad\x35\x65\xbc\xf7\x96\x8e\x64\xf1\xc6\x92\xda\xe0\xdc\x1f\xb5\xf4", 144) != 0)

return FALSE;

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

if (memcmp (dk, "\x13\x64\xae\xf8", 4) != 0)

return FALSE;

/* PKCS-5 test 2 with HMAC-SHA-512 used as the PRF (derives a key longer than the underlying

hash output size and block size) */

if (memcmp (dk, "\x13\x64\xae\xf8\x0d\xf5\x57\x6c\x30\xd5\x71\x4c\xa7\x75\x3f\xfd\x00\xe5\x25\x8b\x39\xc7\x44\x7f\xce\x23\x3d\x08\x75\xe0\x2f\x48\xd6\x30\xd7\x00\xb6\x24\xdb\xe0\x5a\xd7\x47\xef\x52\xca\xa6\x34\x83\x47\xe5\xcb\xe9\x87\xf1\x20\x59\x6a\xe6\xa9\xcf\x51\x78\xc6\xb6\x23\xa6\x74\x0d\xe8\x91\xbe\x1a\xd0\x28\xcc\xce\x16\x98\x9a\xbe\xfb\xdc\x78\xc9\xe1\x7d\x72\x67\xce\xe1\x61\x56\x5f\x96\x68\xe6\xe1\xdd\xf4\xbf\x1b\x80\xe0\x19\x1c\xf4\xc4\xd3\xdd\xd5\xd5\x57\x2d\x83\xc7\xa3\x37\x87\xf4\x4e\xe0\xf6\xd8\x6d\x65\xdc\xa0\x52\xa3\x13\xbe\x81\xfc\x30\xbe\x7d\x69\x58\x34\xb6\xdd\x41\xc6", 144) != 0)

return FALSE;

#ifndef WOLFCRYPT_BACKEND

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

if (memcmp (dk, "\x8d\x51\xfa\x31", 4) != 0)

return FALSE;

/* PKCS-5 test 2 with HMAC-BLAKE2s used as the PRF (derives a key longer than the underlying hash) */

if (memcmp (dk, "\x8d\x51\xfa\x31\x46\x25\x37\x67\xa3\x29\x6b\x3c\x6b\xc1\x5d\xb2\xee\xe1\x6c\x28\x00\x26\xea\x08\x65\x9c\x12\xf1\x07\xde\x0d\xb9\x9b\x4f\x39\xfa\xc6\x80\x26\xb1\x8f\x8e\x48\x89\x85\x2d\x24\x2d", 48) != 0)

return FALSE;

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

if (memcmp (dk, "\x50\x7c\x36\x6f", 4) != 0)

return FALSE;

/* PKCS-5 test 2 with HMAC-Whirlpool used as the PRF (derives a key longer than the underlying hash) */

if (memcmp (dk, "\x50\x7c\x36\x6f\xee\x10\x2e\x9a\xe2\x8a\xd5\x82\x72\x7d\x27\x0f\xe8\x4d\x7f\x68\x7a\xcf\xb5\xe7\x43\x67\xaa\x98\x93\x52\x2b\x09\x6e\x42\xdf\x2c\x59\x4a\x91\x6d\x7e\x10\xae\xb2\x1a\x89\x8f\xb9\x8f\xe6\x31\xa9\xd8\x9f\x98\x26\xf4\xda\xcd\x7d\x65\x65\xde\x10\x95\x91\xb4\x84\x26\xae\x43\xa1\x00\x5b\x1e\xb8\x38\x97\xa4\x1e\x4b\xd2\x65\x64\xbc\xfa\x1f\x35\x85\xdb\x4f\x97\x65\x6f\xbd\x24", 96) != 0)

return FALSE;

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

if (memcmp (dk, "\xd0\x53\xa2\x30", 4) != 0)

return FALSE;

/* PKCS-5 test 2 with HMAC-STREEBOG used as the PRF (derives a key longer than the underlying hash) */

if (memcmp (dk, "\xd0\x53\xa2\x30\x6f\x45\x81\xeb\xbc\x06\x81\xc5\xe7\x53\xa8\x5d\xc7\xf1\x23\x33\x1e\xbe\x64\x2c\x3b\x0f\x26\xd7\x00\xe1\x95\xc9\x65\x26\xb1\x85\xbe\x1e\xe2\xf4\x9b\xfc\x6b\x14\x84\xda\x24\x61\xa0\x1b\x9e\x79\x5c\xee\x69\x6e\xf9\x25\xb1\x1d\xca\xa0\x31\xba\x02\x6f\x9e\x99\x0f\xdb\x25\x01\x5b\xf1\xc7\x10\x19\x53\x3b\x29\x3f\x18\x00\xd6\xfc\x85\x03\xdc\xf2\xe5\xe9\x5a\xb1\x1e\x61\xde", 96) != 0)

return FALSE;

#endif

return TRUE;

}

/*

Legal Notice: Some portions of the source code contained in this file were

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

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

governed by the TrueCrypt License 3.0, also from the source code of

Encryption for the Masses 2.02a, which is Copyright (c) 1998-2000 Paul Le Roux

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)

and all other portions of this file are Copyright (c) 2013-2017 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

code distribution packages. */

#ifdef __cplusplus

extern "C" {

#endif

extern unsigned char ks_tmp[MAX_EXPANDED_KEY];

BOOL test_hmac_sha512 (void);

BOOL test_hmac_blake2s (void);

BOOL test_hmac_whirlpool (void);

BOOL test_pkcs5 (void);

BOOL TestSectorBufEncryption ();

BOOL TestLegacySectorBufEncryption ();

BOOL AutoTestAlgorithms (void);

#ifdef __cplusplus

}

#endif

uint16 GetHeaderField16 (uint8 *header, int offset)

{

return BE16 (*(uint16 *) (header + offset));

}

uint32 GetHeaderField32 (uint8 *header, int offset)

{

return BE32 (*(uint32 *) (header + offset));

}

UINT64_STRUCT GetHeaderField64 (uint8 *header, int offset)

{

UINT64_STRUCT uint64Struct;

#ifndef TC_NO_COMPILER_INT64

uint64Struct.Value = BE64 (*(uint64 *) (header + offset));

#else

uint64Struct.HighPart = BE32 (*(uint32 *) (header + offset));

uint64Struct.LowPart = BE32 (*(uint32 *) (header + offset + 4));

#endif

return uint64Struct;

}

#ifndef TC_WINDOWS_BOOT

typedef struct

{

BOOL Free;

LONG KeyReady;

int Pkcs5Prf;

} KeyDerivationWorkItem;

BOOL ReadVolumeHeaderRecoveryMode = FALSE;

{

unsigned char* keyInfoBuffer = NULL;

int keyInfoBufferSize = sizeof (KEY_INFO) + 16;

size_t keyInfoBufferOffset;

PKEY_INFO keyInfo;

PCRYPTO_INFO cryptoInfo;

int enqPkcs5Prf, pkcs5_prf;

uint16 headerVersion;

int status = ERR_PARAMETER_INCORRECT;

int primaryKeyOffset;

int pkcs5PrfCount = LAST_PRF_ID - FIRST_PRF_ID + 1;

#if !defined(_UEFI)

TC_EVENT *keyDerivationCompletedEvent = NULL;

TC_EVENT *noOutstandingWorkItemEvent = NULL;

KeyDerivationWorkItem *keyDerivationWorkItems = NULL;

int keyDerivationWorkItemsSize = 0;

KeyDerivationWorkItem *item;

size_t encryptionThreadCount = GetEncryptionThreadCount();

LONG *outstandingWorkItemCount = NULL;

int i;

#endif

size_t queuedWorkItems = 0;

// allocate 16-bytes aligned buffer to hold KEY_INFO in a portable way

keyInfoBuffer = TCalloc(keyInfoBufferSize);

if (!keyInfoBuffer)

return ERR_OUTOFMEMORY;

keyInfoBufferOffset = 16 - (((uint64) keyInfoBuffer) % 16);

keyInfo = (PKEY_INFO) (keyInfoBuffer + keyInfoBufferOffset);

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

VirtualLock (keyInfoBuffer, keyInfoBufferSize);

#endif

// if no PIM specified, use default value

if (pim < 0)

WHIRLPOOL_add (bootLoaderBuf + TC_SECTOR_SIZE_BIOS, (bootLoaderSize - TC_SECTOR_SIZE_BIOS), &whirlpool);

sha512_hash (bootLoaderBuf + TC_SECTOR_SIZE_BIOS, (bootLoaderSize - TC_SECTOR_SIZE_BIOS), &sha2);

WHIRLPOOL_finalize (&whirlpool, fingerprint);

sha512_end (&fingerprint [WHIRLPOOL_DIGESTSIZE], &sha2);

#else

sha512_ctx sha2_512;

sha256_ctx sha2_256;

sha512_begin (&sha2_512);

sha256_begin (&sha2_256);

sha512_hash (bootLoaderBuf, TC_BOOT_SECTOR_PIM_VALUE_OFFSET, &sha2_512);

sha256_hash (bootLoaderBuf, TC_BOOT_SECTOR_PIM_VALUE_OFFSET, &sha2_256);

sha512_hash (bootLoaderBuf + TC_BOOT_SECTOR_USER_MESSAGE_OFFSET + TC_BOOT_SECTOR_USER_MESSAGE_MAX_LENGTH, (TC_BOOT_SECTOR_USER_CONFIG_OFFSET - (TC_BOOT_SECTOR_USER_MESSAGE_OFFSET + TC_BOOT_SECTOR_USER_MESSAGE_MAX_LENGTH)), &sha2_512);

sha256_hash (bootLoaderBuf + TC_BOOT_SECTOR_USER_MESSAGE_OFFSET + TC_BOOT_SECTOR_USER_MESSAGE_MAX_LENGTH, (TC_BOOT_SECTOR_USER_CONFIG_OFFSET - (TC_BOOT_SECTOR_USER_MESSAGE_OFFSET + TC_BOOT_SECTOR_USER_MESSAGE_MAX_LENGTH)), &sha2_256);

sha512_hash (bootLoaderBuf + TC_SECTOR_SIZE_BIOS, (bootLoaderSize - TC_SECTOR_SIZE_BIOS), &sha2_512);

sha256_hash (bootLoaderBuf + TC_SECTOR_SIZE_BIOS, (bootLoaderSize - TC_SECTOR_SIZE_BIOS), &sha2_256);

sha512_end (&fingerprint, &sha2_512);

sha256_end (&fingerprint [SHA512_DIGESTSIZE], &sha2_256);

sha256_end (&fingerprint [SHA512_DIGESTSIZE + SHA256_DIGESTSIZE], &sha2_256);

#endif

}

#endif

#else // TC_WINDOWS_BOOT

{

#ifdef TC_WINDOWS_BOOT_SINGLE_CIPHER_MODE

#else

#endif

PCRYPTO_INFO cryptoInfo;

int status = ERR_SUCCESS;

uint32 iterations = pim;

iterations <<= 16;

iterations |= bBoot;

if (retHeaderCryptoInfo != NULL)

cryptoInfo = retHeaderCryptoInfo;

else

cryptoInfo = *retInfo = crypto_open ();

// PKCS5 PRF

#ifdef TC_WINDOWS_BOOT_SHA2

derive_key_sha256 (password->Text, (int) password->Length, header + HEADER_SALT_OFFSET,

PKCS5_SALT_SIZE, iterations, dk, sizeof (dk));

#else

derive_key_blake2s (password->Text, (int) password->Length, header + HEADER_SALT_OFFSET,

PKCS5_SALT_SIZE, iterations, dk, sizeof (dk));

#endif

// Mode of operation

cryptoInfo->mode = FIRST_MODE_OF_OPERATION_ID;

#ifdef TC_WINDOWS_BOOT_SINGLE_CIPHER_MODE

cryptoInfo->ea = 1;

#else

// Test all available encryption algorithms

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

#endif

goto ret;

}

status = ERR_PASSWORD_WRONG;

err:

if (cryptoInfo != retHeaderCryptoInfo)

{

crypto_close(cryptoInfo);

*retInfo = NULL;

}

ret:

burn (dk, sizeof(dk));

return status;

}

#endif // TC_WINDOWS_BOOT

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

#ifdef VOLFORMAT

# include "../Format/TcFormat.h"

# include "Dlgcode.h"

#endif

// Creates a volume header in memory

#if defined(_UEFI)

int pkcs5_prf, int pim, char *masterKeydata, PCRYPTO_INFO *retInfo,

unsigned __int64 volumeSize, unsigned __int64 hiddenVolumeSize,

unsigned __int64 encryptedAreaStart, unsigned __int64 encryptedAreaLength, uint16 requiredProgramVersion, uint32 headerFlags, uint32 sectorSize, BOOL bWipeMode)

#else

int pkcs5_prf, int pim, char *masterKeydata, PCRYPTO_INFO *retInfo,

unsigned __int64 volumeSize, unsigned __int64 hiddenVolumeSize,

unsigned __int64 encryptedAreaStart, unsigned __int64 encryptedAreaLength, uint16 requiredProgramVersion, uint32 headerFlags, uint32 sectorSize, BOOL bWipeMode)

#endif // !defined(_UEFI)

{

static CRYPTOPP_ALIGN_DATA(16) KEY_INFO keyInfo;

int nUserKeyLen = password? password->Length : 0;

PCRYPTO_INFO cryptoInfo = crypto_open ();

static char dk[MASTER_KEYDATA_SIZE];

int x;

int retVal = 0;

int primaryKeyOffset;

if (cryptoInfo == NULL)

return ERR_OUTOFMEMORY;

// if no PIM specified, use default value

if (pim < 0)

pim = 0;

memset (header, 0, TC_VOLUME_HEADER_EFFECTIVE_SIZE);

#if !defined(_UEFI)

VirtualLock (&keyInfo, sizeof (keyInfo));

VirtualLock (&dk, sizeof (dk));

#endif // !defined(_UEFI)

/* Encryption setup */

if (masterKeydata == NULL)

{

// We have no master key data (creating a new volume) so we'll use the TrueCrypt RNG to generate them

int bytesNeeded;

#define TC_HEADER_OFFSET_MAGIC 64

#define TC_HEADER_OFFSET_VERSION 68

#define TC_HEADER_OFFSET_REQUIRED_VERSION 70

#define TC_HEADER_OFFSET_KEY_AREA_CRC 72

#define TC_HEADER_OFFSET_VOLUME_CREATION_TIME 76

#define TC_HEADER_OFFSET_MODIFICATION_TIME 84

#define TC_HEADER_OFFSET_HIDDEN_VOLUME_SIZE 92

#define TC_HEADER_OFFSET_VOLUME_SIZE 100

#define TC_HEADER_OFFSET_ENCRYPTED_AREA_START 108

#define TC_HEADER_OFFSET_ENCRYPTED_AREA_LENGTH 116

#define TC_HEADER_OFFSET_FLAGS 124

#define TC_HEADER_OFFSET_SECTOR_SIZE 128

#define TC_HEADER_OFFSET_HEADER_CRC 252

// Volume header flags

#define TC_HEADER_FLAG_ENCRYPTED_SYSTEM 0x1

#define TC_HEADER_FLAG_NONSYS_INPLACE_ENC 0x2 // The volume has been created (or is being encrypted/decrypted) using non-system in-place encryption

#ifndef TC_HEADER_Volume_VolumeHeader

#include "Password.h"

extern BOOL ReadVolumeHeaderRecoveryMode;

uint16 GetHeaderField16 (uint8 *header, int offset);

uint32 GetHeaderField32 (uint8 *header, int offset);

UINT64_STRUCT GetHeaderField64 (uint8 *header, int offset);

#if defined(TC_WINDOWS_BOOT)

#elif defined(_UEFI)

BOOL RandgetBytes(unsigned char *buf, int len, BOOL forceSlowPoll);

#else

#if defined(_WIN32) && !defined(_UEFI)

void ComputeBootloaderFingerprint (uint8 *bootLoaderBuf, unsigned int bootLoaderSize, uint8* fingerprint);

#endif

#endif

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

BOOL ReadEffectiveVolumeHeader (BOOL device, HANDLE fileHandle, uint8 *header, DWORD *bytesRead);

BOOL WriteEffectiveVolumeHeader (BOOL device, HANDLE fileHandle, uint8 *header);

int WriteRandomDataToReservedHeaderAreas (HWND hwndDlg, HANDLE dev, CRYPTO_INFO *cryptoInfo, uint64 dataAreaSize, BOOL bPrimaryOnly, BOOL bBackupOnly);

#endif

#endif // !TC_HEADER_Volume_VolumeHeader

#ifdef __cplusplus

}

#endif

#endif // TC_HEADER_Common_Volumes

/*

Derived from source code of TrueCrypt 7.1a, which is

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

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

and all other portions of this file are Copyright (c) 2013-2017 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

code distribution packages.

*/

#include "Tcdefs.h"

#include "Wipe.h"

// Fill buffer with wipe patterns defined in "National Industrial Security Program Operating Manual", US DoD 5220.22-M.

// Return: FALSE = buffer must be filled with random data

static BOOL Wipe3Dod5220 (int pass, uint8 *buffer, size_t size)

{

uint8 wipeChar;

switch (pass)

{

case 1:

wipeChar = 0;

break;

case 2:

wipeChar = 0xff;

break;

default:

return FALSE;

}

memset (buffer, wipeChar, size);

return TRUE;

}

static BOOL Wipe7Dod5220 (int pass, uint8 randChars[TC_WIPE_RAND_CHAR_COUNT], uint8 *buffer, size_t size)

{

uint8 wipeChar;

int GetWipePassCount (WipeAlgorithmId algorithm)

{

switch (algorithm)

{

case TC_WIPE_1_RAND:

return 1;

case TC_WIPE_3_DOD_5220:

return 3;

case TC_WIPE_7_DOD_5220:

return 7;

case TC_WIPE_35_GUTMANN:

return 35;

case TC_WIPE_256:

return 256;

}

return -1; // Prevent compiler warnings

}

BOOL WipeBuffer (WipeAlgorithmId algorithm, uint8 randChars[TC_WIPE_RAND_CHAR_COUNT], int pass, uint8 *buffer, size_t size)

{

switch (algorithm)

{

case TC_WIPE_1_RAND:

case TC_WIPE_256:

case TC_WIPE_3_DOD_5220:

return Wipe3Dod5220 (pass, buffer, size);

case TC_WIPE_7_DOD_5220:

return Wipe7Dod5220 (pass, randChars, buffer, size);

case TC_WIPE_35_GUTMANN:

return Wipe35Gutmann (pass, buffer, size);

/* we will never reach here because all calls to WipeBuffer are preceeded

* by a call to GetWipePassCount that already checks the same algorithm

* parameters and in case of unsupported value an error is returned before

* calling WipeBuffer

*/

/*

default:

TC_THROW_FATAL_EXCEPTION;*/

}

return FALSE; // Prevent compiler warnings

}

/*

* Support for SHA-256 x86 instrinsic

* Based on public domain code by Sean Gulley

* (https://github.com/mitls/hacl-star/tree/master/experimental/hash)

*

* Botan is released under the Simplified BSD License (see license.txt)

*/

/* November 10th 2024: Modified for VeraCrypt */

#include "Sha2.h"

#include "Common/Endian.h"

#include "cpu.h"

#include "misc.h"

#if defined(_UEFI) || defined(CRYPTOPP_DISABLE_ASM)

#define NO_OPTIMIZED_VERSIONS

#endif

#ifndef NO_OPTIMIZED_VERSIONS

#if CRYPTOPP_SHANI_AVAILABLE

//

void sha256_intel(void *mp, uint_32t state[8], uint_64t num_blks)

{

// Constants table - align for better performance

CRYPTOPP_ALIGN_DATA(64)

static const uint_32t K[64] = {

0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5, 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,

0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3, 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,

0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC, 0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,

0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7, 0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,

0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13, 0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,

0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3, 0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,

0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5, 0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,

0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208, 0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2,

};

const __m128i* K_mm = (const __m128i*)K;

const __m128i* input_mm = (const __m128i*)mp;

// Create byte shuffle mask for big-endian to little-endian conversion

const __m128i MASK = _mm_set_epi64x(0x0c0d0e0f08090a0b, 0x0405060700010203);

// Load initial values

__m128i STATE0 = _mm_loadu_si128((__m128i*)&state[0]);

__m128i STATE1 = _mm_loadu_si128((__m128i*)&state[4]);

// Adjust byte ordering

STATE0 = _mm_shuffle_epi32(STATE0, 0xB1); // CDAB

STATE1 = _mm_shuffle_epi32(STATE1, 0x1B); // EFGH

uint64 len = sourceBytes;

if ((ctx->countLo = oldCountLo + (uint64)len) < oldCountLo)

ctx->countHi++; // carry from low to high

if (ctx->countHi < oldCountHi)

return;

else

{

uint64* dataBuf = ctx->data;

uint8* data = (uint8 *)dataBuf;

num = oldCountLo & 63;

if (num != 0) // process left over data

{

if (num+len >= 64)

{

memcpy(data+num, input, (size_t) (64-num));

HashMultipleBlocks(ctx, dataBuf, 64);

input += (64-num);

len -= (64-num);

// drop through and do the rest

}

else

{

memcpy(data+num, input, (size_t) len);

return;

}

}

// now process the input data in blocks of 64 bytes and save the leftovers to ctx->data

if (len && data != input)

memcpy(data, input, (size_t) len);

}

}

/**

* Get the hash value from the hashing state.

*

* This method uses the invariant: bufferBits < DIGESTBITS

*/

void WHIRLPOOL_finalize(WHIRLPOOL_CTX * const ctx,

unsigned char * result)

{

unsigned int num = ctx->countLo & 63;

uint64* dataBuf = ctx->data;

uint64* stateBuf = ctx->state;

uint8* data = (uint8 *)dataBuf;

data[num++] = 0x80;

if (num <= 32)

memset(data+num, 0, 32-num);

else

{

memset(data+num, 0, 64-num);

HashMultipleBlocks(ctx, dataBuf, 64);

memset(data, 0, 32);

}

#if BYTE_ORDER == LITTLE_ENDIAN

CorrectEndianness(dataBuf, dataBuf, 32);

#define XOR(v,w) ((v) ^ (w))

#define PLUS(v,w) (U32V((v) + (w)))

#define PLUSONE(v) (PLUS((v),1))

#define QUARTERROUND(a,b,c,d) \

x[a] = PLUS(x[a],x[b]); x[d] = ROTATE(XOR(x[d],x[a]),16); \

x[c] = PLUS(x[c],x[d]); x[b] = ROTATE(XOR(x[b],x[c]),12); \

x[a] = PLUS(x[a],x[b]); x[d] = ROTATE(XOR(x[d],x[a]), 8); \

x[c] = PLUS(x[c],x[d]); x[b] = ROTATE(XOR(x[b],x[c]), 7);

static void salsa20_wordtobyte(uint8 output[64],const uint32 input[16], unsigned int r)

{

uint32 x[16];

int i;

for (i = 0;i < 16;++i) x[i] = input[i];

for (i = r;i > 0;--i) {

QUARTERROUND( 0, 4, 8,12)

QUARTERROUND( 1, 5, 9,13)

QUARTERROUND( 2, 6,10,14)

QUARTERROUND( 3, 7,11,15)

QUARTERROUND( 0, 5,10,15)

QUARTERROUND( 1, 6,11,12)

QUARTERROUND( 2, 7, 8,13)

QUARTERROUND( 3, 4, 9,14)

}

for (i = 0;i < 16;++i) x[i] = PLUS(x[i],input[i]);

for (i = 0;i < 16;++i) U32TO8_LITTLE(output + 4 * i,x[i]);

}

void chacha_ECRYPT_encrypt_bytes(size_t bytes, uint32* x, const uint8* m, uint8* out, uint8* output, unsigned int r)

{

unsigned int i;

#include "chacha_u4.h"

#include "chacha_u1.h"

#ifndef _M_X64

#ifdef _MSC_VER

#if _MSC_VER < 1900

_mm_empty();

#endif

#endif

#endif

if (!bytes) return;

// bytes is now guaranteed to be between 1 and 63

salsa20_wordtobyte(output,x, r);

x[12] = PLUSONE(x[12]);

if (!x[12]) {

x[13] = PLUSONE(x[13]);

/* stopping at 2^70 bytes per nonce is user's responsibility */

}

for (i = 0;i < bytes;++i) out[i] = m[i] ^ output[i];

}

#endif

__cpuid((int *)output, input);

return 1;

}

#else

#ifndef CRYPTOPP_MS_STYLE_INLINE_ASSEMBLY

#if defined(__cplusplus)

extern "C" {

#endif

typedef void (*SigHandler)(int);

static jmp_buf s_jmpNoCPUID;

static void SigIllHandlerCPUID(int p)

{

longjmp(s_jmpNoCPUID, 1);

}

#if !defined (_UEFI) && ((defined(__AES__) && defined(__PCLMUL__)) || defined(__INTEL_COMPILER) || CRYPTOPP_BOOL_AESNI_INTRINSICS_AVAILABLE)

static jmp_buf s_jmpNoAESNI;

static void SigIllHandlerAESNI(int p)

{

longjmp(s_jmpNoAESNI, 1);

}

#endif

#if CRYPTOPP_BOOL_X64 == 0

static jmp_buf s_jmpNoSSE2;

static void SigIllHandlerSSE2(int p)

{

longjmp(s_jmpNoSSE2, 1);

}

#endif

#if defined(__cplusplus)

}

#endif

#endif

int CpuId(uint32 input, uint32 output[4])

{

#ifdef CRYPTOPP_MS_STYLE_INLINE_ASSEMBLY

#ifndef _UEFI

__try

{

#endif

__asm

{

mov eax, input

mov ecx, 0

cpuid

mov edi, output

mov [edi], eax

mov [edi+4], ebx

mov [edi+8], ecx

mov [edi+12], edx

// when Hyper-V is enabled on older versions of Windows Server (i.e. 2008 R2), the AES-NI capability

// gets masked out for all applications, even running on the host.

// We try to detect Hyper-V virtual CPU and perform a dummy AES-NI operation to check its real presence

uint32 cpuid[4] = {0};

char HvProductName[13];

CpuId(0x40000000, cpuid);

memcpy (HvProductName, &cpuid[1], 12);

HvProductName[12] = 0;

if (_stricmp(HvProductName, "Microsoft Hv") == 0)

{

#if defined (TC_WINDOWS_DRIVER) && !defined (_WIN64)

KFLOATING_SAVE floatingPointState;

if (NT_SUCCESS (KeSaveFloatingPointState (&floatingPointState)))

{

#endif

hasAesNI = TryAESNI ();

#if defined (TC_WINDOWS_DRIVER) && !defined (_WIN64)

KeRestoreFloatingPointState (&floatingPointState);

}

#endif

}

return hasAesNI;

}

#endif

#if defined(__SHA__) || defined(__INTEL_COMPILER) || CRYPTOPP_SHANI_AVAILABLE

#endif

static BOOL CheckSHA256Support() {

#if CRYPTOPP_BOOL_X64 && CRYPTOPP_SHANI_AVAILABLE

#if defined(_MSC_VER) // Windows with MSVC

int cpuInfo[4] = { 0 };

__cpuidex(cpuInfo, 7, 0);

return (cpuInfo[1] & (1 << 29)) != 0? TRUE : FALSE;

#elif defined(__GNUC__) || defined(__clang__) // Linux, FreeBSD, macOS with GCC/Clang

unsigned int eax = 0, ebx = 0, ecx = 0, edx = 0;

// First check if CPUID leaf 7 is supported

if (__get_cpuid(0, &eax, &ebx, &ecx, &edx)) {

if (eax >= 7) {

// Now check SHA-256 support in leaf 7, sub-leaf 0

if (__get_cpuid_count(7, 0, &eax, &ebx, &ecx, &edx)) {

return (ebx & (1 << 29)) != 0? TRUE : FALSE;

}

}

}

return FALSE;

#else

#error "Unsupported compiler"

#endif

#else

return FALSE;

#endif

}

wc_InitSha256(&sha256);

wc_Sha256Update(&sha256, source, sourceLen);

wc_Sha256Final(&sha256, result);

wc_Sha256Free(&sha256);

}

void sha512_begin(sha512_ctx* ctx)

{

wc_InitSha512(ctx);

}

void sha512_hash(const unsigned char * source, uint_64t sourceLen, sha512_ctx *ctx)

{

wc_Sha512Update(ctx, source, sourceLen);

}

void sha512_end(unsigned char * result, sha512_ctx* ctx)

{

wc_Sha512Final(ctx, result);

}

void sha512(unsigned char * result, const unsigned char* source, uint_64t sourceLen)

{

wc_Sha512 sha512;

wc_InitSha512(&sha512);

wc_Sha512Update(&sha512, source, sourceLen);

wc_Sha512Final(&sha512, result);

wc_Sha512Free(&sha512);

}

(void) iterations;

wc_HKDF(WC_SHA512, (uint8*)pwd, (word32)pwd_len, (uint8*)salt, (word32)salt_len, NULL, 0, (uint8*)dk, (word32)dklen);

}

(void) iterations;

wc_HKDF(WC_SHA256, (uint8*)pwd, (word32)pwd_len, (uint8*)salt, (word32)salt_len, NULL, 0, (uint8*)dk, (word32)dklen);

}

static void ComputeBootLoaderFingerprint(PDEVICE_OBJECT LowerDeviceObject, uint8* ioBuffer /* ioBuffer must be at least 512 bytes long */)

{

NTSTATUS status;

LARGE_INTEGER offset;

WHIRLPOOL_CTX whirlpool;

sha512_ctx sha2;

ULONG bytesToRead, remainingBytes, bootloaderTotalSize = TC_BOOT_LOADER_AREA_SIZE - TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE;

// clear fingerprint

burn (BootLoaderFingerprint, sizeof (BootLoaderFingerprint));

// compute Whirlpool+SHA512 fingerprint of bootloader including MBR

// we skip user configuration fields:

// TC_BOOT_SECTOR_PIM_VALUE_OFFSET = 400

// TC_BOOT_SECTOR_OUTER_VOLUME_BAK_HEADER_CRC_OFFSET = 402

// => TC_BOOT_SECTOR_OUTER_VOLUME_BAK_HEADER_CRC_SIZE = 4

// TC_BOOT_SECTOR_USER_MESSAGE_OFFSET = 406

// => TC_BOOT_SECTOR_USER_MESSAGE_MAX_LENGTH = 24

// TC_BOOT_SECTOR_USER_CONFIG_OFFSET = 438

//

// we have: TC_BOOT_SECTOR_USER_MESSAGE_OFFSET = TC_BOOT_SECTOR_OUTER_VOLUME_BAK_HEADER_CRC_OFFSET + TC_BOOT_SECTOR_OUTER_VOLUME_BAK_HEADER_CRC_SIZE

WHIRLPOOL_init (&whirlpool);

sha512_begin (&sha2);

// read the first 512 bytes

offset.QuadPart = 0;

status = TCReadDevice (LowerDeviceObject, ioBuffer, offset, TC_SECTOR_SIZE_BIOS);

if (NT_SUCCESS (status))

{

NTSTATUS saveStatus = STATUS_INVALID_PARAMETER;

XSTATE_SAVE SaveState;

if (IsCpuIntel() && HasSAVX())

saveStatus = KeSaveExtendedProcessorStateVC(XSTATE_MASK_GSSE, &SaveState);

#endif

WHIRLPOOL_add (ioBuffer, TC_BOOT_SECTOR_PIM_VALUE_OFFSET, &whirlpool);

WHIRLPOOL_add (ioBuffer + TC_BOOT_SECTOR_USER_MESSAGE_OFFSET + TC_BOOT_SECTOR_USER_MESSAGE_MAX_LENGTH, (TC_BOOT_SECTOR_USER_CONFIG_OFFSET - (TC_BOOT_SECTOR_USER_MESSAGE_OFFSET + TC_BOOT_SECTOR_USER_MESSAGE_MAX_LENGTH)), &whirlpool);

sha512_hash (ioBuffer, TC_BOOT_SECTOR_PIM_VALUE_OFFSET, &sha2);

sha512_hash (ioBuffer + TC_BOOT_SECTOR_USER_MESSAGE_OFFSET + TC_BOOT_SECTOR_USER_MESSAGE_MAX_LENGTH, (TC_BOOT_SECTOR_USER_CONFIG_OFFSET - (TC_BOOT_SECTOR_USER_MESSAGE_OFFSET + TC_BOOT_SECTOR_USER_MESSAGE_MAX_LENGTH)), &sha2);

// we has the reste of the bootloader, 512 bytes at a time

offset.QuadPart = TC_SECTOR_SIZE_BIOS;

remainingBytes = bootloaderTotalSize - TC_SECTOR_SIZE_BIOS;

while (NT_SUCCESS (status) && (remainingBytes > 0))

{

bytesToRead = (remainingBytes >= TC_SECTOR_SIZE_BIOS)? TC_SECTOR_SIZE_BIOS : remainingBytes;

status = TCReadDevice (LowerDeviceObject, ioBuffer, offset, bytesToRead);

if (NT_SUCCESS (status))

{

remainingBytes -= bytesToRead;

offset.QuadPart += bytesToRead;

WHIRLPOOL_add (ioBuffer, bytesToRead, &whirlpool);

sha512_hash (ioBuffer, bytesToRead, &sha2);

}

else

{

Dump ("TCReadDevice error %x during ComputeBootLoaderFingerprint call\n", status);

break;

}

}

if (NT_SUCCESS (status))

{

WHIRLPOOL_finalize (&whirlpool, BootLoaderFingerprint);

sha512_end (&BootLoaderFingerprint [WHIRLPOOL_DIGESTSIZE], &sha2);

}

KeRestoreExtendedProcessorStateVC(&SaveState);

#endif

}

else

{

Dump ("TCReadDevice error %x during ComputeBootLoaderFingerprint call\n", status);

}

}

static NTSTATUS MountDrive (DriveFilterExtension *Extension, Password *password, uint32 *headerSaltCrc32)

{

BOOL hiddenVolume = (BootArgs.HiddenSystemPartitionStart != 0);

int64 hiddenHeaderOffset = BootArgs.HiddenSystemPartitionStart + TC_HIDDEN_VOLUME_HEADER_OFFSET;

NTSTATUS status;

LARGE_INTEGER offset;

int pkcs5_prf = 0, pim = 0;

PARTITION_INFORMATION_EX pi;

BOOL bIsGPT = FALSE;

Dump ("MountDrive pdo=%p\n", Extension->Pdo);

ASSERT (KeGetCurrentIrql() == PASSIVE_LEVEL);

// Check disk MBR id and GPT ID if BootSecRegion is available to detect boot drive

if (BootSecRegionData != NULL && BootSecRegionSize >= 1024) {

uint8 mbr[TC_SECTOR_SIZE_BIOS];

DCS_DISK_ENTRY_LIST* DeList = (DCS_DISK_ENTRY_LIST*)(BootSecRegionData + 512);

offset.QuadPart = 0;

status = TCReadDevice (Extension->LowerDeviceObject, mbr, offset, TC_SECTOR_SIZE_BIOS);

if (NT_SUCCESS (status) && DeList->DE[DE_IDX_DISKID].DiskId.MbrID != *(uint32 *) (mbr + 0x1b8))

return STATUS_UNSUCCESSFUL;

offset.QuadPart = 512;

status = TCReadDevice (Extension->LowerDeviceObject, mbr, offset, TC_SECTOR_SIZE_BIOS);

if (NT_SUCCESS (status) && memcmp(&DeList->DE[DE_IDX_DISKID].DiskId.GptID, mbr + 0x38, sizeof(DCS_GUID)) != 0)

return STATUS_UNSUCCESSFUL;

header = TCalloc (TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE);

if (!header)

return STATUS_INSUFFICIENT_RESOURCES;

// Copy header from SecRegion instead of read from disk

memcpy(header, BootSecRegionData, 512);

// Set SecRegion data for the disk (sectors to substitute to hide GPT table)

Extension->Queue.SecRegionData = BootSecRegionData;

{

Extension->SystemStorageDeviceNumber = storageDeviceNumber.DeviceNumber;

Extension->SystemStorageDeviceNumberValid = TRUE;

}

}

status = SendDeviceIoControlRequest (Extension->LowerDeviceObject, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, &BootDriveLength, sizeof (BootDriveLength));

if (!NT_SUCCESS (status))

{

Dump ("Failed to get drive length - error %x\n", status);

BootDriveLength.QuadPart = 0;

Extension->Queue.MaxReadAheadOffset.QuadPart = 0;

}

else

Extension->Queue.MaxReadAheadOffset = BootDriveLength;

/* encrypt keys */

#ifdef _WIN64

if (IsRamEncryptionEnabled())

{

VcProtectKeys (Extension->HeaderCryptoInfo, VcGetEncryptionID (Extension->HeaderCryptoInfo));

VcProtectKeys (Extension->Queue.CryptoInfo, VcGetEncryptionID (Extension->Queue.CryptoInfo));

}

#endif

status = EncryptedIoQueueStart (&Extension->Queue);

if (!NT_SUCCESS (status))

TC_BUG_CHECK (status);

{

}

// Hidden system hibernation is not supported if an extra boot partition is present as the system is not allowed to update the boot partition

if (IsHiddenSystemRunning() && (BootArgs.Flags & TC_BOOT_ARGS_FLAG_EXTRA_BOOT_PARTITION))

{

CrashDumpEnabled = FALSE;

HibernationEnabled = FALSE;

}

}

else

{

Dump ("Header not decrypted\n");

crypto_close (Extension->HeaderCryptoInfo);

Extension->HeaderCryptoInfo = NULL;

status = STATUS_UNSUCCESSFUL;

}

ret:

TCfree (header);

return status;

}

static NTSTATUS SaveDriveVolumeHeader (DriveFilterExtension *Extension)

{

NTSTATUS status = STATUS_SUCCESS;

LARGE_INTEGER offset;

uint8 *header;

header = TCalloc (TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE);

&& IsVolumeDevice (filterExtension->LowerDeviceObject))

{

Dump ("Drive and volume merged pdo=%p", filterExtension->Pdo);

filterExtension->IsVolumeFilterDevice = TRUE;

filterExtension->IsDriveFilterDevice = FALSE;

}

else

{

NTSTATUS status = KeWaitForMutexObject (&MountMutex, Executive, KernelMode, FALSE, NULL);

if (!NT_SUCCESS (status))

TC_BUG_CHECK (status);

if (!BootDriveFound)

{

Password bootPass = {0};

bootPass.Length = BootArgs.BootPassword.Length;

memcpy (bootPass.Text, BootArgs.BootPassword.Text, BootArgs.BootPassword.Length);

MountDrive (filterExtension, &bootPass, &BootArgs.HeaderSaltCrc32);

burn (&bootPass, sizeof (bootPass));

}

KeReleaseMutex (&MountMutex, FALSE);

}

}

}

static VOID MountDriveWorkItemRoutine (PDEVICE_OBJECT deviceObject, DriveFilterExtension *filterExtension)

{

CheckDeviceTypeAndMount (filterExtension);

KeSetEvent (&filterExtension->MountWorkItemCompletedEvent, IO_NO_INCREMENT, FALSE);

}

static NTSTATUS OnStartDeviceCompleted (PDEVICE_OBJECT filterDeviceObject, PIRP Irp, DriveFilterExtension *Extension)

{

if (Irp->PendingReturned)

IoMarkIrpPending (Irp);

if (Extension->LowerDeviceObject->Characteristics & FILE_REMOVABLE_MEDIA)

filterDeviceObject->Characteristics |= FILE_REMOVABLE_MEDIA;

if (KeGetCurrentIrql() == PASSIVE_LEVEL)

{

CheckDeviceTypeAndMount (Extension);

}

else

{

PIO_WORKITEM workItem = IoAllocateWorkItem (filterDeviceObject);

if (!workItem)

{

IoReleaseRemoveLock (&Extension->Queue.RemoveLock, Irp);

return STATUS_INSUFFICIENT_RESOURCES;

}

KeInitializeEvent (&Extension->MountWorkItemCompletedEvent, SynchronizationEvent, FALSE);

IoQueueWorkItem (workItem, MountDriveWorkItemRoutine, DelayedWorkQueue, Extension);

KeWaitForSingleObject (&Extension->MountWorkItemCompletedEvent, Executive, KernelMode, FALSE, NULL);

IoReleaseRemoveLockAndWait (&Extension->Queue.RemoveLock, Irp);

status = PassIrp (Extension->LowerDeviceObject, Irp);

IoDetachDevice (Extension->LowerDeviceObject);

if (Extension->DriveMounted)

DismountDrive (Extension, TRUE);

if (Extension->BootDrive)

{

BootDriveFound = FALSE;

BootDriveFilterExtension = NULL;

}

IoDeleteDevice (DeviceObject);

return status;

default:

status = PassIrp (Extension->LowerDeviceObject, Irp);

IoReleaseRemoveLock (&Extension->Queue.RemoveLock, Irp);

}

return status;

}

static NTSTATUS DispatchPower (PDEVICE_OBJECT DeviceObject, PIRP Irp, DriveFilterExtension *Extension, PIO_STACK_LOCATION irpSp)

{

NTSTATUS status;

Dump ("IRP_MJ_POWER minor=%d type=%d shutdown=%d\n", (int) irpSp->MinorFunction, (int) irpSp->Parameters.Power.Type, (int) irpSp->Parameters.Power.ShutdownType);

if (SetupInProgress

&& irpSp->MinorFunction == IRP_MN_SET_POWER

&& irpSp->Parameters.Power.ShutdownType == PowerActionHibernate)

{

while (SendDeviceIoControlRequest (RootDeviceObject, TC_IOCTL_ABORT_BOOT_ENCRYPTION_SETUP, NULL, 0, NULL, 0) == STATUS_INSUFFICIENT_RESOURCES);

}

// Dismount the system drive on shutdown on Windows 7 and later

if (DriverShuttingDown

&& EraseKeysOnShutdown

&& IsOSAtLeast (WIN_7)

&& Extension->BootDrive

&& Extension->DriveMounted

&& irpSp->MinorFunction == IRP_MN_SET_POWER

&& irpSp->Parameters.Power.Type == DevicePowerState)

{

DismountDrive (Extension, TRUE);

#ifdef _WIN64

ClearSecurityParameters ();

#endif

}

PoStartNextPowerIrp (Irp);

status = IoAcquireRemoveLock (&Extension->Queue.RemoveLock, Irp);

if (!NT_SUCCESS (status))

return TCCompleteIrp (Irp, status, 0);

IoSkipCurrentIrpStackLocation (Irp);

status = PoCallDriver (Extension->LowerDeviceObject, Irp);

IoReleaseRemoveLock (&Extension->Queue.RemoveLock, Irp);

return status;

}

static NTSTATUS DispatchControl (PDEVICE_OBJECT DeviceObject, PIRP Irp, DriveFilterExtension *Extension, PIO_STACK_LOCATION irpSp)

{

BOOL bBlockTrim = BlockSystemTrimCommand || IsHiddenSystemRunning();

NTSTATUS status = IoAcquireRemoveLock (&Extension->Queue.RemoveLock, Irp);

if (!NT_SUCCESS (status))

return TCCompleteIrp (Irp, status, 0);

switch (irpSp->Parameters.DeviceIoControl.IoControlCode)

{

case IOCTL_STORAGE_MANAGE_DATA_SET_ATTRIBUTES:

Dump ("DriverFilter-DispatchControl: IOCTL_STORAGE_MANAGE_DATA_SET_ATTRIBUTES\n");

if (bBlockTrim)

{

DWORD inputLength = irpSp->Parameters.DeviceIoControl.InputBufferLength;

if (inputLength >= sizeof (DEVICE_MANAGE_DATA_SET_ATTRIBUTES))

{

PDEVICE_MANAGE_DATA_SET_ATTRIBUTES pInputAttrs = (PDEVICE_MANAGE_DATA_SET_ATTRIBUTES) Irp->AssociatedIrp.SystemBuffer;

DEVICE_DATA_MANAGEMENT_SET_ACTION action = pInputAttrs->Action;

if (action == DeviceDsmAction_Trim)

{

Dump ("DriverFilter-DispatchControl: IOCTL_STORAGE_MANAGE_DATA_SET_ATTRIBUTES - DeviceDsmAction_Trim.\n");

if (bBlockTrim)

{

Dump ("DriverFilter-DispatchControl:: TRIM command blocked.\n");

IoReleaseRemoveLock (&Extension->Queue.RemoveLock, Irp);

return TCCompleteDiskIrp (Irp, STATUS_SUCCESS, 0);

}

}

}

}

break;

case IOCTL_DISK_GROW_PARTITION:

Dump ("DriverFilter-DispatchControl: IOCTL_DISK_GROW_PARTITION blocked\n");

IoReleaseRemoveLock (&Extension->Queue.RemoveLock, Irp);

return TCCompleteDiskIrp (Irp, STATUS_UNSUCCESSFUL, 0);

break;

}

status = PassIrp (Extension->LowerDeviceObject, Irp);

IoReleaseRemoveLock (&Extension->Queue.RemoveLock, Irp);

return status;

}

{

status = EncryptedIoQueueAddIrp (&Extension->Queue, Irp);

if (status != STATUS_PENDING)

TCCompleteDiskIrp (Irp, status, 0);

return status;

}

break;

case IRP_MJ_PNP:

return DispatchPnp (DeviceObject, Irp, Extension, irpSp);

case IRP_MJ_POWER:

return DispatchPower (DeviceObject, Irp, Extension, irpSp);

case IRP_MJ_DEVICE_CONTROL:

return DispatchControl (DeviceObject, Irp, Extension, irpSp);

}

status = IoAcquireRemoveLock (&Extension->Queue.RemoveLock, Irp);

if (!NT_SUCCESS (status))

return TCCompleteIrp (Irp, status, 0);

status = PassIrp (Extension->LowerDeviceObject, Irp);

IoReleaseRemoveLock (&Extension->Queue.RemoveLock, Irp);

return status;

}

{

irp->IoStatus.Information = 0;

if (!IoIsSystemThread (PsGetCurrentThread()) && !UserCanAccessDriveDevice())

{

irp->IoStatus.Status = STATUS_ACCESS_DENIED;

}

else

{

int drive;

for (drive = MIN_MOUNTED_VOLUME_DRIVE_NUMBER; drive <= MAX_MOUNTED_VOLUME_DRIVE_NUMBER; ++drive)

{

PDEVICE_OBJECT device = GetVirtualVolumeDeviceObject (drive);

if (device)

{

PEXTENSION extension = (PEXTENSION) device->DeviceExtension;

if (extension)

{

InvalidateVolumeKeys (extension);

}

}

}

if (BootDriveFound && BootDriveFilterExtension && BootDriveFilterExtension->DriveMounted)

InvalidateDriveFilterKeys (BootDriveFilterExtension);

ClearSecurityParameters();

irp->IoStatus.Status = STATUS_SUCCESS;

}

}

{

LARGE_INTEGER offset;

ReopenBootVolumeHeaderRequest *request = (ReopenBootVolumeHeaderRequest *) irp->AssociatedIrp.SystemBuffer;

irp->IoStatus.Information = 0;

if (!IoIsSystemThread (PsGetCurrentThread()) && !UserCanAccessDriveDevice())

{

irp->IoStatus.Status = STATUS_ACCESS_DENIED;

return;

}

if (!ValidateIOBufferSize (irp, sizeof (ReopenBootVolumeHeaderRequest), ValidateInput))

return;

if (!BootDriveFound || !BootDriveFilterExtension || !BootDriveFilterExtension->DriveMounted || !BootDriveFilterExtension->HeaderCryptoInfo

|| request->VolumePassword.Length > MAX_LEGACY_PASSWORD

|| request->pkcs5_prf < 0

|| request->pkcs5_prf > LAST_PRF_ID

|| request->pim < 0

|| request->pim > 65535

)

{

irp->IoStatus.Status = STATUS_INVALID_PARAMETER;

goto wipe;

}

header = TCalloc (TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE);

if (!header)

{

irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;

goto wipe;

}

if (BootDriveFilterExtension->HiddenSystem)

offset.QuadPart = BootArgs.HiddenSystemPartitionStart + TC_HIDDEN_VOLUME_HEADER_OFFSET;

else

offset.QuadPart = TC_BOOT_VOLUME_HEADER_SECTOR_OFFSET;

irp->IoStatus.Status = TCReadDevice (BootDriveFilterExtension->LowerDeviceObject, header, offset, TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE);

if (!NT_SUCCESS (irp->IoStatus.Status))

{

Dump ("TCReadDevice error %x\n", irp->IoStatus.Status);

goto ret;

}

if (IsRamEncryptionEnabled())

{

VcUnprotectKeys (BootDriveFilterExtension->HeaderCryptoInfo, VcGetEncryptionID (BootDriveFilterExtension->HeaderCryptoInfo));

}

if (ReadVolumeHeader (!BootDriveFilterExtension->HiddenSystem, header, &request->VolumePassword, request->pkcs5_prf, request->pim, NULL, BootDriveFilterExtension->HeaderCryptoInfo) == 0)

{

Dump ("Header reopened\n");

if (IsRamEncryptionEnabled())

{

VcProtectKeys (BootDriveFilterExtension->HeaderCryptoInfo, VcGetEncryptionID(BootDriveFilterExtension->HeaderCryptoInfo));

}

ComputeBootLoaderFingerprint (BootDriveFilterExtension->LowerDeviceObject, header);

BootDriveFilterExtension->Queue.CryptoInfo->pkcs5 = BootDriveFilterExtension->HeaderCryptoInfo->pkcs5;

BootDriveFilterExtension->Queue.CryptoInfo->noIterations = BootDriveFilterExtension->HeaderCryptoInfo->noIterations;

BootDriveFilterExtension->Queue.CryptoInfo->volumePim = BootDriveFilterExtension->HeaderCryptoInfo->volumePim;

irp->IoStatus.Status = STATUS_SUCCESS;

}

else

{

crypto_close (BootDriveFilterExtension->HeaderCryptoInfo);

BootDriveFilterExtension->HeaderCryptoInfo = NULL;

Dump ("Header not reopened\n");

irp->IoStatus.Status = STATUS_INVALID_PARAMETER;

}

ret:

TCfree (header);

wipe:

burn (request, sizeof (*request));

}

// Legacy Windows XP/2003 hibernation dump filter

typedef NTSTATUS (*HiberDriverWriteFunctionA) (ULONG arg0, PLARGE_INTEGER writeOffset, PMDL dataMdl, PVOID arg3);

typedef NTSTATUS (*HiberDriverWriteFunctionB) (PLARGE_INTEGER writeOffset, PMDL dataMdl);

typedef struct

hiberDriverContext->PartitionStartOffset.QuadPart += BootDriveFilterExtension->Queue.RemappedAreaOffset;

}

return STATUS_SUCCESS;

}

static NTSTATUS HiberDriverEntryFilter0 (PVOID arg0, HiberDriverContext *hiberDriverContext)

{

return HiberDriverEntryFilter (0, arg0, hiberDriverContext);

}

static NTSTATUS HiberDriverEntryFilter1 (PVOID arg0, HiberDriverContext *hiberDriverContext)

{

return HiberDriverEntryFilter (1, arg0, hiberDriverContext);

}

static NTSTATUS HiberDriverEntryFilter2 (PVOID arg0, HiberDriverContext *hiberDriverContext)

{

return HiberDriverEntryFilter (2, arg0, hiberDriverContext);

}

static VOID LoadImageNotifyRoutine (PUNICODE_STRING fullImageName, HANDLE processId, PIMAGE_INFO imageInfo)

{

ModuleTableItem *moduleItem;

LIST_ENTRY *listEntry;

KIRQL origIrql;

if (!imageInfo || !imageInfo->SystemModeImage || !imageInfo->ImageBase || !TCDriverObject->DriverSection)

return;

moduleItem = *(ModuleTableItem **) TCDriverObject->DriverSection;

if (!moduleItem || !moduleItem->ModuleList.Flink)

return;

// Search loaded system modules for hibernation driver

origIrql = KeRaiseIrqlToDpcLevel();

for (listEntry = moduleItem->ModuleList.Flink->Blink;

listEntry && listEntry != TCDriverObject->DriverSection;

listEntry = listEntry->Flink)

{

moduleItem = CONTAINING_RECORD (listEntry, ModuleTableItem, ModuleList);

if (moduleItem && imageInfo->ImageBase == moduleItem->ModuleBaseAddress)

{

if (moduleItem->ModuleName.Buffer && moduleItem->ModuleName.Length >= 5 * sizeof (wchar_t))

{

if (memcmp (moduleItem->ModuleName.Buffer, L"hiber", 5 * sizeof (wchar_t)) == 0

|| memcmp (moduleItem->ModuleName.Buffer, L"Hiber", 5 * sizeof (wchar_t)) == 0

|| memcmp (moduleItem->ModuleName.Buffer, L"HIBER", 5 * sizeof (wchar_t)) == 0)

{

HiberDriverEntry filterEntry;

switch (LastHiberFilterNumber)

{

case 0: filterEntry = HiberDriverEntryFilter0; break;

case 1: filterEntry = HiberDriverEntryFilter1; break;

case 2: filterEntry = HiberDriverEntryFilter2; break;

default: TC_THROW_FATAL_EXCEPTION;

}

if (moduleItem->ModuleEntryAddress != filterEntry)

{

// Install filter

OriginalHiberDriverEntries[LastHiberFilterNumber] = moduleItem->ModuleEntryAddress;

moduleItem->ModuleEntryAddress = filterEntry;

if (++LastHiberFilterNumber > TC_MAX_HIBER_FILTER_COUNT - 1)

LastHiberFilterNumber = 0;

}

}

}

break;

}

}

KeLowerIrql (origIrql);

}

static VOID SetupThreadProc (PVOID threadArg)

{

DriveFilterExtension *Extension = BootDriveFilterExtension;

LARGE_INTEGER offset;

UINT64_STRUCT dataUnit;

ULONG setupBlockSize = TC_ENCRYPTION_SETUP_IO_BLOCK_SIZE;

BOOL headerUpdateRequired = FALSE;

int64 bytesWrittenSinceHeaderUpdate = 0;

uint8 *buffer = NULL;

uint8 *wipeBuffer = NULL;

uint8 wipeRandChars[TC_WIPE_RAND_CHAR_COUNT];

uint8 wipeRandCharsUpdate[TC_WIPE_RAND_CHAR_COUNT];

KIRQL irql;

NTSTATUS status;

// generate real random values for wipeRandChars and

// wipeRandCharsUpdate instead of relying on uninitialized stack memory

ChaCha20RngCtx rngCtx;

uint8 pbSeed[CHACHA20RNG_KEYSZ + CHACHA20RNG_IVSZ];

GetDriverRandomSeed (pbSeed, sizeof (pbSeed));

ChaCha20RngInit (&rngCtx, pbSeed, GetDriverRandomSeed, 0);

ChaCha20RngGetBytes (&rngCtx, wipeRandChars, TC_WIPE_RAND_CHAR_COUNT);

ChaCha20RngGetBytes (&rngCtx, wipeRandCharsUpdate, TC_WIPE_RAND_CHAR_COUNT);

burn (&rngCtx, sizeof (rngCtx));

FAST_ERASE64 (pbSeed, sizeof (pbSeed));

SetupResult = STATUS_UNSUCCESSFUL;

// Make sure volume header can be updated

if (Extension->HeaderCryptoInfo == NULL)

{

SetupResult = STATUS_INVALID_PARAMETER;

goto ret;

}

buffer = TCalloc (TC_ENCRYPTION_SETUP_IO_BLOCK_SIZE);

if (!buffer)

{

SetupResult = STATUS_INSUFFICIENT_RESOURCES;

goto ret;

}

if (SetupRequest.SetupMode == SetupEncryption && SetupRequest.WipeAlgorithm != TC_WIPE_NONE)

{

wipeBuffer = TCalloc (TC_ENCRYPTION_SETUP_IO_BLOCK_SIZE);

if (!wipeBuffer)

NTSTATUS status;

if (!UserCanAccessDriveDevice())

return STATUS_ACCESS_DENIED;

if (SetupInProgress || !BootDriveFound || !BootDriveFilterExtension

|| !BootDriveFilterExtension->DriveMounted

|| BootDriveFilterExtension->HiddenSystem

|| irpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof (BootEncryptionSetupRequest))

return STATUS_INVALID_PARAMETER;

if (EncryptionSetupThread)

AbortBootEncryptionSetup();

SetupRequest = *(BootEncryptionSetupRequest *) irp->AssociatedIrp.SystemBuffer;

EncryptionSetupThreadAbortRequested = FALSE;

KeInitializeSpinLock (&SetupStatusSpinLock);

SetupStatusEncryptedAreaEnd = BootDriveFilterExtension ? BootDriveFilterExtension->Queue.EncryptedAreaEnd : -1;

SetupInProgress = TRUE;

status = TCStartThread (SetupThreadProc, DeviceObject, &EncryptionSetupThread);

if (!NT_SUCCESS (status))

SetupInProgress = FALSE;

return status;

}

{

if (ValidateIOBufferSize (irp, sizeof (VOLUME_PROPERTIES_STRUCT), ValidateOutput))

{

DriveFilterExtension *Extension = BootDriveFilterExtension;

VOLUME_PROPERTIES_STRUCT *prop = (VOLUME_PROPERTIES_STRUCT *) irp->AssociatedIrp.SystemBuffer;

memset (prop, 0, sizeof (*prop));

if (!BootDriveFound || !Extension || !Extension->DriveMounted)

{

irp->IoStatus.Status = STATUS_INVALID_PARAMETER;

irp->IoStatus.Information = 0;

}

else

{

prop->hiddenVolume = Extension->Queue.CryptoInfo->hiddenVolume;

prop->diskLength = Extension->ConfiguredEncryptedAreaEnd + 1 - Extension->ConfiguredEncryptedAreaStart;

prop->ea = Extension->Queue.CryptoInfo->ea;

prop->mode = Extension->Queue.CryptoInfo->mode;

prop->pkcs5 = Extension->Queue.CryptoInfo->pkcs5;

prop->pkcs5Iterations = Extension->Queue.CryptoInfo->noIterations;

prop->volumePim = Extension->Queue.CryptoInfo->volumePim;

#if 0

prop->volumeCreationTime = Extension->Queue.CryptoInfo->volume_creation_time;

prop->headerCreationTime = Extension->Queue.CryptoInfo->header_creation_time;

#endif

prop->volFormatVersion = Extension->Queue.CryptoInfo->LegacyVolume ? TC_VOLUME_FORMAT_VERSION_PRE_6_0 : TC_VOLUME_FORMAT_VERSION;

prop->totalBytesRead = Extension->Queue.TotalBytesRead;

prop->totalBytesWritten = Extension->Queue.TotalBytesWritten;

irp->IoStatus.Information = sizeof (VOLUME_PROPERTIES_STRUCT);

irp->IoStatus.Status = STATUS_SUCCESS;

}

}

}

{

/* IMPORTANT: Do NOT add any potentially time-consuming operations to this function. */

if (ValidateIOBufferSize (irp, sizeof (BootEncryptionStatus), ValidateOutput))

{

DriveFilterExtension *Extension = BootDriveFilterExtension;

BootEncryptionStatus *bootEncStatus = (BootEncryptionStatus *) irp->AssociatedIrp.SystemBuffer;

memset (bootEncStatus, 0, sizeof (*bootEncStatus));

if (BootArgsValid)

bootEncStatus->BootLoaderVersion = BootArgs.BootLoaderVersion;

bootEncStatus->DeviceFilterActive = DeviceFilterActive;

bootEncStatus->SetupInProgress = SetupInProgress;

bootEncStatus->SetupMode = SetupRequest.SetupMode;

bootEncStatus->TransformWaitingForIdle = TransformWaitingForIdle;

if (!BootDriveFound || !Extension || !Extension->DriveMounted)

{

bootEncStatus->DriveEncrypted = FALSE;

bootEncStatus->DriveMounted = FALSE;

bootEncStatus->VolumeHeaderPresent = FALSE;

}

else

{

bootEncStatus->DriveMounted = Extension->DriveMounted;

bootEncStatus->VolumeHeaderPresent = Extension->VolumeHeaderPresent;

bootEncStatus->DriveEncrypted = Extension->Queue.EncryptedAreaStart != -1;

bootEncStatus->BootDriveLength = BootDriveLength;

bootEncStatus->ConfiguredEncryptedAreaEnd = Extension->ConfiguredEncryptedAreaEnd;

bootEncStatus->EncryptedAreaStart = Extension->Queue.EncryptedAreaStart;

bootEncStatus->MasterKeyVulnerable = Extension->HeaderCryptoInfo->bVulnerableMasterKey;

if (SetupInProgress)

{

KIRQL irql;

KeAcquireSpinLock (&SetupStatusSpinLock, &irql);

bootEncStatus->EncryptedAreaEnd = SetupStatusEncryptedAreaEnd;

KeReleaseSpinLock (&SetupStatusSpinLock, irql);

}

else

bootEncStatus->EncryptedAreaEnd = Extension->Queue.EncryptedAreaEnd;

bootEncStatus->VolumeHeaderSaltCrc32 = Extension->VolumeHeaderSaltCrc32;

bootEncStatus->HibernationPreventionCount = HibernationPreventionCount;

bootEncStatus->HiddenSysLeakProtectionCount = HiddenSysLeakProtectionCount;

bootEncStatus->HiddenSystem = Extension->HiddenSystem;

if (Extension->HiddenSystem)

bootEncStatus->HiddenSystemPartitionStart = BootArgs.HiddenSystemPartitionStart;

}

irp->IoStatus.Information = sizeof (BootEncryptionStatus);

irp->IoStatus.Status = STATUS_SUCCESS;

}

}

{

if (ValidateIOBufferSize (irp, sizeof (uint16), ValidateOutput))

{

if (BootArgsValid)

{

*(uint16 *) irp->AssociatedIrp.SystemBuffer = BootArgs.BootLoaderVersion;

irp->IoStatus.Information = sizeof (uint16);

irp->IoStatus.Status = STATUS_SUCCESS;

}

else

{

irp->IoStatus.Status = STATUS_INVALID_PARAMETER;

irp->IoStatus.Information = 0;

}

}

}

{

if (ValidateIOBufferSize (irp, sizeof (BootLoaderFingerprintRequest), ValidateOutput))

{

irp->IoStatus.Information = 0;

if (BootArgsValid && BootDriveFound && BootDriveFilterExtension && BootDriveFilterExtension->DriveMounted && BootDriveFilterExtension->HeaderCryptoInfo)

{

BootLoaderFingerprintRequest *bootLoaderFingerprint = (BootLoaderFingerprintRequest *) irp->AssociatedIrp.SystemBuffer;

/* compute the fingerprint again and check if it is the same as the one retrieved during boot */

if (!header)

{

irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;

}

else

{

memcpy (bootLoaderFingerprint->Fingerprint, BootLoaderFingerprint, sizeof (BootLoaderFingerprint));

ComputeBootLoaderFingerprint (BootDriveFilterExtension->LowerDeviceObject, header);

burn (header, TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE);

TCfree (header);

if (0 == memcmp (bootLoaderFingerprint->Fingerprint, BootLoaderFingerprint, sizeof (BootLoaderFingerprint)))

{

irp->IoStatus.Information = sizeof (BootLoaderFingerprintRequest);

irp->IoStatus.Status = STATUS_SUCCESS;

}

else

{

/* fingerprint mismatch.*/

irp->IoStatus.Status = STATUS_INVALID_IMAGE_HASH;

}

}

}

else

{

irp->IoStatus.Status = STATUS_INVALID_PARAMETER;

}

}

}

{

if (ValidateIOBufferSize (irp, sizeof (GetBootEncryptionAlgorithmNameRequest), ValidateOutput))

{

if (BootDriveFilterExtension && BootDriveFilterExtension->DriveMounted)

{

wchar_t BootEncryptionAlgorithmNameW[256];

wchar_t BootPrfAlgorithmNameW[256];

GetBootEncryptionAlgorithmNameRequest *request = (GetBootEncryptionAlgorithmNameRequest *) irp->AssociatedIrp.SystemBuffer;

EAGetName (BootEncryptionAlgorithmNameW, 256, BootDriveFilterExtension->Queue.CryptoInfo->ea, 0);

HashGetName2 (BootPrfAlgorithmNameW, 256, BootDriveFilterExtension->Queue.CryptoInfo->pkcs5);

RtlStringCbPrintfA (request->BootEncryptionAlgorithmName, sizeof (request->BootEncryptionAlgorithmName), "%S", BootEncryptionAlgorithmNameW);

RtlStringCbPrintfA (request->BootPrfAlgorithmName, sizeof (request->BootPrfAlgorithmName), "%S", BootPrfAlgorithmNameW);

irp->IoStatus.Information = sizeof (GetBootEncryptionAlgorithmNameRequest);

irp->IoStatus.Status = STATUS_SUCCESS;

}

else

{

irp->IoStatus.Status = STATUS_INVALID_PARAMETER;

irp->IoStatus.Information = 0;

}

}

}

NTSTATUS GetSetupResult()

{

return SetupResult;

}

{

return BootDriveFilterExtension;

}

CRYPTO_INFO *GetSystemDriveCryptoInfo ()

{

return BootDriveFilterExtension->Queue.CryptoInfo;

}

NTSTATUS AbortBootEncryptionSetup ()

{

if (!IoIsSystemThread (PsGetCurrentThread()) && !UserCanAccessDriveDevice())

return STATUS_ACCESS_DENIED;

if (EncryptionSetupThread)

{

EncryptionSetupThreadAbortRequested = TRUE;

TCStopThread (EncryptionSetupThread, NULL);

EncryptionSetupThread = NULL;

}

return STATUS_SUCCESS;

}

static VOID DecoySystemWipeThreadProc (PVOID threadArg)

{

DriveFilterExtension *Extension = BootDriveFilterExtension;

LARGE_INTEGER offset;

UINT64_STRUCT dataUnit;

ULONG wipeBlockSize = TC_ENCRYPTION_SETUP_IO_BLOCK_SIZE;

CRYPTO_INFO *wipeCryptoInfo = NULL;

uint8 *wipeBuffer = NULL;

uint8 *wipeRandBuffer = NULL;

uint8 wipeRandChars[TC_WIPE_RAND_CHAR_COUNT];

int wipePass, wipePassCount;

int ea = Extension->Queue.CryptoInfo->ea;

KIRQL irql;

NTSTATUS status;

DecoySystemWipeResult = STATUS_UNSUCCESSFUL;

wipeBuffer = TCalloc (TC_ENCRYPTION_SETUP_IO_BLOCK_SIZE);

if (!wipeBuffer)

{

DecoySystemWipeResult = STATUS_INSUFFICIENT_RESOURCES;

goto ret;

}

wipeRandBuffer = TCalloc (TC_ENCRYPTION_SETUP_IO_BLOCK_SIZE);

if (!wipeRandBuffer)

{

DecoySystemWipeResult = STATUS_INSUFFICIENT_RESOURCES;

goto ret;

return STATUS_SUCCESS;

if (DecoySystemWipeThread)

AbortDecoySystemWipe();

request = (WipeDecoySystemRequest *) irp->AssociatedIrp.SystemBuffer;

WipeDecoyRequest = *request;

burn (request->WipeKey, sizeof (request->WipeKey));

DecoySystemWipeThreadAbortRequested = FALSE;

KeInitializeSpinLock (&DecoySystemWipeStatusSpinLock);

DecoySystemWipedAreaEnd = BootDriveFilterExtension->ConfiguredEncryptedAreaStart;

DecoySystemWipeInProgress = TRUE;

status = TCStartThread (DecoySystemWipeThreadProc, DeviceObject, &DecoySystemWipeThread);

if (!NT_SUCCESS (status))

DecoySystemWipeInProgress = FALSE;

return status;

}

BOOL IsDecoySystemWipeInProgress()

{

return DecoySystemWipeInProgress;

}

{

if (ValidateIOBufferSize (irp, sizeof (DecoySystemWipeStatus), ValidateOutput))

{

DecoySystemWipeStatus *wipeStatus = (DecoySystemWipeStatus *) irp->AssociatedIrp.SystemBuffer;

if (!IsHiddenSystemRunning())

{

irp->IoStatus.Status = STATUS_INVALID_PARAMETER;

irp->IoStatus.Information = 0;

}

else

{

wipeStatus->WipeInProgress = DecoySystemWipeInProgress;

wipeStatus->WipeAlgorithm = WipeDecoyRequest.WipeAlgorithm;

if (DecoySystemWipeInProgress)

{

KIRQL irql;

KeAcquireSpinLock (&DecoySystemWipeStatusSpinLock, &irql);

wipeStatus->WipedAreaEnd = DecoySystemWipedAreaEnd;

KeReleaseSpinLock (&DecoySystemWipeStatusSpinLock, irql);

}

else

wipeStatus->WipedAreaEnd = DecoySystemWipedAreaEnd;

irp->IoStatus.Information = sizeof (DecoySystemWipeStatus);

irp->IoStatus.Status = STATUS_SUCCESS;

}

}

}

ULONG SystemStorageDeviceNumber;

BOOL SystemStorageDeviceNumberValid;

int64 ConfiguredEncryptedAreaStart;

int64 ConfiguredEncryptedAreaEnd;

uint32 VolumeHeaderSaltCrc32;

EncryptedIoQueue Queue;

BOOL BootDrive;

BOOL VolumeHeaderPresent;

BOOL DriveMounted;

KEVENT MountWorkItemCompletedEvent;

CRYPTO_INFO *HeaderCryptoInfo;

BOOL HiddenSystem;

} DriveFilterExtension;

#define TC_BOOT_DRIVE_FILTER_EXTENSION_MAGIC_NUMBER 0x5645524142455854

extern BOOL BootArgsValid;

extern BootArguments BootArgs;

extern PKTHREAD EncryptionSetupThread;

extern PKTHREAD DecoySystemWipeThread;

NTSTATUS AbortBootEncryptionSetup ();

NTSTATUS DriveFilterAddDevice (PDRIVER_OBJECT driverObject, PDEVICE_OBJECT pdo);

NTSTATUS DriveFilterDispatchIrp (PDEVICE_OBJECT DeviceObject, PIRP Irp);

NTSTATUS GetSetupResult ();

DriveFilterExtension *GetBootDriveFilterExtension ();

CRYPTO_INFO *GetSystemDriveCryptoInfo ();

BOOL IsBootDriveMounted ();

BOOL IsBootEncryptionSetupInProgress ();

BOOL IsHiddenSystemRunning ();

NTSTATUS LoadBootArguments (BOOL bIsEfi);

static NTSTATUS SaveDriveVolumeHeader (DriveFilterExtension *Extension);

NTSTATUS StartBootEncryptionSetup (PDEVICE_OBJECT DeviceObject, PIRP irp, PIO_STACK_LOCATION irpSp);

NTSTATUS StartDecoySystemWipe (PDEVICE_OBJECT DeviceObject, PIRP irp, PIO_STACK_LOCATION irpSp);

NTSTATUS AbortDecoySystemWipe ();

BOOL IsDecoySystemWipeInProgress();

NTSTATUS GetDecoySystemWipeResult();

uint64 GetBootDriveLength ();

NTSTATUS WriteBootDriveSector (PIRP irp, PIO_STACK_LOCATION irpSp);

#define TC_ENCRYPTION_SETUP_IO_BLOCK_SIZE (1536 * 1024)

#define TC_ENCRYPTION_SETUP_HEADER_UPDATE_THRESHOLD (64 * 1024 * 1024)

#define TC_HIBERNATION_WRITE_BUFFER_SIZE (128 * 1024)

#endif // TC_HEADER_DRIVER_DRIVE_FILTER

#ifdef _WIN64

highestAcceptableWriteBufferAddr.QuadPart = 0x7FFffffFFFFLL;

#else

highestAcceptableWriteBufferAddr.QuadPart = 0xffffFFFFLL;

#endif

WriteFilterBuffer = MmAllocateContiguousMemory (WriteFilterBufferSize, highestAcceptableWriteBufferAddr);

if (!WriteFilterBuffer)

{

status = STATUS_INSUFFICIENT_RESOURCES;

goto err;

}

filterInitData->DumpStart = DumpFilterStart;

filterInitData->DumpWrite = DumpFilterWrite;

filterInitData->DumpFinish = DumpFilterFinish;

filterInitData->DumpUnload = DumpFilterUnload;

Dump ("Dump filter loaded type=%d\n", filterExtension->DumpType);

return STATUS_SUCCESS;

err:

Dump ("DumpFilterEntry error %x\n", status);

return status;

}

static NTSTATUS DumpFilterStart (PFILTER_EXTENSION filterExtension)

{

Dump ("DumpFilterStart type=%d\n", filterExtension->DumpType);

if (BootDriveFilterExtension->MagicNumber != TC_BOOT_DRIVE_FILTER_EXTENSION_MAGIC_NUMBER)

TC_BUG_CHECK (STATUS_CRC_ERROR);

return BootDriveFilterExtension->DriveMounted ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;

}

static NTSTATUS DumpFilterWrite (PFILTER_EXTENSION filterExtension, PLARGE_INTEGER diskWriteOffset, PMDL writeMdl)

{

ULONG dataLength = MmGetMdlByteCount (writeMdl);

uint64 offset = DumpPartitionOffset.QuadPart + diskWriteOffset->QuadPart;

uint64 intersectStart;

uint32 intersectLength;

PVOID writeBuffer;

CSHORT origMdlFlags;

if (BootDriveFilterExtension->MagicNumber != TC_BOOT_DRIVE_FILTER_EXTENSION_MAGIC_NUMBER)

TC_BUG_CHECK (STATUS_CRC_ERROR);

if (BootDriveFilterExtension->Queue.EncryptedAreaEndUpdatePending) // Hibernation should always abort the setup thread

TC_BUG_CHECK (STATUS_INVALID_PARAMETER);

if (BootDriveFilterExtension->Queue.EncryptedAreaStart == -1 || BootDriveFilterExtension->Queue.EncryptedAreaEnd == -1)

return STATUS_SUCCESS;

if (dataLength > WriteFilterBufferSize)

TC_BUG_CHECK (STATUS_BUFFER_OVERFLOW); // Bug check is required as returning an error does not prevent data from being written to disk

if ((dataLength & (ENCRYPTION_DATA_UNIT_SIZE - 1)) != 0)

TC_BUG_CHECK (STATUS_INVALID_PARAMETER);

if ((offset & (ENCRYPTION_DATA_UNIT_SIZE - 1)) != 0)

TC_BUG_CHECK (STATUS_INVALID_PARAMETER);

if (!writeBuffer)

TC_BUG_CHECK (STATUS_INSUFFICIENT_RESOURCES);

memcpy (WriteFilterBuffer, writeBuffer, dataLength);

GetIntersection (offset,

dataLength,

BootDriveFilterExtension->Queue.EncryptedAreaStart,

BootDriveFilterExtension->Queue.EncryptedAreaEnd,

&intersectStart,

&intersectLength);

if (intersectLength > 0)

{

UINT64_STRUCT dataUnit;

dataUnit.Value = intersectStart / ENCRYPTION_DATA_UNIT_SIZE;

if (BootDriveFilterExtension->Queue.RemapEncryptedArea)

{

diskWriteOffset->QuadPart += BootDriveFilterExtension->Queue.RemappedAreaOffset;

dataUnit.Value += BootDriveFilterExtension->Queue.RemappedAreaDataUnitOffset;

}

EncryptDataUnitsCurrentThreadEx (WriteFilterBuffer + (intersectStart - offset),

&dataUnit,

intersectLength / ENCRYPTION_DATA_UNIT_SIZE,

BootDriveFilterExtension->Queue.CryptoInfo);

}

origMdlFlags = writeMdl->MdlFlags;

MmInitializeMdl (writeMdl, WriteFilterBuffer, dataLength);

MmBuildMdlForNonPagedPool (writeMdl);

// Instead of using MmGetSystemAddressForMdlSafe(), some buggy custom storage drivers may directly test MDL_MAPPED_TO_SYSTEM_VA flag,

// disregarding the fact that other MDL flags may be set by the system or a dump filter (e.g. MDL_SOURCE_IS_NONPAGED_POOL flag only).

// Therefore, to work around this issue, the original flags will be restored even if they do not match the new MDL.

// MS BitLocker also uses this hack/workaround (it should be safe to use until the MDL structure is changed).

writeMdl->MdlFlags = origMdlFlags;

return STATUS_SUCCESS;

}

static NTSTATUS DumpFilterFinish (PFILTER_EXTENSION filterExtension)

{

Dump ("DumpFilterFinish type=%d\n", filterExtension->DumpType);

return STATUS_SUCCESS;

}

static NTSTATUS DumpFilterUnload (PFILTER_EXTENSION filterExtension)

{

Dump ("DumpFilterUnload type=%d\n", filterExtension->DumpType);

if (WriteFilterBuffer)

{

memset (WriteFilterBuffer, 0, WriteFilterBufferSize);

MmFreeContiguousMemory (WriteFilterBuffer);

WriteFilterBuffer = NULL;

}

return STATUS_SUCCESS;

}

&& !item->Write

&& item->OriginalLength > 0

&& (item->OriginalLength & (ENCRYPTION_DATA_UNIT_SIZE - 1)) == 0

&& (item->OriginalOffset.QuadPart & (ENCRYPTION_DATA_UNIT_SIZE - 1)) != 0)

{

uint8 *buffer;

ULONG alignedLength;

LARGE_INTEGER alignedOffset;

hResult = ULongAdd(item->OriginalLength, ENCRYPTION_DATA_UNIT_SIZE, &alignedLength);

if (hResult != S_OK)

{

CompleteOriginalIrp (item, STATUS_INVALID_PARAMETER, 0);

continue;

}

alignedOffset.QuadPart = item->OriginalOffset.QuadPart & ~((LONGLONG) ENCRYPTION_DATA_UNIT_SIZE - 1);

buffer = TCalloc (alignedLength);

if (!buffer)

{

CompleteOriginalIrp (item, STATUS_INSUFFICIENT_RESOURCES, 0);

continue;

}

item->Status = TCReadDevice (queue->LowerDeviceObject, buffer, alignedOffset, alignedLength);

if (NT_SUCCESS (item->Status))

{

UINT64_STRUCT dataUnit;

if (!dataBuffer)

{

TCfree (buffer);

CompleteOriginalIrp (item, STATUS_INSUFFICIENT_RESOURCES, 0);

continue;

}

if (queue->EncryptedAreaStart != -1 && queue->EncryptedAreaEnd != -1)

{

GetIntersection (alignedOffset.QuadPart, alignedLength, queue->EncryptedAreaStart, queue->EncryptedAreaEnd, &intersectStart, &intersectLength);

if (intersectLength > 0)

{

dataUnit.Value = intersectStart / ENCRYPTION_DATA_UNIT_SIZE;

DecryptDataUnits (buffer + (intersectStart - alignedOffset.QuadPart), &dataUnit, intersectLength / ENCRYPTION_DATA_UNIT_SIZE, queue->CryptoInfo);

}

}

// Update subst sectors

if((queue->SecRegionData != NULL) && (queue->SecRegionSize > 512)) {

UpdateBuffer(buffer, queue->SecRegionData, alignedOffset.QuadPart, alignedLength, TRUE);

}

memcpy (dataBuffer, buffer + (item->OriginalOffset.LowPart & (ENCRYPTION_DATA_UNIT_SIZE - 1)), item->OriginalLength);

}

TCfree (buffer);

CompleteOriginalIrp (item, item->Status, NT_SUCCESS (item->Status) ? item->OriginalLength : 0);

continue;

}

// Validate offset and length

continue;

}

}

}

else if (item->Write

&& RegionsOverlap (item->OriginalOffset.QuadPart, item->OriginalOffset.QuadPart + item->OriginalLength - 1, TC_BOOT_VOLUME_HEADER_SECTOR_OFFSET, TC_BOOT_VOLUME_HEADER_SECTOR_OFFSET + TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE - 1))

{

// Prevent inappropriately designed software from damaging important data that may be out of sync with the backup on the Rescue Disk (such as the end of the encrypted area).

Dump ("Preventing write to the system encryption key data area\n");

CompleteOriginalIrp (item, STATUS_MEDIA_WRITE_PROTECTED, 0);

continue;

}

else if (item->Write && IsHiddenSystemRunning()

&& (RegionsOverlap (item->OriginalOffset.QuadPart, item->OriginalOffset.QuadPart + item->OriginalLength - 1, TC_SECTOR_SIZE_BIOS, TC_BOOT_LOADER_AREA_SECTOR_COUNT * TC_SECTOR_SIZE_BIOS - 1)

|| RegionsOverlap (item->OriginalOffset.QuadPart, item->OriginalOffset.QuadPart + item->OriginalLength - 1, GetBootDriveLength(), _I64_MAX)))

{

Dump ("Preventing write to boot loader or host protected area\n");

CompleteOriginalIrp (item, STATUS_MEDIA_WRITE_PROTECTED, 0);

continue;

}

else if (item->Write

&& (queue->SecRegionData != NULL) && (queue->SecRegionSize > 512)

&& UpdateBuffer (NULL, queue->SecRegionData, item->OriginalOffset.QuadPart, (uint32)(item->OriginalOffset.QuadPart + item->OriginalLength - 1), FALSE))

{

// Prevent inappropriately designed software from damaging important data

Dump ("Preventing write to the system GPT area\n");

CompleteOriginalIrp (item, STATUS_MEDIA_WRITE_PROTECTED, 0);

continue;

}

if (dataBuffer == NULL)

{

CompleteOriginalIrp (item, STATUS_INSUFFICIENT_RESOURCES, 0);

continue;

}

// Divide data block to fragments to enable efficient overlapping of encryption and IO operations

dataRemaining = item->OriginalLength;

fragmentOffset = item->OriginalOffset;

while (dataRemaining > 0)

{

ULONG queueFragmentSize = queue->FragmentSize;

BOOL isLastFragment = dataRemaining <= queueFragmentSize;

ULONG dataFragmentLength = isLastFragment ? dataRemaining : queueFragmentSize;

activeFragmentBuffer = (activeFragmentBuffer == queue->FragmentBufferA ? queue->FragmentBufferB : queue->FragmentBufferA);

InterlockedIncrement (&queue->IoThreadPendingRequestCount);

// Create IO request

request = GetPoolBuffer (queue, sizeof (EncryptedIoRequest));

if (!request)

{

CompleteOriginalIrp (item, STATUS_INSUFFICIENT_RESOURCES, 0);

break;

}

request->Item = item;

int LastUniqueVolumeId;

ULONG OsMajorVersion = 0;

ULONG OsMinorVersion;

BOOL DriverUnloadDisabled = FALSE;

BOOL PortableMode = FALSE;

BOOL VolumeClassFilterRegistered = FALSE;

BOOL CacheBootPassword = FALSE;

BOOL CacheBootPim = FALSE;

BOOL NonAdminSystemFavoritesAccessDisabled = FALSE;

BOOL BlockSystemTrimCommand = FALSE;

BOOL AllowWindowsDefrag = FALSE;

BOOL EraseKeysOnShutdown = TRUE; // by default, we erase encryption keys on system shutdown

static size_t EncryptionThreadPoolFreeCpuCountLimit = 0;

static BOOL SystemFavoriteVolumeDirty = FALSE;

static BOOL PagingFileCreationPrevented = FALSE;

static BOOL EnableExtendedIoctlSupport = FALSE;

static BOOL AllowTrimCommand = FALSE;

static BOOL RamEncryptionActivated = FALSE;

static KeSaveExtendedProcessorStateFn KeSaveExtendedProcessorStatePtr = NULL;

static KeRestoreExtendedProcessorStateFn KeRestoreExtendedProcessorStatePtr = NULL;

static ExGetFirmwareEnvironmentVariableFn ExGetFirmwareEnvironmentVariablePtr = NULL;

static KeQueryInterruptTimePreciseFn KeQueryInterruptTimePrecisePtr = NULL;

static KeAreAllApcsDisabledFn KeAreAllApcsDisabledPtr = NULL;

static KeSetSystemGroupAffinityThreadFn KeSetSystemGroupAffinityThreadPtr = NULL;

static KeQueryActiveGroupCountFn KeQueryActiveGroupCountPtr = NULL;

static KeQueryActiveProcessorCountExFn KeQueryActiveProcessorCountExPtr = NULL;

int EncryptionIoRequestCount = 0;

int EncryptionItemCount = 0;

int EncryptionFragmentSize = 0;

PDEVICE_OBJECT VirtualVolumeDeviceObjects[MAX_MOUNTED_VOLUME_DRIVE_NUMBER + 1];

BOOL AlignValue (ULONG ulValue, ULONG ulAlignment, ULONG *pulResult)

{

BOOL bRet = FALSE;

HRESULT hr;

if (ulAlignment == 0)

{

*pulResult = ulValue;

bRet = TRUE;

}

else

{

ulAlignment -= 1;

hr = ULongAdd (ulValue, ulAlignment, &ulValue);

if (S_OK == hr)

{

*pulResult = ulValue & (~ulAlignment);

bRet = TRUE;

}

}

return bRet;

}

BOOL IsUefiBoot ()

{

BOOL bStatus = FALSE;

NTSTATUS ntStatus = STATUS_NOT_IMPLEMENTED;

}

void GetDriverRandomSeed (unsigned char* pbRandSeed, size_t cbRandSeed)

{

LARGE_INTEGER iSeed, iSeed2;

uint8 digest[WHIRLPOOL_DIGESTSIZE];

WHIRLPOOL_CTX tctx;

size_t count;

#ifndef _WIN64

KFLOATING_SAVE floatingPointState;

NTSTATUS saveStatus = STATUS_INVALID_PARAMETER;

if (HasISSE())

saveStatus = KeSaveFloatingPointState (&floatingPointState);

#endif

while (cbRandSeed)

{

WHIRLPOOL_init (&tctx);

// we hash current content of digest buffer which is uninitialized the first time

WHIRLPOOL_add (digest, WHIRLPOOL_DIGESTSIZE, &tctx);

// we use various time information as source of entropy

KeQuerySystemTime( &iSeed );

WHIRLPOOL_add ((unsigned char *) &(iSeed.QuadPart), sizeof(iSeed.QuadPart), &tctx);

iSeed = KeQueryPerformanceCounter (&iSeed2);

WHIRLPOOL_add ((unsigned char *) &(iSeed.QuadPart), sizeof(iSeed.QuadPart), &tctx);

WHIRLPOOL_add ((unsigned char *) &(iSeed2.QuadPart), sizeof(iSeed2.QuadPart), &tctx);

if (KeQueryInterruptTimePrecisePtr)

{

WHIRLPOOL_add ((unsigned char *) &(iSeed.QuadPart), sizeof(iSeed.QuadPart), &tctx);

WHIRLPOOL_add ((unsigned char *) &(iSeed2.QuadPart), sizeof(iSeed2.QuadPart), &tctx);

}

else

{

iSeed.QuadPart = KeQueryInterruptTime ();

WHIRLPOOL_add ((unsigned char *) &(iSeed.QuadPart), sizeof(iSeed.QuadPart), &tctx);

}

/* use JitterEntropy library to get good quality random bytes based on CPU timing jitter */

if (0 == jent_entropy_init ())

{

struct rand_data *ec = jent_entropy_collector_alloc (1, 0);

if (ec)

{

ssize_t rndLen = jent_read_entropy (ec, (char*) digest, sizeof (digest));

if (rndLen > 0)

WHIRLPOOL_add (digest, (unsigned int) rndLen, &tctx);

jent_entropy_collector_free (ec);

}

}

// use RDSEED or RDRAND from CPU as source of entropy if enabled

if ( IsCpuRngEnabled() &&

( (HasRDSEED() && RDSEED_getBytes (digest, sizeof (digest)))

|| (HasRDRAND() && RDRAND_getBytes (digest, sizeof (digest)))

))

{

WHIRLPOOL_add (digest, sizeof(digest), &tctx);

}

WHIRLPOOL_finalize (&tctx, digest);

count = VC_MIN (cbRandSeed, sizeof (digest));

// copy digest value to seed buffer

memcpy (pbRandSeed, digest, count);

cbRandSeed -= count;

pbRandSeed += count;

}

#if !defined (_WIN64)

if (NT_SUCCESS (saveStatus))

KeRestoreFloatingPointState (&floatingPointState);

#endif

FAST_ERASE64 (digest, sizeof (digest));

FAST_ERASE64 (&iSeed.QuadPart, 8);

FAST_ERASE64 (&iSeed2.QuadPart, 8);

burn (&tctx, sizeof(tctx));

}

{

PKEY_VALUE_PARTIAL_INFORMATION startKeyValue;

LONG version;

int i;

// KeAreAllApcsDisabled is available starting from Windows Server 2003

if ((OsMajorVersion > 5) || (OsMajorVersion == 5 && OsMinorVersion >= 2))

{

UNICODE_STRING KeAreAllApcsDisabledFuncName;

RtlInitUnicodeString(&KeAreAllApcsDisabledFuncName, L"KeAreAllApcsDisabled");

}

// KeSaveExtendedProcessorState/KeRestoreExtendedProcessorState are available starting from Windows 7

// KeQueryActiveGroupCount/KeQueryActiveProcessorCountEx/KeSetSystemGroupAffinityThread are available starting from Windows 7

if ((OsMajorVersion > 6) || (OsMajorVersion == 6 && OsMinorVersion >= 1))

{

UNICODE_STRING saveFuncName, restoreFuncName, groupCountFuncName, procCountFuncName, setAffinityFuncName;

RtlInitUnicodeString(&saveFuncName, L"KeSaveExtendedProcessorState");

RtlInitUnicodeString(&restoreFuncName, L"KeRestoreExtendedProcessorState");

RtlInitUnicodeString(&groupCountFuncName, L"KeQueryActiveGroupCount");

RtlInitUnicodeString(&procCountFuncName, L"KeQueryActiveProcessorCountEx");

RtlInitUnicodeString(&setAffinityFuncName, L"KeSetSystemGroupAffinityThread");

}

// ExGetFirmwareEnvironmentVariable is available starting from Windows 8

if ((OsMajorVersion > 6) || (OsMajorVersion == 6 && OsMinorVersion >= 2))

{

UNICODE_STRING funcName;

RtlInitUnicodeString(&funcName, L"ExGetFirmwareEnvironmentVariable");

}

// KeQueryInterruptTimePrecise is available starting from Windows 8.1

if ((OsMajorVersion > 6) || (OsMajorVersion == 6 && OsMinorVersion >= 3))

{

UNICODE_STRING funcName;

RtlInitUnicodeString(&funcName, L"KeQueryInterruptTimePrecise");

}

// Load dump filter if the main driver is already loaded

TCDriverObject = DriverObject;

SelfTestsPassed = AutoTestAlgorithms();

// Enable device class filters and load boot arguments if the driver is set to start at system boot

{

{

if (!SelfTestsPassed)

{

// in case of system encryption, if self-tests fail, disable all extended CPU

// features and try again in order to workaround faulty configurations

SelfTestsPassed = AutoTestAlgorithms();

// BUG CHECK if the self-tests still fail

if (!SelfTestsPassed)

}

VolumeClassFilterRegistered = IsVolumeClassFilterRegistered();

DriverObject->DriverExtension->AddDevice = DriverAddDevice;

}

}

{

}

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

{

DriverObject->MajorFunction[i] = TCDispatchQueueIRP;

}

DriverObject->DriverUnload = TCUnloadDriver;

}

NTSTATUS DriverAddDevice (PDRIVER_OBJECT driverObject, PDEVICE_OBJECT pdo)

{

#if defined(DEBUG) || defined (DEBUG_TRACE)

char nameInfoBuffer[128];

POBJECT_NAME_INFORMATION nameInfo = (POBJECT_NAME_INFORMATION) nameInfoBuffer;

ULONG nameInfoSize;

Dump ("AddDevice pdo=%p type=%x name=%ws\n", pdo, pdo->DeviceType, NT_SUCCESS (ObQueryNameString (pdo, nameInfo, sizeof (nameInfoBuffer), &nameInfoSize)) ? nameInfo->Name.Buffer : L"?");

#endif

if (VolumeClassFilterRegistered && BootArgsValid && BootArgs.HiddenSystemPartitionStart != 0)

{

PWSTR interfaceLinks = NULL;

if (NT_SUCCESS (IoGetDeviceInterfaces (&GUID_DEVINTERFACE_VOLUME, pdo, DEVICE_INTERFACE_INCLUDE_NONACTIVE, &interfaceLinks)) && interfaceLinks)

{

if (interfaceLinks[0] != UNICODE_NULL)

{

Dump ("Volume pdo=%p interface=%ws\n", pdo, interfaceLinks);

ExFreePool (interfaceLinks);

return VolumeFilterAddDevice (driverObject, pdo);

}

ExFreePool (interfaceLinks);

}

}

return DriveFilterAddDevice (driverObject, pdo);

return STATUS_SUCCESS;

}

BOOL RootDeviceControlMutexAcquireNoWait ()

{

NTSTATUS status;

LARGE_INTEGER timeout;

timeout.QuadPart = 0;

status = KeWaitForMutexObject (&RootDeviceControlMutex, Executive, KernelMode, FALSE, &timeout);

return NT_SUCCESS (status) && status != STATUS_TIMEOUT;

}

void RootDeviceControlMutexRelease ()

{

KeReleaseMutex (&RootDeviceControlMutex, FALSE);

}

/*

IOCTL_STORAGE_GET_DEVICE_NUMBER 0x002D1080

IOCTL_STORAGE_GET_HOTPLUG_INFO 0x002D0C14

IOCTL_STORAGE_QUERY_PROPERTY 0x002D1400

*/

NTSTATUS ProcessVolumeDeviceControlIrp (PDEVICE_OBJECT DeviceObject, PEXTENSION Extension, PIRP Irp)

{

PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation (Irp);

switch (irpSp->Parameters.DeviceIoControl.IoControlCode)

{

case IOCTL_MOUNTDEV_QUERY_DEVICE_NAME:

Dump ("ProcessVolumeDeviceControlIrp (IOCTL_MOUNTDEV_QUERY_DEVICE_NAME)\n");

if (!ValidateIOBufferSize (Irp, sizeof (MOUNTDEV_NAME), ValidateOutput))

{

Irp->IoStatus.Information = sizeof (MOUNTDEV_NAME);

Irp->IoStatus.Status = STATUS_BUFFER_OVERFLOW;

}

else

{

ULONG outLength;

UNICODE_STRING ntUnicodeString;

WCHAR ntName[256];

PMOUNTDEV_NAME outputBuffer = (PMOUNTDEV_NAME) Irp->AssociatedIrp.SystemBuffer;

TCGetNTNameFromNumber (ntName, sizeof(ntName),Extension->nDosDriveNo);

RtlInitUnicodeString (&ntUnicodeString, ntName);

outputBuffer->NameLength = ntUnicodeString.Length;

outLength = ntUnicodeString.Length + sizeof(USHORT);

if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < outLength)

{

Irp->IoStatus.Information = sizeof (MOUNTDEV_NAME);

Irp->IoStatus.Status = STATUS_BUFFER_OVERFLOW;

break;

}

RtlCopyMemory ((PCHAR)outputBuffer->Name,ntUnicodeString.Buffer, ntUnicodeString.Length);

Irp->IoStatus.Status = STATUS_SUCCESS;

Irp->IoStatus.Information = outLength;

Dump ("name = %ls\n",ntName);

}

break;

case IOCTL_MOUNTDEV_QUERY_UNIQUE_ID:

Dump ("ProcessVolumeDeviceControlIrp (IOCTL_MOUNTDEV_QUERY_UNIQUE_ID)\n");

if (!ValidateIOBufferSize (Irp, sizeof (MOUNTDEV_UNIQUE_ID), ValidateOutput))

{

Irp->IoStatus.Information = sizeof (MOUNTDEV_UNIQUE_ID);

Irp->IoStatus.Status = STATUS_BUFFER_OVERFLOW;

}

else

{

ULONG outLength;

PMOUNTDEV_UNIQUE_ID outputBuffer = (PMOUNTDEV_UNIQUE_ID) Irp->AssociatedIrp.SystemBuffer;

RtlStringCbCopyA (volId, sizeof(volId),TC_UNIQUE_ID_PREFIX);

tmp[0] = 'A' + (UCHAR) Extension->nDosDriveNo;

RtlStringCbCatA (volId, sizeof(volId),tmp);

outputBuffer->UniqueIdLength = (USHORT) strlen (volId);

outLength = (ULONG) (strlen (volId) + sizeof (USHORT));

if (irpSp->Parameters.DeviceIoControl.OutputBufferLength < outLength)

{

Irp->IoStatus.Information = sizeof (MOUNTDEV_UNIQUE_ID);

Irp->IoStatus.Status = STATUS_BUFFER_OVERFLOW;

break;

}

RtlCopyMemory ((PCHAR)outputBuffer->UniqueId, volId, strlen (volId));

Irp->IoStatus.Status = STATUS_SUCCESS;

Irp->IoStatus.Information = outLength;

Dump ("id = %s\n",volId);

}

break;

case IOCTL_MOUNTDEV_QUERY_SUGGESTED_LINK_NAME:

Dump ("ProcessVolumeDeviceControlIrp (IOCTL_MOUNTDEV_QUERY_SUGGESTED_LINK_NAME)\n");

{

ULONG outLength;

UNICODE_STRING ntUnicodeString;

case IOCTL_DISK_GET_MEDIA_TYPES:

case IOCTL_DISK_GET_DRIVE_GEOMETRY:

case IOCTL_STORAGE_GET_MEDIA_TYPES:

case IOCTL_DISK_UPDATE_DRIVE_SIZE:

Dump ("ProcessVolumeDeviceControlIrp (IOCTL_DISK_GET_DRIVE_GEOMETRY)\n");

/* Return the drive geometry for the disk. Note that we

return values which were made up to suit the disk size. */

if (ValidateIOBufferSize (Irp, sizeof (DISK_GEOMETRY), ValidateOutput))

{

PDISK_GEOMETRY outputBuffer = (PDISK_GEOMETRY)

Irp->AssociatedIrp.SystemBuffer;

outputBuffer->MediaType = Extension->bRemovable ? RemovableMedia : FixedMedia;

outputBuffer->Cylinders.QuadPart = Extension->NumberOfCylinders;

outputBuffer->TracksPerCylinder = Extension->TracksPerCylinder;

outputBuffer->SectorsPerTrack = Extension->SectorsPerTrack;

outputBuffer->BytesPerSector = Extension->BytesPerSector;

Irp->IoStatus.Status = STATUS_SUCCESS;

Irp->IoStatus.Information = sizeof (DISK_GEOMETRY);

}

break;

case IOCTL_DISK_GET_DRIVE_GEOMETRY_EX:

Dump ("ProcessVolumeDeviceControlIrp (IOCTL_DISK_GET_DRIVE_GEOMETRY_EX)\n");

{

ULONG minOutputSize = IsOSAtLeast (WIN_SERVER_2003)? sizeof (DISK_GEOMETRY_EX) : sizeof (DISK_GEOMETRY) + sizeof (LARGE_INTEGER);

ULONG fullOutputSize = sizeof (DISK_GEOMETRY) + sizeof (LARGE_INTEGER) + sizeof (DISK_PARTITION_INFO) + sizeof (DISK_DETECTION_INFO);

if (ValidateIOBufferSize (Irp, minOutputSize, ValidateOutput))

{

BOOL bFullBuffer = (irpSp->Parameters.DeviceIoControl.OutputBufferLength >= fullOutputSize)? TRUE : FALSE;

PDISK_GEOMETRY_EX outputBuffer = (PDISK_GEOMETRY_EX) Irp->AssociatedIrp.SystemBuffer;

outputBuffer->Geometry.MediaType = Extension->bRemovable ? RemovableMedia : FixedMedia;

outputBuffer->Geometry.Cylinders.QuadPart = Extension->NumberOfCylinders;

outputBuffer->Geometry.TracksPerCylinder = Extension->TracksPerCylinder;

outputBuffer->Geometry.SectorsPerTrack = Extension->SectorsPerTrack;

outputBuffer->Geometry.BytesPerSector = Extension->BytesPerSector;

// Add 1MB to the disk size to emulate the geometry of a real MBR disk

outputBuffer->DiskSize.QuadPart = Extension->DiskLength + BYTES_PER_MB;

if (bFullBuffer)

{

PDISK_PARTITION_INFO pPartInfo = (PDISK_PARTITION_INFO)(((ULONG_PTR) outputBuffer) + sizeof (DISK_GEOMETRY) + sizeof (LARGE_INTEGER));

PDISK_DETECTION_INFO pDetectInfo = ((PDISK_DETECTION_INFO)((((ULONG_PTR) pPartInfo) + sizeof (DISK_PARTITION_INFO))));

pPartInfo->SizeOfPartitionInfo = sizeof (DISK_PARTITION_INFO);

pPartInfo->PartitionStyle = PARTITION_STYLE_MBR;

pPartInfo->Mbr.Signature = GetCrc32((unsigned char*) &(Extension->UniqueVolumeId), 4);

pDetectInfo->SizeOfDetectInfo = sizeof (DISK_DETECTION_INFO);

Irp->IoStatus.Information = fullOutputSize;

}

else

{

if (irpSp->Parameters.DeviceIoControl.OutputBufferLength >= sizeof (DISK_GEOMETRY_EX))

Irp->IoStatus.Information = sizeof (DISK_GEOMETRY_EX);

else

Irp->IoStatus.Information = minOutputSize;

outputBuffer->HiddenSectors = 0;

Irp->IoStatus.Status = STATUS_SUCCESS;

Irp->IoStatus.Information = sizeof (PARTITION_INFORMATION);

}

break;

case IOCTL_DISK_GET_PARTITION_INFO_EX:

Dump ("ProcessVolumeDeviceControlIrp (IOCTL_DISK_GET_PARTITION_INFO_EX)\n");

if (ValidateIOBufferSize (Irp, sizeof (PARTITION_INFORMATION_EX), ValidateOutput))

{

PPARTITION_INFORMATION_EX outputBuffer = (PPARTITION_INFORMATION_EX) Irp->AssociatedIrp.SystemBuffer;

outputBuffer->PartitionStyle = PARTITION_STYLE_MBR;

outputBuffer->RewritePartition = FALSE;

outputBuffer->StartingOffset.QuadPart = BYTES_PER_MB; // Set offset to 1MB to emulate the partition offset on a real MBR disk

outputBuffer->PartitionLength.QuadPart= Extension->DiskLength;

outputBuffer->PartitionNumber = 1;

outputBuffer->Mbr.PartitionType = Extension->PartitionType;

outputBuffer->Mbr.BootIndicator = FALSE;

outputBuffer->Mbr.RecognizedPartition = TRUE;

outputBuffer->Mbr.HiddenSectors = 0;

Irp->IoStatus.Status = STATUS_SUCCESS;

Irp->IoStatus.Information = sizeof (PARTITION_INFORMATION_EX);

}

break;

case IOCTL_DISK_GET_DRIVE_LAYOUT:

Dump ("ProcessVolumeDeviceControlIrp (IOCTL_DISK_GET_DRIVE_LAYOUT)\n");

if (ValidateIOBufferSize (Irp, sizeof (DRIVE_LAYOUT_INFORMATION), ValidateOutput))

{

BOOL bFullBuffer = (irpSp->Parameters.DeviceIoControl.OutputBufferLength >= (sizeof (DRIVE_LAYOUT_INFORMATION) + 3*sizeof(PARTITION_INFORMATION)))? TRUE : FALSE;

PDRIVE_LAYOUT_INFORMATION outputBuffer = (PDRIVE_LAYOUT_INFORMATION)

Irp->AssociatedIrp.SystemBuffer;

outputBuffer->PartitionCount = bFullBuffer? 4 : 1;

outputBuffer->Signature = GetCrc32((unsigned char*) &(Extension->UniqueVolumeId), 4);

outputBuffer->PartitionEntry->PartitionType = Extension->PartitionType;

outputBuffer->PartitionEntry->BootIndicator = FALSE;

outputBuffer->PartitionEntry->RecognizedPartition = TRUE;

outputBuffer->PartitionEntry->RewritePartition = FALSE;

outputBuffer->PartitionEntry->StartingOffset.QuadPart = BYTES_PER_MB; // Set offset to 1MB to emulate the partition offset on a real MBR disk

outputBuffer->PartitionEntry->PartitionLength.QuadPart = Extension->DiskLength;

outputBuffer->PartitionEntry->PartitionNumber = 1;

outputBuffer->PartitionEntry->HiddenSectors = 0;

Irp->IoStatus.Status = STATUS_SUCCESS;

Irp->IoStatus.Information = sizeof (DRIVE_LAYOUT_INFORMATION);

if (bFullBuffer)

{

Irp->IoStatus.Information += 3*sizeof(PARTITION_INFORMATION);

memset (((BYTE*) Irp->AssociatedIrp.SystemBuffer) + sizeof (DRIVE_LAYOUT_INFORMATION), 0, 3*sizeof(PARTITION_INFORMATION));

}

}

break;

case IOCTL_DISK_GET_DRIVE_LAYOUT_EX:

Dump ("ProcessVolumeDeviceControlIrp (IOCTL_DISK_GET_DRIVE_LAYOUT_EX)\n");

Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;

Irp->IoStatus.Information = 0;

if (EnableExtendedIoctlSupport)

{

if (ValidateIOBufferSize (Irp, sizeof (DRIVE_LAYOUT_INFORMATION_EX), ValidateOutput))

{

BOOL bFullBuffer = (irpSp->Parameters.DeviceIoControl.OutputBufferLength >= (sizeof (DRIVE_LAYOUT_INFORMATION_EX) + 3*sizeof(PARTITION_INFORMATION_EX)))? TRUE : FALSE;

PDRIVE_LAYOUT_INFORMATION_EX outputBuffer = (PDRIVE_LAYOUT_INFORMATION_EX)

Irp->AssociatedIrp.SystemBuffer;

outputBuffer->PartitionCount = bFullBuffer? 4 : 1;

outputBuffer->PartitionStyle = PARTITION_STYLE_MBR;

outputBuffer->Mbr.Signature = GetCrc32((unsigned char*) &(Extension->UniqueVolumeId), 4);

outputBuffer->PartitionEntry->PartitionStyle = PARTITION_STYLE_MBR;

outputBuffer->PartitionEntry->Mbr.BootIndicator = FALSE;

outputBuffer->PartitionEntry->Mbr.RecognizedPartition = TRUE;

outputBuffer->PartitionEntry->RewritePartition = FALSE;

outputBuffer->PartitionEntry->StartingOffset.QuadPart = BYTES_PER_MB; // Set offset to 1MB to emulate the partition offset on a real MBR disk

outputBuffer->PartitionEntry->PartitionLength.QuadPart = Extension->DiskLength;

outputBuffer->PartitionEntry->PartitionNumber = 1;

outputBuffer->PartitionEntry->Mbr.HiddenSectors = 0;

outputBuffer->PartitionEntry->Mbr.PartitionType = Extension->PartitionType;

Irp->IoStatus.Status = STATUS_SUCCESS;

Irp->IoStatus.Information = sizeof (DRIVE_LAYOUT_INFORMATION_EX);

if (bFullBuffer)

{

Irp->IoStatus.Information += 3*sizeof(PARTITION_INFORMATION_EX);

}

}

}

break;

case IOCTL_DISK_GET_LENGTH_INFO:

Dump ("ProcessVolumeDeviceControlIrp (IOCTL_DISK_GET_LENGTH_INFO)\n");

{

if (Extension->bReadOnly)

Irp->IoStatus.Status = STATUS_MEDIA_WRITE_PROTECTED;

else

Irp->IoStatus.Status = STATUS_SUCCESS;

Irp->IoStatus.Information = 0;

}

break;

case IOCTL_VOLUME_ONLINE:

Dump ("ProcessVolumeDeviceControlIrp (IOCTL_VOLUME_ONLINE)\n");

Irp->IoStatus.Status = STATUS_SUCCESS;

Irp->IoStatus.Information = 0;

break;

case IOCTL_VOLUME_POST_ONLINE:

Dump ("ProcessVolumeDeviceControlIrp (IOCTL_VOLUME_POST_ONLINE)\n");

Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;

Irp->IoStatus.Information = 0;

if (EnableExtendedIoctlSupport)

{

Irp->IoStatus.Status = STATUS_SUCCESS;

Irp->IoStatus.Information = 0;

}

break;

case IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS:

Dump ("ProcessVolumeDeviceControlIrp (IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS)\n");

// Vista's, Windows 8.1 and later filesystem defragmenter fails if IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS does not succeed.

{

Irp->IoStatus.Status = STATUS_SUCCESS;

}

break;

case IOCTL_STORAGE_READ_CAPACITY:

Dump ("ProcessVolumeDeviceControlIrp (IOCTL_STORAGE_READ_CAPACITY)\n");

Irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;

Irp->IoStatus.Information = 0;