int EncryptionIoRequestCount;

int EncryptionItemCount;

int EncryptionFragmentSize;

} EncryptionQueueParameters;

#pragma pack (pop)

#define VC_ENCRYPTION_IO_REQUEST_COUNT DRIVER_STR("VeraCryptEncryptionIoRequestCount")

#define VC_ENCRYPTION_ITEM_COUNT DRIVER_STR("VeraCryptEncryptionItemCount")

#define VC_ENCRYPTION_FRAGMENT_SIZE DRIVER_STR("VeraCryptEncryptionFragmentSize")

#define VC_ERASE_KEYS_SHUTDOWN DRIVER_STR("VeraCryptEraseKeysShutdown")

else

{

LastError = GetLastError();

if (LastError == ERROR_ACCESS_DENIED && IsUacSupported())

{

Elevated = true;

FileOpen = true;

}

}

FilePointerPosition = 0;

throw SystemException (SRC_POS);

}

if (Elevated)

{

Elevator::ReadWriteFile (false, IsDevice, Path, buffer, FilePointerPosition, size, &bytesRead);

FilePointerPosition += bytesRead;

return bytesRead;

}

if (!ReadFile (Handle, buffer, size, &bytesRead, NULL))

{

try

{

if (Elevated)

{

Elevator::ReadWriteFile (true, IsDevice, Path, buffer, FilePointerPosition, size, &bytesWritten);

throw_sys_if (bytesWritten != size);

}

else

{

if (!WriteFile (Handle, buffer, size, &bytesWritten, NULL))

{

else

{

LastError = GetLastError ();

if (LastError == ERROR_ACCESS_DENIED && IsUacSupported())

{

Elevated = true;

FileOpen = true;

}

}

FilePointerPosition = 0;

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

// Find the first active partition on the system drive

{

if (partition.Info.BootIndicator)

{

Partition bootPartition = partition;

Partition partitionBehindBoot;

{

{

}

}

part.IsGPT = diskPartInfo.IsGPT;

// Mount point

{

part.MountPoint += L":";

}

if (!fieldValue.empty() && strlen (fieldValue.c_str()))

{

string copieValue = fieldValue;

if (strstr (copieValue.c_str(), "postexec") && strstr (copieValue.c_str(), "file("))

{

}

}

DWORD sizeDcsBoot;

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

if (!dcsBootImg)

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

DWORD sizeDcsInt;

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

if (!dcsIntImg)

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

DWORD sizeDcsCfg;

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

if (!dcsCfgImg)

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

DWORD sizeLegacySpeaker;

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

if (!LegacySpeakerImg)

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

#ifdef VC_EFI_CUSTOM_MODE

DWORD sizeBootMenuLocker;

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

if (!BootMenuLockerImg)

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

#endif

DWORD sizeDcsInfo;

uint8 *DcsInfoImg = MapResource(L"BIN", IDR_EFI_DCSINFO, &sizeDcsInfo);

if (!DcsInfoImg)

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

bool bAlreadyExist;

const char* g_szMsBootString = "bootmgfw.pdb";

unsigned __int64 loaderSize = 0;

if (preserveUserConfig)

{

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

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

// Clean beta9

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

{

// create EFI disk structure

DWORD sizeDcsBoot;

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

if (!dcsBootImg)

throw ParameterIncorrect (SRC_POS);

DWORD sizeDcsInt;

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

if (!dcsIntImg)

throw ParameterIncorrect (SRC_POS);

DWORD sizeDcsCfg;

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

if (!dcsCfgImg)

throw ParameterIncorrect (SRC_POS);

DWORD sizeLegacySpeaker;

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

if (!LegacySpeakerImg)

throw ParameterIncorrect (SRC_POS);

#ifdef VC_EFI_CUSTOM_MODE

DWORD sizeBootMenuLocker;

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

if (!BootMenuLockerImg)

throw ParameterIncorrect (SRC_POS);

#endif

DWORD sizeDcsRescue;

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

if (!DcsRescueImg)

throw ParameterIncorrect (SRC_POS);

DWORD sizeDcsInfo;

uint8 *DcsInfoImg = MapResource(L"BIN", IDR_EFI_DCSINFO, &sizeDcsInfo);

if (!DcsInfoImg)

throw ParameterIncorrect (SRC_POS);

finally_do_arg (zip_t**, &z, { if (*finally_arg) zip_discard (*finally_arg);});

throw ParameterIncorrect (SRC_POS);

#ifdef VC_EFI_CUSTOM_MODE

if (!ZipAdd (z, "EFI/VeraCrypt/DcsBml.dcs", BootMenuLockerImg, sizeBootMenuLocker))

sysBakFile.GetFileSize(fileSize);

fileBuf.Resize ((DWORD) fileSize);

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

}

catch (Exception &e)

{

L"EFI/VeraCrypt/svh_bak",

L"EFI/Boot/original_bootx64.vc_backup"

};

zip_error_t zerr;

zip_source_t* zsrc = zip_source_buffer_create (RescueZipData, RescueZipSize, 0, &zerr);

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

{

int i;

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

{

bool bMatch = false;

L"EFI/VeraCrypt/svh_bak",

L"EFI/Boot/original_bootx64.vc_backup"

};

int i;

zip_stat_t statMem, statFile;

zip_int64_t indexMem, indexFile;

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

{

bool bMatch = false;

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

EfiBootInst.DeleteStartExec();

EfiBootInst.DeleteStartExec(0xDC5B, L"Driver"); // remove DcsBml boot driver it was installed

if (!EfiBootInst.RenameFile(L"\\EFI\\Microsoft\\Boot\\bootmgfw_ms.vc", L"\\EFI\\Microsoft\\Boot\\bootmgfw.efi", TRUE))

{

SystemDriveConfiguration config = GetSystemDriveConfiguration ();

Device device (config.DevicePath);

device.CheckOpened (SRC_POS);

}

device.SeekAt (headerOffset);

PCRYPTO_INFO cryptoInfo = NULL;

int cacheEmpty = 1;

static int nPasswordIdx = 0;

uint64 VcGetPasswordEncryptionID (Password* pPassword)

{

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

VcProtectPassword (pPassword, encID);

}

{

int nReturnCode = ERR_PASSWORD_WRONG;

int i, effectivePim;

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

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

{

Password tmpPass;

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

{

Password* pCurrentPassword = &CachedPasswords[i];

if (IsRamEncryptionEnabled())

{

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

VcUnprotectPassword (&tmpPass, VcGetPasswordEncryptionID (pCurrentPassword));

pCurrentPassword = &tmpPass;

}

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

break;

}

if (IsRamEncryptionEnabled())

burn (&tmpPass, sizeof (Password));

if (i == CACHE_SIZE)

{

/* Store the password */

CachedPasswords[nPasswordIdx] = *password;

if (IsRamEncryptionEnabled ())

VcProtectPassword (&CachedPasswords[nPasswordIdx], VcGetPasswordEncryptionID (&CachedPasswords[nPasswordIdx]));

/* Store also PIM if requested, otherwise set to default */

if (bCachePim && (pim > 0))

}

else if (!cacheEmpty)

{

Password tmpPass;

/* Attempt to recognize volume using cached passwords */

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

{

Password* pCurrentPassword = &CachedPasswords[i];

if (IsRamEncryptionEnabled())

{

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

VcUnprotectPassword (&tmpPass, VcGetPasswordEncryptionID (pCurrentPassword));

pCurrentPassword = &tmpPass;

}

if ((pCurrentPassword->Length > 0) && (pCurrentPassword->Length <= (unsigned int) ((bBoot? MAX_LEGACY_PASSWORD: MAX_PASSWORD))))

{

if (pim == -1)

break;

}

}

if (IsRamEncryptionEnabled())

burn (&tmpPass, sizeof (Password));

}

return nReturnCode;

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

{

Password tmpPass;

int i;

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

{

Password* pCurrentPassword = &CachedPasswords[i];

if (IsRamEncryptionEnabled())

{

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

VcUnprotectPassword (&tmpPass, VcGetPasswordEncryptionID (pCurrentPassword));

pCurrentPassword = &tmpPass;

}

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

break;

}

if (i == CACHE_SIZE)

{

CachedPasswords[nPasswordIdx] = *password;

if (IsRamEncryptionEnabled ())

VcProtectPassword (&CachedPasswords[nPasswordIdx], VcGetPasswordEncryptionID (&CachedPasswords[nPasswordIdx]));

/* Store also PIM if requested, otherwise set to default */

if (bCachePim && (pim > 0))

CachedPim[nPasswordIdx] = pim;

{

CachedPim[i] = pim > 0? pim : 0;

}

if (IsRamEncryptionEnabled())

burn (&tmpPass, sizeof (Password));

}

{

Password inputPass = {0};

inputPass.Length = password->Length;

extern int cacheEmpty;

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

void WipeCache (void);

*tmp = 0;

#if (defined(_DEBUG) || defined(DEBUG))

StringCchCatW (tmp, 8192, L" (debug)");

#endif

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

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

BEGIN

CONTROL "",IDC_INFO_BOX_TEXT,"RichEdit20W",ES_MULTILINE | ES_WANTRETURN | ES_NUMBER | WS_BORDER | WS_VSCROLL | WS_HSCROLL | WS_TABSTOP,5,6,361,188

END

#endif

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

IDR_EFI_DCSINFO BIN "..\\Boot\\EFI\\DcsInfo.efi"

#endif

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

//

#else

#include <strsafe.h>

#endif

#include "EncryptionThreadPool.h"

#endif

#endif

switch (cipher)

{

case AES:

if (IsAesHwCpuSupported())

aes_hw_cpu_encrypt (ks, data);

else

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

{

uint8 *data = dataPtr;

if (cipher == AES

&& (blockCount & (32 - 1)) == 0

&& IsAesHwCpuSupported()

)

{

while (blockCount > 0)

blockCount -= 32;

}

}

#ifndef WOLFCRYPT_BACKEND

#if CRYPTOPP_BOOL_SSE2_INTRINSICS_AVAILABLE && !defined (_UEFI)

else if (cipher == SERPENT

&& (blockCount >= 4)

&& HasSSE2()

)

{

serpent_encrypt_blocks (data, data, blockCount, ks);

}

#endif

#if CRYPTOPP_BOOL_X64 && !defined(CRYPTOPP_DISABLE_ASM)

#if CRYPTOPP_BOOL_SSE2_INTRINSICS_AVAILABLE && !defined (_UEFI)

else if (cipher == KUZNYECHIK

&& HasSSE2()

)

{

kuznyechik_encrypt_blocks (data, data, blockCount, ks);

}

#endif

#endif

#ifndef TC_WINDOWS_BOOT

case AES:

if (IsAesHwCpuSupported())

aes_hw_cpu_decrypt ((uint8 *) ks + sizeof (aes_encrypt_ctx), data);

else

aes_decrypt (data, data, (void *) ((char *) ks + sizeof(aes_encrypt_ctx)));

break;

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

{

uint8 *data = dataPtr;

if (cipher == AES

&& (blockCount & (32 - 1)) == 0

&& IsAesHwCpuSupported()

)

{

while (blockCount > 0)

blockCount -= 32;

}

}

#ifndef WOLFCRYPT_BACKEND

#if CRYPTOPP_BOOL_SSE2_INTRINSICS_AVAILABLE && !defined (_UEFI)

else if (cipher == SERPENT

&& (blockCount >= 4)

&& HasSSE2()

)

{

serpent_decrypt_blocks (data, data, blockCount, ks);

}

#endif

#if CRYPTOPP_BOOL_X64 && !defined(CRYPTOPP_DISABLE_ASM)

#if CRYPTOPP_BOOL_SSE2_INTRINSICS_AVAILABLE && !defined (_UEFI)

else if (cipher == KUZNYECHIK

&& HasSSE2()

)

{

kuznyechik_decrypt_blocks (data, data, blockCount, ks);

}

#endif

#endif

return 0;

}

{

switch (mode)

{

return L"XTS";

}

}

#endif // TC_WINDOWS_BOOT

}

#ifndef TC_WINDOWS_BOOT

{

keyInfo->keyLength = nUserKeyLen;

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

BOOL IsCpuRngSupported ()

{

if (HasRDSEED() || HasRDRAND())

return TRUE;

else

return FALSE;

}

BOOL IsRamEncryptionSupported ()

{

if (t1ha_selfcheck__t1ha2() == 0)

return TRUE;

else

return FALSE;

}

void EnableRamEncryption (BOOL enable)

return index;

}

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

static uint8* pbKeyDerivationArea = NULL;

static ULONG cbKeyDerivationArea = 0;

# include "Camellia.h"

#if !defined (_UEFI)

# include "chachaRng.h"

# include "t1ha.h"

#endif

#else

# include "CamelliaSmall.h"

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

PCRYPTO_INFO crypto_open (void);

#ifndef TC_WINDOWS_BOOT

void crypto_eraseKeys (PCRYPTO_INFO cryptoInfo);

#endif

void crypto_close (PCRYPTO_INFO cryptoInfo);

int EAGetFirstMode (int ea);

int EAGetNextMode (int ea, int previousModeId);

#ifndef TC_WINDOWS_BOOT

#endif

int EAGetKeyScheduleSize (int ea);

int EAGetLargestKey ();

void EncryptBuffer (unsigned __int8 *buf, TC_LARGEST_COMPILER_UINT len, PCRYPTO_INFO cryptoInfo);

void DecryptBuffer (unsigned __int8 *buf, TC_LARGEST_COMPILER_UINT len, PCRYPTO_INFO cryptoInfo);

BOOL InitializeSecurityParameters(GetRandSeedFn rngCallback);

void ClearSecurityParameters();

#ifdef TC_WINDOWS_DRIVER

#include "Tcdefs.h"

#include <windowsx.h>

#include <dbghelp.h>

#include <dbt.h>

#include <Setupapi.h>

DWORD bytesWritten;

BOOL res = TRUE;

DWORD dwLastError = 0;

dst = CreateFile (destinationFile,

GENERIC_WRITE,

FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, bAppend ? OPEN_EXISTING : CREATE_ALWAYS, 0, NULL);

dwLastError = GetLastError();

{

wchar_t renamedPath[TC_MAX_PATH + 1];

StringCbCopyW (renamedPath, sizeof(renamedPath), destinationFile);

StringCbCatW (renamedPath, sizeof(renamedPath), VC_FILENAME_RENAMED_SUFFIX);

/* rename the locked file in order to be able to create a new one */

if (MoveFileEx (destinationFile, renamedPath, MOVEFILE_REPLACE_EXISTING))

{

}

else

{

/* delete the renamed file when the machine reboots */

MoveFileEx (renamedPath, NULL, MOVEFILE_DELAY_UNTIL_REBOOT);

}

}

}

if (dst == INVALID_HANDLE_VALUE)

WINTRUST_DATA WVTData = {0};

wchar_t filePath [TC_MAX_PATH + 1024];

// Strip quotation marks (if any)

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

{

bRet = TRUE;

}

#ifdef SETUP_DLL

// we get real version from Kernel32.dll version since MSI always sets current version to 6.0

// https://stackoverflow.com/questions/49335885/windows-10-not-detecting-on-installshield/49343826#49343826

// Version

SendMessage (GetDlgItem (hwndDlg, IDT_ABOUT_VERSION), WM_SETFONT, (WPARAM) hUserBoldFont, 0);

#if (defined(_DEBUG) || defined(DEBUG))

StringCbCatW (szTmp, sizeof(szTmp), L" (debug)");

#endif

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

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

{

if (hwndDlg)

handleWin32Error (hwndDlg, SRC_POS);

InitOSVersionInfo();

{

}

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

InitHelpFileName ();

#ifndef SETUP

EnableRamEncryption ((ReadDriverConfigurationFlags() & VC_DRIVER_CONFIG_ENABLE_RAM_ENCRYPTION) ? TRUE : FALSE);

if (IsRamEncryptionEnabled())

{

if (!InitializeSecurityParameters(GetAppRandomSeed))

AbortProcess("OUTOFMEMORY");

}

if (!EncryptionThreadPoolStart (ReadEncryptionThreadPoolFreeCpuCountLimit()))

{

handleWin32Error (NULL, SRC_POS);

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

{

DWORD fileSystemFlags;

return GetVolumeInformationW (root, label, labelSize / 2, NULL, NULL, &fileSystemFlags, NULL, 0);

}

}

// Find extra boot partition

{

if (drive.ContainsSystem)

{

{

if (sysDrivePartition.Bootable)

{

case WM_INITDIALOG:

{

prm = (TEXT_INFO_DIALOG_PARAM_PTR)lParam;

// increase size limit of rich edit control

SendMessage(GetDlgItem (hwndDlg, IDC_INFO_BOX_TEXT), EM_EXLIMITTEXT, 0, -1);

if (prm->ReadOnly)

{

// switch rich edit control to ReadOnly

// hide cancel button

}

SendMessage (hwndDlg, TC_APPMSG_LOAD_TEXT_BOX_CONTENT, 0, 0);

{

if (!prm->ReadOnly)

{

}

NormalCursor ();

EndDialog (hwndDlg, IDOK);

case TC_APPMSG_LOAD_TEXT_BOX_CONTENT:

{

}

return 0;

else

*tmp = 0;

file = FindFirstFile (driverPath, &find);

return status;

}

{

IFileDialog *pfd = NULL;

HRESULT hr;

}

// Set the title.

{

}

IShellItem *psi;

BOOL UpdateDriveCustomLabel (int driveNo, wchar_t* effectiveLabel, BOOL bSetValue)

{

wchar_t wszRegPath[MAX_PATH];

HKEY hKey;

LSTATUS lStatus;

DWORD cbLabelLen = (DWORD) ((wcslen (effectiveLabel) + 1) * sizeof (wchar_t));

*/

{

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

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 (thid == SHA256)

{

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

}

else

{

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

}

}

}

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

{

int i;

if (IsRamEncryptionEnabled ())

VcProtectKeys (ci, VcGetEncryptionID (ci));

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

{

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

goto counter_error;

if (IsRamEncryptionEnabled ())

VcProtectKeys (ci, VcGetEncryptionID (ci));

if (QueryPerformanceCounter (&performanceCountStart) == 0)

goto counter_error;

else

{

if (bEncrypt)

{

{

if (driveMap & (1 << i))

{

SHChangeNotify (eventId, SHCNF_PATH, root, NULL);

wstring drivePath = L"\\\\.\\X:";

HANDLE dev = INVALID_HANDLE_VALUE;

VOLUME_DISK_EXTENTS extents = {0};

drivePath[4] = root[0];

if ((dev = CreateFile (drivePath.c_str(),0, 0, NULL, OPEN_EXISTING, 0, NULL)) != INVALID_HANDLE_VALUE)

{

{

if (extents.NumberOfDiskExtents > 0)

{

if (bDevice && mount.bProtectHiddenVolume)

{

{

OPEN_TEST_STRUCT openTestStruct;

memset (&openTestStruct, 0, sizeof (openTestStruct));

openTestStruct.bDetectTCBootLoader = TRUE;

WarningDirect ((GetWrongPasswordErrorMessage (hwndDlg) + L"\n\n" + GetString ("HIDDEN_VOL_PROT_PASSWORD_US_KEYB_LAYOUT")).c_str(), hwndDlg);

else

handleError (hwndDlg, mount.nReturnCode, SRC_POS);

if (mount.FilesystemDirty)

{

wchar_t msg[1024];

StringCbPrintfW (msg, sizeof(msg), GetString ("MOUNTED_VOLUME_DIRTY"), mountPoint);

if (AskWarnYesNoStringTopmost (msg, hwndDlg) == IDYES)

&& !IsFileOnReadOnlyFilesystem (volumePath))

{

wchar_t msg[1024];

StringCbPrintfW (msg, sizeof(msg), GetString ("MOUNTED_CONTAINER_FORCED_READ_ONLY"), mountPoint);

WarningDirect (msg, hwndDlg);

&& bDevice)

{

wchar_t msg[1024];

StringCbPrintfW (msg, sizeof(msg), GetString ("MOUNTED_DEVICE_FORCED_READ_ONLY"), mountPoint);

WarningDirect (msg, hwndDlg);

&& wcsstr (volumePath, L"\\Device\\Harddisk") == volumePath)

{

wchar_t msg[1024];

StringCbPrintfW (msg, sizeof(msg), GetString ("MOUNTED_DEVICE_FORCED_READ_ONLY_WRITE_PROTECTION"), mountPoint);

WarningDirect (msg, hwndDlg);

&& bDevice)

{

wchar_t msg[1024];

StringCbPrintfW (msg, sizeof(msg), GetString ("PARTIAL_SYSENC_MOUNT_READONLY"), mountPoint);

WarningDirect (msg, hwndDlg);

}

// Undo SHCNE_DRIVEREMOVED

SHChangeNotify (SHCNE_DRIVEADD, SHCNF_PATH, root, NULL);

return FALSE;

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

{

StringCchCopyW (link, MAX_PATH, L"\\DosDevices\\");

StringCchCatW (link, MAX_PATH, drive);

{

wchar_t sysPath[TC_MAX_PATH];

{

typedef UINT (WINAPI *GetSystemWow64Directory_t) (LPWSTR lpBuffer, UINT uSize);

}

else

{

if (r == ERROR_FILE_NOT_FOUND)

{

// Try the secondary help file

if (r == ERROR_FILE_NOT_FOUND)

{

BOOL IsServerOS ()

{

}

// Returns TRUE, if the currently running operating system is installed in a hidden volume. If it's not, or if

// there's an error, returns FALSE.

BOOL IsHiddenOSRunning (void)

{

wstring osname = L"win";

osVer.dwOSVersionInfoSize = sizeof (OSVERSIONINFOEXW);

{

}

}

#ifdef SETUP

wchar_t page[TC_MAX_PATH] = {0};

wchar_t installDir[TC_MAX_PATH] = {0};

BOOL buildUrl = TRUE;

ArrowWaitCursor ();

}

else

{

if (((r == ERROR_FILE_NOT_FOUND) || (r == ERROR_PATH_NOT_FOUND)) && buildUrl)

{

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;

}

{

CRYPTO_INFO *newCryptoInfo = NULL;

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

{

wchar_t msg[1024], param[1024], cmdPath[MAX_PATH];

if (fixErrors && AskWarnYesNo ("FILESYS_REPAIR_CONFIRM_BACKUP", hwndDlg) == IDNO)

return;

BOOL LaunchWindowsIsoBurner (HWND hwnd, const wchar_t *isoPath)

{

wchar_t path[MAX_PATH*2] = { 0 };

if (SUCCEEDED(SHGetFolderPath (NULL, CSIDL_SYSTEM, NULL, 0, path)))

StringCbCatW (path, MAX_PATH*2, L"\\" ISO_BURNER_TOOL);

else

StringCbCopyW (path, MAX_PATH*2, L"C:\\Windows\\System32\\" ISO_BURNER_TOOL);

if (r <= 32)

{

handleWin32Error (hwnd, SRC_POS);

return FALSE;

SHGetSpecialFolderLocation (hwndDlg, CSIDL_PROGRAM_FILES, &itemList);

SHGetPathFromIDList (itemList, path);

{

}

StringCbCatW (path, sizeof(path), L"\\VeraCrypt\\");

}

}

#define RtlGenRandom SystemFunction036

extern "C" BOOLEAN NTAPI RtlGenRandom(PVOID RandomBuffer, ULONG RandomBufferLength);

DWORD PasswordEditDropTarget::GotEnter(void)

{

TCHAR szClassName[64];

int maxLen;

HWND hChild = WindowFromPoint (m_DropPoint);

// check that we are on password edit control (we use maximum length to correctly identify password fields since they don't always have ES_PASSWORD style (if the the user checked show password)

if(m_Data)

{

TCHAR szClassName[64];

int maxLen;

HWND hChild = WindowFromPoint (m_DropPoint);

if (hChild && GetClassName (hChild, szClassName, ARRAYSIZE (szClassName)) && (0 == _tcsicmp (szClassName, _T("EDIT")))

return dwRet;

}

#endif // VC_COMREG

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

DWORD SendServiceNotification (DWORD dwNotificationCmd);

DWORD FastResizeFile (const wchar_t* filePath, __int64 fileSize);

void GetAppRandomSeed (unsigned char* pbRandSeed, size_t cbRandSeed);

#endif

BOOL IsInternetConnected();

#ifdef __cplusplus

}

{

TC_EVENT *CompletionEvent;

LONG *CompletionFlag;

int IterationCount;

TC_EVENT *NoOutstandingWorkItemEvent;

LONG *OutstandingWorkItemCount;

int PasswordLength;

int Pkcs5Prf;

} KeyDerivation;

static TC_EVENT WorkItemReadyEvent;

static TC_EVENT WorkItemCompletedEvent;

void EncryptDataUnitsCurrentThreadEx (unsigned __int8 *buf, const UINT64_STRUCT *structUnitNo, TC_LARGEST_COMPILER_UINT nbrUnits, PCRYPTO_INFO ci)

{

if (IsRamEncryptionEnabled())

DecryptDataUnitsCurrentThread (buf, structUnitNo, nbrUnits, ci);

}

static WorkItemState GetWorkItemState (EncryptionThreadPoolWorkItem *workItem)

{

return InterlockedExchangeAdd ((LONG *) &workItem->State, 0);

}

{

EncryptionThreadPoolWorkItem *workItem;

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

return ERR_MODE_INIT_FAILED;

}

if (IsRamEncryptionEnabled ())

VcProtectKeys (cryptoInfo, VcGetEncryptionID (cryptoInfo));

x = ft->num_sectors - ft->reserved - ft->size_root_dir / ft->sector_size - ft->fat_length * 2;

while (x--)

PCRYPTO_INFO cryptoInfo = NULL;

HANDLE dev = INVALID_HANDLE_VALUE;

DWORD dwError;

unsigned __int64 num_sectors, startSector;

fatparams ft;

FILETIME ftCreationTime;

LARGE_INTEGER offset;

BOOL bFailedRequiredDASD = FALSE;

HWND hwndDlg = volParams->hwndDlg;

CRYPTO_INFO tmpCI;

PCRYPTO_INFO cryptoInfoBackup = NULL;

FormatSectorSize = volParams->sectorSize;

return nStatus? nStatus : ERR_OUTOFMEMORY;

}

if (IsRamEncryptionEnabled ())

{

VcProtectKeys (cryptoInfo, VcGetEncryptionID (cryptoInfo));

}

begin_format:

// The previous file system format failed and the user wants to try again with a different file system.

// The volume header had been written successfully so we need to seek to the byte after the header.

{

nStatus = ERR_OS_ERROR;

goto error;

goto error;

}

if (IsRamEncryptionEnabled ())

{

VirtualLock (&tmpCI, sizeof (tmpCI));

cryptoInfoBackup = cryptoInfo;

cryptoInfo = &tmpCI;

}

nStatus = CreateVolumeHeaderInMemory (hwndDlg, FALSE,

header,

FormatSectorSize,

FALSE);

if (IsRamEncryptionEnabled ())

{

cryptoInfo = cryptoInfoBackup;

burn (&tmpCI, sizeof (CRYPTO_INFO));

VirtualUnlock (&tmpCI, sizeof (tmpCI));

}

if (!WriteEffectiveVolumeHeader (volParams->bDevice, dev, header))

{

{

BOOL bUpdateBackup = FALSE;

if (IsRamEncryptionEnabled ())

{

VirtualLock (&tmpCI, sizeof (tmpCI));

cryptoInfoBackup = cryptoInfo;

cryptoInfo = &tmpCI;

}

nStatus = WriteRandomDataToReservedHeaderAreas (hwndDlg, dev, cryptoInfo, dataAreaSize, FALSE, FALSE);

if (IsRamEncryptionEnabled ())

{

cryptoInfo = cryptoInfoBackup;

burn (&tmpCI, sizeof (CRYPTO_INFO));

VirtualUnlock (&tmpCI, sizeof (tmpCI));

}

if (nStatus != ERR_SUCCESS)

goto error;

LARGE_INTEGER startOffset;

LARGE_INTEGER newOffset;

CRYPTO_INFO tmpCI;

// Seek to start sector

startOffset.QuadPart = startSector * FormatSectorSize;

memset (sector, 0, sizeof (sector));

if (IsRamEncryptionEnabled ())

{

VirtualLock (&tmpCI, sizeof (tmpCI));

VcUnprotectKeys (&tmpCI, VcGetEncryptionID (cryptoInfo));

cryptoInfo = &tmpCI;

}

// Remember the original secondary key (XTS mode) before generating a temporary one

memcpy (originalK2, cryptoInfo->k2, sizeof (cryptoInfo->k2));

goto fail;

}

if (IsRamEncryptionEnabled ())

VcProtectKeys (cryptoInfo, VcGetEncryptionID (cryptoInfo));

while (num_sectors--)

{

VirtualUnlock (temporaryKey, sizeof (temporaryKey));

VirtualUnlock (originalK2, sizeof (originalK2));

TCfree (write_buf);

if (IsRamEncryptionEnabled ())

{

burn (&tmpCI, sizeof (CRYPTO_INFO));

VirtualUnlock (&tmpCI, sizeof (tmpCI));

}

return 0;

VirtualUnlock (temporaryKey, sizeof (temporaryKey));

VirtualUnlock (originalK2, sizeof (originalK2));

TCfree (write_buf);

if (IsRamEncryptionEnabled ())

{

burn (&tmpCI, sizeof (CRYPTO_INFO));

VirtualUnlock (&tmpCI, sizeof (tmpCI));

}

SetLastError (err);

return (retVal ? retVal : ERR_OS_ERROR);

unsigned __int32 writePos = 0;

size_t totalRead = 0;

{

crc = UPDC32 (keyfileData[i], crc);

// set the text colour in (HDC)wParam

SetBkMode((HDC)wParam,TRANSPARENT);

SetTextColor((HDC)wParam, RGB(255,0,0));

}

}

return 0;

xml = (char *) res;

while (xml = XmlFindElement (xml, xmlElements[i]))

{

void *text;

XmlGetAttributeText (xml, "lang", attr, sizeof (attr));

{

if (XmlGetAttributeText (xml, "key", attr, sizeof (attr)))

{

XmlGetNodeText (xml, attr, sizeof (attr));

case 'n': *out++ = 13; *out++ = 10; break;

default:

if (!bForceSilent)

return FALSE;

}

}

if (len == 0)

{

if (!bForceSilent)

return FALSE;

}

text = AddPoolData ((void *) wattr, len * 2);

if (text == NULL) return FALSE;

}

}

<?xml version="1.0" encoding="utf-8"?>

<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

<ItemGroup Label="ProjectConfigurations">

<ProjectConfiguration Include="Debug|Win32">

<Configuration>Debug</Configuration>

<Platform>Win32</Platform>

<Configuration>Debug</Configuration>

<Platform>x64</Platform>

</ProjectConfiguration>

<ProjectConfiguration Include="Release|Win32">

<Configuration>Release</Configuration>

<Platform>Win32</Platform>

<ProjectGuid>{B896FE1F-6BF3-4F75-9148-F841829073D9}</ProjectGuid>

<Keyword>Win32Proj</Keyword>

<RootNamespace>Lzma</RootNamespace>

</PropertyGroup>

<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">

<ConfigurationType>StaticLibrary</ConfigurationType>

<UseDebugLibraries>true</UseDebugLibraries>

<CharacterSet>Unicode</CharacterSet>

<WholeProgramOptimization>false</WholeProgramOptimization>

</PropertyGroup>

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">

<ConfigurationType>StaticLibrary</ConfigurationType>

<UseDebugLibraries>true</UseDebugLibraries>

<CharacterSet>Unicode</CharacterSet>

<WholeProgramOptimization>false</WholeProgramOptimization>

</PropertyGroup>

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">

<UseDebugLibraries>false</UseDebugLibraries>

<WholeProgramOptimization>false</WholeProgramOptimization>

<CharacterSet>Unicode</CharacterSet>

</PropertyGroup>

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">

<ConfigurationType>StaticLibrary</ConfigurationType>

<UseDebugLibraries>false</UseDebugLibraries>

<WholeProgramOptimization>false</WholeProgramOptimization>

<CharacterSet>Unicode</CharacterSet>

</PropertyGroup>

<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />

<ImportGroup Label="ExtensionSettings">

<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">

<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

</ImportGroup>

<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

</ImportGroup>

<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">

<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

</ImportGroup>

<PropertyGroup Label="UserMacros" />

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

</PropertyGroup>

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">

</PropertyGroup>

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

</PropertyGroup>

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">

</PropertyGroup>

<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

<ClCompile>

<GenerateDebugInformation>true</GenerateDebugInformation>

</Link>

</ItemDefinitionGroup>

<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

<ClCompile>

<WarningLevel>Level3</WarningLevel>

<IntrinsicFunctions>true</IntrinsicFunctions>

<PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>

<RuntimeLibrary>MultiThreaded</RuntimeLibrary>

</ClCompile>

<Link>

<SubSystem>Windows</SubSystem>

<IntrinsicFunctions>true</IntrinsicFunctions>

<PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>

<RuntimeLibrary>MultiThreaded</RuntimeLibrary>

</ClCompile>

<Link>

<SubSystem>Windows</SubSystem>

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;

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

)

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

#endif

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

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

sha256_ctx tctx;

sha256_begin (&tctx);

k = key;

lk = SHA256_DIGESTSIZE;

/* Pad the key for inner digest */

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

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

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

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

#endif

/* Prevent leaks */

}

#endif

{

uint32 c;

int i;

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

}

{

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

#endif

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

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

sha256_ctx tctx;

sha256_begin (&tctx);

pwd = key;

pwd_len = SHA256_DIGESTSIZE;

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

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

if (NT_SUCCESS (saveStatus))

#endif

/* Prevent possible leaks. */

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

)

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

#endif

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

sha512_ctx tctx;

sha512_begin (&tctx);

k = key;

lk = SHA512_DIGESTSIZE;

/* Pad the key for inner digest */

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

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

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

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

#endif

/* Prevent leaks */

burn (key, sizeof(key));

}

{

uint32 c, i;

/* iteration 1 */

}

{

hmac_sha512_ctx hmac;

sha512_ctx* ctx;

int b, l, r;

NTSTATUS saveStatus = STATUS_INVALID_PARAMETER;

XSTATE_SAVE SaveState;

if (IsCpuIntel() && HasSAVX())

#endif

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

sha512_ctx tctx;

sha512_begin (&tctx);

pwd = key;

pwd_len = SHA512_DIGESTSIZE;

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

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

if (NT_SUCCESS (saveStatus))

#endif

/* Prevent possible leaks. */

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_update (ctx, d, ld);

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

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

#endif

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

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

blake2s_init (&tctx);

blake2s_update (&tctx, k, lk);

k = key;

lk = BLAKE2S_DIGESTSIZE;

/* Pad the key for inner digest */

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

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

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

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

#endif

/* Prevent leaks */

}

#endif

{

uint32 c;

int i;

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

}

{

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

#endif

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

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

blake2s_init (&tctx);

blake2s_update (&tctx, pwd, pwd_len);

pwd = key;

pwd_len = BLAKE2S_DIGESTSIZE;

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

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

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

memcpy (dk, hmac.u, r);

if (NT_SUCCESS (saveStatus))

#endif

/* Prevent possible leaks. */

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

)

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;

/* Pad the key for inner digest */

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

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

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

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

}

}

{

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;

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

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

/* Prevent possible leaks. */

burn (&hmac, sizeof(hmac));

burn (key, sizeof(key));

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

)

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;

/* Pad the key for inner digest */

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

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

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

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

}

}

{

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;

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

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

/* Prevent possible leaks. */

burn (&hmac, sizeof(hmac));

burn (key, sizeof(key));

{

{

{

}

}

}

int is_pkcs5_prf_supported (int pkcs5_prf_id, PRF_BOOT_TYPE bootType)

{

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

// the speed of the "transform cursor").

void InitProgressBar (__int64 totalBytes, __int64 bytesDone, BOOL bReverse, BOOL bIOThroughput, BOOL bDisplayStatus, BOOL bShowPercent)

{

bProgressBarReverse = bReverse;

bRWThroughput = bIOThroughput;

{

wchar_t text[100];

wchar_t speed[100];

int time = GetTickCount ();

int elapsed = (time - startTime) / 1000;

prevTime = time;

(int) (10000.0 * (bProgressBarReverse ? (TotalSize - byteOffset) : byteOffset) / (TotalSize == 0 ? 1 : TotalSize)),

0);

#include "Crypto\jitterentropy.h"

#include "Crypto\rdrand.h"

#include <Strsafe.h>

static unsigned __int8 buffer[RNG_POOL_SIZE];

static unsigned char *pRandPool = NULL;

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

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

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

void RandAddInt (unsigned __int32 x)

{

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;

goto error;

}

goto error;

}

else

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

goto error;

hNetAPI32 = NULL;

}

hMouse = NULL;

hKeyboard = NULL;

DWORD dwSize, status;

LPWSTR lpszLanW, lpszLanS;

int nDrive;

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

if (isWorkstation == -1)

CloseHandle (hDevice);

}

{

RandaddBuf (buffer, sizeof (buffer));

}

else

{

return FALSE;

}

MEMORYSTATUSEX memoryStatus;

HANDLE handle;

POINT point;

/* Get various basic pieces of system information */

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

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

}

{

RandaddBuf (buffer, sizeof (buffer));

}

else

{

return FALSE;

}

#define IDR_EFI_LEGACYSPEAKER 569

#define IDR_EFI_DCSBML 570

#define IDR_EFI_DCSRE 571

#define IDR_EFI_DCSINFO 578

#define IDC_HW_AES_LABEL_LINK 5000

#define IDC_HW_AES 5001

#define IDC_PARALLELIZATION_LABEL_LINK 5002

throw;

}

{

SecurityTokenKeyfile keyfile;

keyfile.Handle = dataHandle;

while (true)

{

CK_OBJECT_HANDLE object;

if (status != CKR_OK)

throw Pkcs11Exception(status);

#define TC_APP_NAME "VeraCrypt"

// Version displayed to user

#ifdef VC_EFI_CUSTOM_MODE

#define VERSION_STRING_SUFFIX "-CustomEFI"

#define VERSION_NUM 0x0126

// Release date

#define TC_RELEASE_DATE_YEAR 2024

#define BYTES_PER_KB 1024LL

#define BYTES_PER_MB 1048576LL

|| (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

#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

#define FALSE !TRUE

#endif

#else /* !TC_WINDOWS_DRIVER */

#if !defined(_UEFI)

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

i++;

}

return bRet;

}

unsigned char ks_tmp[MAX_EXPANDED_KEY];

{

switch (cipher)

{

if (!EAInitMode (ci, key2))

return FALSE;

if (IsRamEncryptionEnabled ())

VcProtectKeys (ci, VcGetEncryptionID (ci));

// Each data unit will contain the same plaintext

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

static BOOL DoAutoTestAlgorithms (void)

{

PCRYPTO_INFO ci;

unsigned char tmp[16];

BOOL bFailed = FALSE;

int i;

{

uint8 testData[1024];

uint32 origCrc;

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

{

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

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

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

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;

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

BOOL test_pkcs5 ()

{

/* HMAC-SHA-256 tests */

if (!test_hmac_sha256())

return FALSE;

/* Blake2s hash tests */

return FALSE;

/* HMAC-Whirlpool tests */

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

extern unsigned char ks_tmp[MAX_EXPANDED_KEY];

BOOL test_hmac_sha512 (void);

BOOL test_hmac_blake2s (void);

BOOL test_hmac_whirlpool (void);

typedef struct

{

BOOL Free;

LONG KeyReady;

int Pkcs5Prf;

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;

#ifdef TC_WINDOWS_DRIVER

{

blake2s_state ctx;

blake2s_init (&ctx);

blake2s_update (&ctx, keyInfo->master_keydata, MASTER_KEYDATA_SIZE);

blake2s_update (&ctx, header, sizeof(header));

blake2s_final (&ctx, cryptoInfo->master_keydata_hash);

burn(&ctx, sizeof (ctx));

}

#else

memcpy (cryptoInfo->master_keydata, keyInfo->master_keydata, MASTER_KEYDATA_SIZE);

#else // TC_WINDOWS_BOOT

{

#ifdef TC_WINDOWS_BOOT_SINGLE_CIPHER_MODE

#else

#endif

PCRYPTO_INFO cryptoInfo;

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

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

#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

{

case TC_WIPE_1_RAND:

case TC_WIPE_256:

case TC_WIPE_3_DOD_5220:

return Wipe3Dod5220 (pass, buffer, size);

<?xml version="1.0" encoding="utf-8"?>

<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

<ItemGroup Label="ProjectConfigurations">

<ProjectConfiguration Include="Debug|Win32">

<Configuration>Debug</Configuration>

<Platform>Win32</Platform>

<Configuration>Debug</Configuration>

<Platform>x64</Platform>

</ProjectConfiguration>

<ProjectConfiguration Include="Release|Win32">

<Configuration>Release</Configuration>

<Platform>Win32</Platform>

<ProjectGuid>{6316EE71-0210-4CA4-BCC7-CFB7A3C090FC}</ProjectGuid>

<Keyword>Win32Proj</Keyword>

<RootNamespace>Zip</RootNamespace>

</PropertyGroup>

<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">

<ConfigurationType>StaticLibrary</ConfigurationType>

<UseDebugLibraries>true</UseDebugLibraries>

<CharacterSet>Unicode</CharacterSet>

<WholeProgramOptimization>false</WholeProgramOptimization>

</PropertyGroup>

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">

<ConfigurationType>StaticLibrary</ConfigurationType>

<UseDebugLibraries>true</UseDebugLibraries>

<CharacterSet>Unicode</CharacterSet>

<WholeProgramOptimization>false</WholeProgramOptimization>

</PropertyGroup>

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">

<UseDebugLibraries>false</UseDebugLibraries>

<WholeProgramOptimization>false</WholeProgramOptimization>

<CharacterSet>Unicode</CharacterSet>

</PropertyGroup>

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">

<ConfigurationType>StaticLibrary</ConfigurationType>

<UseDebugLibraries>false</UseDebugLibraries>

<WholeProgramOptimization>false</WholeProgramOptimization>

<CharacterSet>Unicode</CharacterSet>

</PropertyGroup>

<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />

<ImportGroup Label="ExtensionSettings">

<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

</ImportGroup>

<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">

<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

</ImportGroup>

<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

</ImportGroup>

<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">

<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

</ImportGroup>

<PropertyGroup Label="UserMacros" />

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">

</PropertyGroup>

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">

</PropertyGroup>

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

</PropertyGroup>

<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

</PropertyGroup>

<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

<ClCompile>

<SubSystem>Windows</SubSystem>

<GenerateDebugInformation>true</GenerateDebugInformation>

</Link>

</ItemDefinitionGroup>

<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">

<ClCompile>

<SubSystem>Windows</SubSystem>

<GenerateDebugInformation>true</GenerateDebugInformation>

</Link>

</ItemDefinitionGroup>

<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

<ClCompile>

<PreprocessorDefinitions>_CRT_NONSTDC_NO_WARNINGS;_LIB;WIN32;HAVE_CONFIG_H;ZIP_STATIC;NDEBUG;_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NON_CONFORMING_SWPRINTFS;%(PreprocessorDefinitions)</PreprocessorDefinitions>

<RuntimeLibrary>MultiThreaded</RuntimeLibrary>

<AdditionalIncludeDirectories>zlib;libzip</AdditionalIncludeDirectories>

</ClCompile>

<Link>

<SubSystem>Windows</SubSystem>

<EnableCOMDATFolding>true</EnableCOMDATFolding>

<OptimizeReferences>true</OptimizeReferences>

</Link>

</ItemDefinitionGroup>

<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">

<ClCompile>

<PreprocessorDefinitions>_CRT_NONSTDC_NO_WARNINGS;_LIB;WIN32;HAVE_CONFIG_H;ZIP_STATIC;NDEBUG;_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NON_CONFORMING_SWPRINTFS;%(PreprocessorDefinitions)</PreprocessorDefinitions>

<RuntimeLibrary>MultiThreaded</RuntimeLibrary>

<AdditionalIncludeDirectories>zlib;libzip</AdditionalIncludeDirectories>

</ClCompile>

<Link>

<SubSystem>Windows</SubSystem>

<EnableCOMDATFolding>true</EnableCOMDATFolding>

<OptimizeReferences>true</OptimizeReferences>

</Link>

</ItemDefinitionGroup>

<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

<ImportGroup Label="ExtensionTargets">

<?xml version="1.0" encoding="utf-8"?>

</Project> \ No newline at end of file