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;