BiosResultTimeout = 0x80

};

#endif // TC_HEADER_Boot_Bios

typedef struct

{

} BootSectorConfiguration;

uint32 Data1;

uint16 Data2;

uint16 Data3;

} DCS_GUID;

// DE types

struct {

uint32 Type;

uint32 Offset;

uint64 Length; // size of structure at Offset

};

DCS_DISK_ENTRY_SECTORS Sectors;

uint32 Count;

PasswordLegacy Pwd[4];

int32 Pim[4];

} DCS_DEP_PWD_CACHE;

CSTATIC_ASSERT(sizeof(DCS_DEP_PWD_CACHE) == 512, Wrong_size_DCS_DEP_PWD_CACHE);

#pragma pack()

#include "BootConfig.h"

bool BootDriveGeometryValid = false;

bool PreventNormalSystemBoot = false;

bool PreventBootMenu = false;

void ReadBootSectorUserConfiguration ()

{

AcquireSectorBuffer();

}

{

uint64 mbrSector;

mbrSector.HighPart = 0;

#include "Platform.h"

#include "BootDiskIo.h"

extern bool BootDriveGeometryValid;

extern DriveGeometry BootDriveGeometry;

extern bool PreventNormalSystemBoot;

void ReadBootSectorUserConfiguration ();

#endif // TC_HEADER_Boot_BootConfig

}

{

PrintChar (((b >> 4) >= 0xA ? 'A' - 0xA : '0') + (b >> 4));

PrintChar (((b & 0xF) >= 0xA ? 'A' - 0xA : '0') + (b & 0xF));

void PrintHex (uint16 data)

{

}

}

{

__asm

{

mov ah, 2

}

{

return GetKeyboardChar (nullptr);

}

}

*/

{

// Work around potential BIOS bugs (Windows boot manager polls the keystroke buffer)

while (!IsKeyboardCharAvailable())

}

}

__asm

{

mov ah, 0

{

if (IsKeyboardCharAvailable ())

{

GetKeyboardChar (&keyScanCode);

return keyScanCode == TC_BIOS_KEY_ESC;

}

int GetString (char *buffer, size_t bufferSize)

{

size_t pos = 0;

while (pos < bufferSize)

void DisableScreenOutput ();

void EnableScreenOutput ();

bool EscKeyPressed ();

int GetString (char *buffer, size_t bufferSize);

void InitVideoMode ();

bool IsKeyboardCharAvailable ();

void PrintRepeatedChar (char c, int n);

void PrintError (const char *message);

void PrintErrorNoEndl (const char *message);

void PrintHex (uint16 data);

void PrintHex (uint32 data);

void PrintHex (const uint64 &data);

}

{

__asm

{

}

{

const size_t width = 16;

for (size_t pos = 0; pos < size; )

size_t i;

for (i = 0; i < width && pos < size; ++i)

{

if (memSegment)

{

__asm

void PrintHexDump (uint16 memSegment, uint16 memOffset, size_t size)

{

}

#endif // TC_BOOT_DEBUG_ENABLED

void InitDebugPort ();

void InitStackChecker ();

void PrintHexDump (uint16 memSegment, uint16 memOffset, size_t size);

void PrintVal (const char *message, const uint32 value, bool newLine = true, bool hex = false);

void PrintVal (const char *message, const uint64 &value, bool newLine = true, bool hex = false);

#include "BootStrings.h"

#ifdef TC_BOOT_DEBUG_ENABLED

static bool SectorBufferInUse = false;

#endif

{

static bool CachedStatus;

uint16 result = 0;

}

{

PrintEndl();

Print (write ? "Write" : "Read"); Print (" error:");

}

{

CheckStack();

BiosResult result;

do

{

#ifdef TC_WINDOWS_BOOT_RESCUE_DISK_MODE

{

uint16 codeSeg;

__asm mov codeSeg, cs

return ReadWriteSectors (write, codeSeg, (uint16) buffer, drive, chs, sectorCount, silent);

}

{

return ReadWriteSectors (false, buffer, drive, chs, sectorCount, silent);

}

#if 0

{

return ReadWriteSectors (true, buffer, drive, chs, sectorCount, silent);

}

#endif

{

CheckStack();

dapPacket.SectorCount = sectorCount;

dapPacket.Sector = sector;

BiosResult result;

do

{

}

{

BiosLbaPacket dapPacket;

dapPacket.Buffer = (uint32) buffer;

}

{

BiosLbaPacket dapPacket;

dapPacket.Buffer = ((uint32) bufferSegment << 16) | bufferOffset;

return ReadWriteSectors (write, dapPacket, drive, sector, sectorCount, silent);

}

{

return ReadWriteSectors (false, bufferSegment, bufferOffset, drive, sector, sectorCount, silent);

}

{

BiosResult result;

uint16 codeSeg;

}

{

return ReadWriteSectors (true, buffer, drive, sector, sectorCount, silent);

}

{

CheckStack();

BiosResult result;

__asm

{

void LbaToChs (const DriveGeometry &geometry, const uint64 &lba, ChsAddress &chs)

{

uint32 ch = lba.LowPart / geometry.Sectors;

chs.Cylinder = (uint16) (ch / geometry.Heads);

}

}

{

uint64 mbrSector;

mbrSector.HighPart = 0;

}

{

Partition *followingPartition;

Partition tmpPartition;

MBR *extMbr = (MBR *) SectorBuffer;

while (partitionArrayPos < partitionArrayCapacity &&

&& extMbr->Signature == 0xaa55)

{

if (extMbr->Partitions[0].SectorCountLBA > 0)

}

{

size_t partCount;

struct PartitionEntryMBR

{

uint32 StartLBA;

uint32 SectorCountLBA;

struct MBR

{

PartitionEntryMBR Partitions[4];

uint16 Signature;

};

struct BiosLbaPacket

{

uint16 SectorCount;

uint32 Buffer;

uint64 Sector;

struct ChsAddress

{

uint16 Cylinder;

};

struct Partition

{

bool Active;

uint64 EndSector;

bool Primary;

uint64 SectorCount;

uint64 StartSector;

};

struct DriveGeometry

{

uint16 Cylinders;

};

#endif

void ChsToLba (const DriveGeometry &geometry, const ChsAddress &chs, uint64 &lba);

void LbaToChs (const DriveGeometry &geometry, const uint64 &lba, ChsAddress &chs);

void Print (const ChsAddress &chs);

void PrintSectorCountInMB (const uint64 &sectorCount);

#endif // TC_HEADER_Boot_BootDiskIo

#include "BootEncryptedIo.h"

{

BiosResult result;

bool decrypt = true;

}

{

BiosResult result = BiosResultSuccess;

AcquireSectorBuffer();

#include "Platform.h"

static bool ReadWritePartiallyCoversEncryptedArea (const uint64 &sector, uint16 sectorCount);

#endif // TC_HEADER_Boot_BootEncryptionIo

}

{

#ifdef TC_WINDOWS_BOOT_RESCUE_DISK_MODE

return scanCode == TC_MENU_KEY_REPAIR;

}

{

size_t pos = 0;

pim = 0;

}

{

Print ("Booting...\r\n");

CopyMemory (sectorBuffer, 0x0000, 0x7c00, TC_LB_SIZE);

}

{

int volumeType;

bool hiddenVolume;

}

{

BootArguments *bootArguments = (BootArguments *) TC_BOOT_LOADER_ARGS_OFFSET;

int incorrectPasswordCount = 0, pim = 0;

}

{

size_t partCount;

}

{

BootArguments *bootArguments = (BootArguments *) TC_BOOT_LOADER_ARGS_OFFSET;

BootCryptoInfo = NULL;

if (!GetSystemPartitions (BootDrive))

if (!InstallInterruptFilters())

goto err;

while (true)

{

EncryptedVirtualPartition.Drive = TC_INVALID_BIOS_DRIVE;

EraseMemory ((void *) TC_BOOT_LOADER_ARGS_OFFSET, sizeof (BootArguments));

GetKeyboardChar (&scanCode);

return scanCode;

}

size_t partitionCount;

size_t bootablePartitionCount = 0;

{

if (GetDrivePartitions (drive, partitions, array_capacity (partitions), partitionCount, false, nullptr, true) == BiosResultSuccess)

{

#ifndef TC_WINDOWS_BOOT_RESCUE_DISK_MODE

{

bool status = false;

#else // TC_WINDOWS_BOOT_RESCUE_DISK_MODE

{

if (!MountVolume (drive, exitKey, false, true))

return;

for (int i = 7; i >= 0; --i)

{

encryptedAreaLength = encryptedAreaLength >> 8;

}

for (i = 3; i >= 0; --i)

{

headerCrc32 >>= 8;

}

sector.HighPart = 0;

ChsAddress chs;

AcquireSectorBuffer();

for (int i = (selection == RestoreVolumeHeader ? TC_BOOT_VOLUME_HEADER_SECTOR : TC_MBR_SECTOR);

Password password;

int pim;

if (exitKey != TC_BIOS_KEY_ENTER)

goto abort;

while (true)

{

InitScreen();

#ifndef TC_WINDOWS_BOOT_RESCUE_DISK_MODE

// Hidden system setup

if (hiddenSystemCreationPhase != TC_HIDDEN_OS_CREATION_PHASE_NONE)

{

#include "TCdefs.h"

#include "Platform.h"

static int AskSelection (const char *options[], size_t optionCount);

static bool AskYesNo (const char *message);

static void BootMenu ();

static void InitScreen ();

static void PrintMainMenu ();

static void RepairMenu ();

static int ReEntryCount = -1;

++ReEntryCount;

#ifdef TC_TRACE_INT13

DisableScreenOutput();

case 0x2: // Read sectors

case 0x3: // Write sectors

{

ChsAddress chs;

chs.Cylinder = ((regs.CX << 2) & 0x300) | (regs.CX >> 8);

chs.Head = regs.DX >> 8;

chs.Sector = regs.CX & 0x3f;

#ifdef TC_TRACE_INT13

PrintVal (": Drive", drive - TC_FIRST_BIOS_DRIVE, false);

case 0x42: // Read sectors LBA

case 0x43: // Write sectors LBA

{

BiosLbaPacket lba;

#ifdef TC_TRACE_INT13

PrintVal (": Drive", drive - TC_FIRST_BIOS_DRIVE, false);

}

else

{

IntRegisters.Flags &= ~TC_X86_CARRY_FLAG;

IntRegisters.EAX = 0x534D4150UL;

#ifdef TC_TRACE_INT15

BiosMemoryMapEntry entry;

PrintHex (entry.Type); PrintChar (' ');

PrintHex (entry.BaseAddress); PrintChar (' ');

PrintHex (entry.Length); PrintChar (' ');

{

r.LowPart >>= 1;

r.LowPart |= 0x80000000UL;

r.HighPart >>= 1;

typedef struct

{

} BootLoaderFingerprintRequest;

typedef struct

{

wchar_t DevicePath[TC_MAX_PATH];

BOOL DriveIsDynamic;

uint16 BootLoaderVersion;

char CustomUserMessage[TC_BOOT_SECTOR_USER_MESSAGE_MAX_LENGTH + 1];

} GetSystemDriveConfigurationRequest;

typedef struct

{

WipeAlgorithmId WipeAlgorithm;

} WipeDecoySystemRequest;

typedef struct

typedef struct

{

LARGE_INTEGER Offset;

} WriteBootDriveSectorRequest;

typedef struct

msg [maxSize - 1] = 0;

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

BootEncryption bootEnc (NULL);

}

catch (SystemException &)

{

return true;

}

{

BOOL bRet = FALSE;

const char* g_szStr1 = "Invalid partition table";

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

const char* g_szStr3 = "Missing operating system";

}

}

{

Elevate();

}

}

{

Elevate();

public:

static void AddReference () { }

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

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

static void Release () { }

static void SetDriverServiceStartType (DWORD startType) { throw ParameterIncorrect (SRC_POS); }

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

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

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

static void UpdateSetupConfigFile (bool bForInstall) { throw ParameterIncorrect (SRC_POS); }

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

};

FileOpen = false;

}

{

DWORD bytesRead;

dwSize = (DWORD) size64;

}

{

DWORD bytesWritten;

return version;

}

{

BootLoaderFingerprintRequest request;

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

}

{

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

device.CheckOpened (SRC_POS);

device.SeekAt (0);

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

continue;

}

return true;

}

}

{

uint32 sum = 0;

}

{

if (bufferSize < TC_BOOT_LOADER_AREA_SIZE - TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE)

throw ParameterIncorrect (SRC_POS);

// Boot sector

DWORD size;

if (!bootSecResourceImg || size != TC_SECTOR_SIZE_BIOS)

throw ParameterIncorrect (SRC_POS);

{

Device device (GetSystemDriveConfiguration().DevicePath);

device.CheckOpened (SRC_POS);

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

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

}

// Decompressor

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

throw ParameterIncorrect (SRC_POS);

memcpy (buffer + TC_SECTOR_SIZE_BIOS, decompressor, size);

// Compressed boot loader

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

throw ParameterIncorrect (SRC_POS);

}

// return false when the user cancel an elevation request

{

bool bCanceled = false, bExceptionOccured = false;

try

}

{

Device device (GetSystemDriveConfiguration().DevicePath);

device.CheckOpened (SRC_POS);

device.SeekAt (0);

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

device.SeekAt (0);

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

device.SeekAt (0);

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

throw ErrorException ("ERROR_MBR_PROTECTED", SRC_POS);

}

{

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

{

}

}

{

if (GetSystemDriveConfiguration().SystemPartition.IsGPT)

{

{

Device device (GetSystemDriveConfiguration().DevicePath);

device.CheckOpened (SRC_POS);

device.SeekAt (0);

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

device.SeekAt (0);

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

device.SeekAt (0);

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

unsigned int BootEncryption::GetHiddenOSCreationPhase ()

{

ReadBootSectorConfig (configFlags, sizeof(configFlags));

#if TC_BOOT_CFG_FLAG_AREA_SIZE != 1

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

#endif

ReadBootSectorConfig (configFlags, sizeof(configFlags));

configFlags[0] |= newPhase;

Device device (GetSystemDriveConfiguration().DevicePath);

device.CheckOpened(SRC_POS);

device.SeekAt (0);

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

# error PRAND_DISK_WIPE_PASSES > RNG_POOL_SIZE

#endif

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

throw ParameterIncorrect (SRC_POS);

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

}

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

if (wipePass == PRAND_DISK_WIPE_PASSES - 1)

if (loaderSize > 32768)

{

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

uint32 varSize = 56;

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

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

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

*(uint32 *)pVar = attr;

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

// Type

// SubType

// HDD dev path length

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

pVar += 16;

// MbrType

// SigType

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

*(uint16 *)pVar = 0x0404;

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

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

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

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

SetFirmwareEnvironmentVariable(varName, EfiVarGuid, startVar, varSize);

wchar_t varName[256];

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

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

if (existingVarLen > 0)

{

if (size1 == size2)

{

// same size, so now we compare content

DWORD remainingBytes = size1, dataToRead;

while (remainingBytes)

return bRet;

}

{

bool bRet = false;

if (existingSize == size)

{

DWORD remainingBytes = size, dataOffset = 0, dataToRead;

while (remainingBytes)

return bRet;

}

wstring path = EfiBootPartPath;

path += name;

f.Close();

}

wstring path = EfiBootPartPath;

path += name;

File f(path, true);

}

DWORD sizeDcsBoot;

#ifdef _WIN64

#else

#endif

if (!dcsBootImg)

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

DWORD sizeDcsInt;

#ifdef _WIN64

#else

#endif

if (!dcsIntImg)

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

DWORD sizeDcsCfg;

#ifdef _WIN64

#else

#endif

if (!dcsCfgImg)

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

DWORD sizeLegacySpeaker;

#ifdef _WIN64

#else

#endif

if (!LegacySpeakerImg)

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

#ifdef VC_EFI_CUSTOM_MODE

DWORD sizeBootMenuLocker;

#ifdef _WIN64

#else

#endif

if (!BootMenuLockerImg)

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

#endif

DWORD sizeDcsInfo;

#ifdef _WIN64

#else

#endif

if (!DcsInfoImg)

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

{

if (loaderSize > 32768)

{

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

// DcsBoot.efi is always smaller than 32KB

if (loaderSize > 32768)

{

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

{

// look for bootmgfw.efi identifiant string

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

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

EfiBootInst.GetFileSize(szStdEfiBootloader, loaderSize);

if (loaderSize > 32768)

{

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

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

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

EfiBootInst.GetFileSize(szStdEfiBootloader, loaderSize);

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

// look for bootmgfw.efi or VeraCrypt identifiant strings

{

try

{

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

// Write MBR

device.SeekAt (0);

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

device.SeekAt (0);

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

device.SeekAt (0);

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

if (config.SystemPartition.IsGPT)

return true;

bool bRet = false;

try

// create EFI disk structure

DWORD sizeDcsBoot;

#ifdef _WIN64

#else

#endif

if (!dcsBootImg)

throw ParameterIncorrect (SRC_POS);

DWORD sizeDcsInt;

#ifdef _WIN64

#else

#endif

if (!dcsIntImg)

throw ParameterIncorrect (SRC_POS);

DWORD sizeDcsCfg;

#ifdef _WIN64

#else

#endif

if (!dcsCfgImg)

throw ParameterIncorrect (SRC_POS);

DWORD sizeLegacySpeaker;

#ifdef _WIN64

#else

#endif

if (!LegacySpeakerImg)

throw ParameterIncorrect (SRC_POS);

#ifdef VC_EFI_CUSTOM_MODE

DWORD sizeBootMenuLocker;

#ifdef _WIN64

#else

#endif

if (!BootMenuLockerImg)

throw ParameterIncorrect (SRC_POS);

#endif

DWORD sizeDcsRescue;

#ifdef _WIN64

#else

#endif

if (!DcsRescueImg)

throw ParameterIncorrect (SRC_POS);

DWORD sizeDcsInfo;

#ifdef _WIN64

#else

#endif

if (!DcsInfoImg)

throw ParameterIncorrect (SRC_POS);

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

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

if (!RescueZipData)

throw bad_alloc();

{

Buffer imageBuf (RescueIsoImageSize);

memset (image, 0, RescueIsoImageSize);

// Primary volume descriptor

// Boot loader backup

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

if (!RescueIsoImage)

throw bad_alloc();

memcpy (RescueIsoImage, image, RescueIsoImageSize);

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

throw ParameterIncorrect (SRC_POS);

mputInt64 (fieldPos, volumeSize);

// CRC of the header fields

device.CheckOpened (SRC_POS);

device.SeekAt (TC_BOOT_VOLUME_HEADER_SECTOR_OFFSET);

}

}

}

unsigned __int64 loaderSize = 0;

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

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

const char* g_szMsBootString = "bootmgfw.pdb";

{

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

device.CheckOpened (SRC_POS);

device.SeekAt (0);

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

const char* g_szMsBootString = "bootmgfw.pdb";

unsigned __int64 loaderSize = 0;

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

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

}

else

{

File backupFile (GetSystemLoaderBackupPath(), true);

backupFile.CheckOpened(SRC_POS);

device.CheckOpened (SRC_POS);

// Preserve current partition table

device.SeekAt (0);

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

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

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

size_t strSize = filter.size() + 1;

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

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

// read initial value

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

Buffer expectedRegKeyBuf(65536), outputRegKeyBuf(65536);

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

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

// remove value in case it was not done properly

Buffer regKeyBuf(65536);

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

// Verify CRC of header salt

Device device(config.DevicePath, true);

device.CheckOpened(SRC_POS);

device.SeekAt(TC_BOOT_VOLUME_HEADER_SECTOR_OFFSET);

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

throw ParameterIncorrect(SRC_POS);

}

}

}

device.SeekAt (headerOffset);

PCRYPTO_INFO cryptoInfo = NULL;

}

device.SeekAt (headerOffset);

headerUpdated = true;

}

try

{

// check if PIM is stored in MBR

if ( ReadBootSectorConfig (nullptr, 0, &userConfig)

&& (userConfig & TC_BOOT_USER_CFG_FLAG_DISABLE_PIM)

)

return configMap;

}

{

WriteBootDriveSectorRequest request;

request.Offset.QuadPart = offset;

bool IsOpened () const { return FileOpen;}

void CheckOpened (const char* srcPos) { if (!FileOpen) { SetLastError (LastError); throw SystemException (srcPos);} }

void Close ();

void SeekAt (int64 position);

void GetFileSize (unsigned __int64& size);

void GetFileSize (DWORD& dwSize);

public:

Buffer (size_t size) : DataSize (size)

{

if (!DataPtr)

throw bad_alloc();

}

~Buffer () { delete[] DataPtr; }

size_t Size () const { return DataSize; }

void Resize (size_t newSize)

{

if (newSize > DataSize)

{

if (!tmp)

throw bad_alloc();

memcpy (tmp, DataPtr, DataSize);

}

protected:

size_t DataSize;

};

struct PartitionEntryMBR

{

uint32 StartLBA;

uint32 SectorCountLBA;

struct MBR

{

PartitionEntryMBR Partitions[4];

uint16 Signature;

};

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

void SetStartExec(wstring description, wstring execPath, bool setBootEntry = true, bool forceFirstBootEntry = true, bool setBootNext = true, uint16 statrtOrderNum = 0xDC5B, wchar_t* type = NULL, uint32 attr = 1);

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

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

bool FileExists(const wchar_t* name);

static bool CompareFiles (const wchar_t* fileName1, const wchar_t* fileName2);

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

BOOL DelFile(const wchar_t* name);

DWORD GetDriverServiceStartType ();

unsigned int GetHiddenOSCreationPhase ();

uint16 GetInstalledBootLoaderVersion ();

Partition GetPartitionForHiddenOS ();

bool IsBootLoaderOnDrive (wchar_t *devicePath);

BootEncryptionStatus GetStatus ();

void PrepareHiddenOSCreation (int ea, int mode, int pkcs5);

void PrepareInstallation (bool systemPartitionOnly, Password &password, int ea, int mode, int pkcs5, int pim, const wstring &rescueIsoImagePath);

void ProbeRealSystemDriveSize ();

uint32 ReadDriverConfigurationFlags ();

uint32 ReadServiceConfigurationFlags ();

void RegisterBootDriver (bool hiddenSystem);

void StartDecryption (BOOL discardUnreadableEncryptedSectors);

void StartDecoyOSWipe (WipeAlgorithmId wipeAlgorithm);

void StartEncryption (WipeAlgorithmId wipeAlgorithm, bool zeroUnreadableSectors);

bool SystemDriveContainsExtendedPartition ();

bool SystemDriveContainsNonStandardPartitions ();

bool SystemPartitionCoversWholeDrive ();

bool VerifyRescueDisk ();

bool VerifyRescueDiskImage (const wchar_t* imageFile);

void WipeHiddenOSCreationConfig ();

void WriteLocalMachineRegistryDwordValue (wchar_t *keyPath, wchar_t *valueName, DWORD value);

void GetEfiBootDeviceNumber (PSTORAGE_DEVICE_NUMBER pSdn);

void BackupSystemLoader ();

protected:

static const uint32 RescueIsoImageSize = 1835008; // Size of ISO9660 image with bootable emulated 1.44MB floppy disk image

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

wstring GetSystemLoaderBackupPath ();

DISK_GEOMETRY_EX GetDriveGeometry (int driveNumber);

PartitionList GetDrivePartitions (int driveNumber);

wstring GetRemarksOnHiddenOS ();

int SelectedEncryptionAlgorithmId;

int SelectedPrfAlgorithmId;

Partition HiddenOSCandidatePartition;

unsigned long RescueZipSize;

bool DriveConfigValid;

bool RealSystemDriveSizeValid;

bool RescueVolumeHeaderValid;

clear();

}

{

m_nc = 0;

m_ne = 0;

{

// case 2s

// 256 is encoded as 0x00

m_apdu.resize(5, 0);

setHeader(cla, ins, p1, p2);

m_apdu[4] = len;

else

{

// case 2e

// 65536 is encoded as 0x00 0x00

if (m_ne == 65536)

{

}

else

{

}

m_apdu.resize(7, 0);

setHeader(cla, ins, p1, p2);

// case 3s

m_apdu.resize(4 + 1 + dataLength, 0);

setHeader(cla, ins, p1, p2);

m_dataOffset = 5;

memcpy(m_apdu.data() + 5, data + dataOffset, dataLength);

}

m_apdu.resize(4 + 3 + dataLength, 0);

setHeader(cla, ins, p1, p2);

m_apdu[4] = 0;

m_dataOffset = 7;

memcpy(m_apdu.data() + 7, data + dataOffset, dataLength);

m_isExtendedAPDU = true;

// case 4s

m_apdu.resize(4 + 2 + dataLength, 0);

setHeader(cla, ins, p1, p2);

m_dataOffset = 5;

memcpy(m_apdu.data() + 5, data + dataOffset, dataLength);

}

else

{

m_apdu.resize(4 + 5 + dataLength, 0);

setHeader(cla, ins, p1, p2);

m_apdu[4] = 0;

m_dataOffset = 7;

memcpy(m_apdu.data() + 7, data + dataOffset, dataLength);

if (ne != 65536)

{

size_t leOfs = m_apdu.size() - 2;

} // else le == 65536: no need to fill in, encoded as 0

m_isExtendedAPDU = true;

}

m_parsedSuccessfully = true;

}

{

}

void CommandAPDU::clear()

m_dataOffset = 0;

}

{

init(cla, ins, p1, p2, data, dataOffset, dataLength, ne);

}

{

init(cla, ins, p1, p2, NULL, 0, 0, 0);

}

{

init(cla, ins, p1, p2, NULL, 0, 0, ne);

}

{

init(cla, ins, p1, p2, data.data(), 0, (uint32)data.size(), 0);

}

{

init(cla, ins, p1, p2, data, dataOffset, dataLength, 0);

}

{

init(cla, ins, p1, p2, data.data(), 0, (uint32)data.size(), ne);

}

{

m_apdu = apdu;

parse();

}

{

return m_apdu[0] & 0xff;

}

{

return m_apdu[1] & 0xff;

}

{

return m_apdu[2] & 0xff;

}

{

return m_apdu[3] & 0xff;

}

return m_nc;

}

{

if (m_nc > 0)

{

return m_ne;

}

{

return m_apdu;

}

{

protected:

uint32 m_nc;

uint32 m_ne;

uint32 m_dataOffset;

bool m_parsedSuccessfully;

void parse();

public:

CommandAPDU();

uint32 getNc();

uint32 getNe();

bool isValid();

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

{

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

KFLOATING_SAVE floatingPointState;

#endif

case AES:

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

if (IsAesHwCpuSupported())

else

#endif

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

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

{

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

KFLOATING_SAVE floatingPointState;

#endif

{

while (blockCount > 0)

{

data += 32 * 16;

blockCount -= 32;

#ifdef TC_WINDOWS_BOOT

CRYPTO_INFO CryptoInfoBuffer;

#endif

{

#ifdef TC_WINDOWS_BOOT_AES

if (IsAesHwCpuSupported())

else

aes_encrypt (data, data, ks);

#elif defined (TC_WINDOWS_BOOT_SERPENT) && !defined (WOLFCRYPT_BACKEND)

{

#ifdef TC_WINDOWS_BOOT_AES

if (IsAesHwCpuSupported())

else

#elif defined (TC_WINDOWS_BOOT_SERPENT) && !defined (WOLFCRYPT_BACKEND)

serpent_decrypt (data, data, ks);

#elif defined (TC_WINDOWS_BOOT_TWOFISH) && !defined (WOLFCRYPT_BACKEND)

}

/* masking for random index to remove bias */

{

if (count >= 128)

return 0xFF;

return 1;

}

{

while (TRUE)

{

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

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

static ULONG cbKeyDerivationArea = 0;

static uint64 HashSeedMask = 0;

BOOL InitializeSecurityParameters(GetRandSeedFn rngCallback)

{

ChaCha20RngCtx ctx;

#ifdef TC_WINDOWS_DRIVER

char randomStr[4];

Dump ("InitializeSecurityParameters BEGIN\n");

#endif

cbKeyDerivationArea = 1024 * 1024;

do

{

if (!pbKeyDerivationArea)

cbKeyDerivationArea >>= 1;

} while (!pbKeyDerivationArea && (cbKeyDerivationArea >= (2*PAGE_SIZE)));

#if defined(_M_ARM64) || defined(__arm__) || defined (__arm64__) || defined (__aarch64__)

/* dummy implementation that should never be called */

{

ks = ks;

data = data;

}

{

ks = ks;

data = data;

}

{

ks = ks;

data = data;

}

{

ks = ks;

data = data;

static BOOL IsReturnAddress (DWORD64 address)

{

static size_t codeEnd = 0;

if (codeEnd == 0)

{

MEMORY_BASIC_INFORMATION mi;

VirtualQuery (sp, &mi, sizeof (mi));

int i = 0;

while (retAddrs.size() < 16 && &sp[i] < stackTop)

return result;

}

{

bool bRet = true;

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

else if (c >= L'a' && c <= L'z')

else if (c >= L'A' && c <= L'Z')

else

bRet = false;

return bRet;

}

{

size_t i, len = wcslen (hexStr);

arr.clear();

if ((path.length () >= 3) && (_wcsnicmp (path.c_str(), L"ID:", 3) == 0))

{

if ( (path.length() == (3 + 2*VOLUME_ID_SIZE))

&& HexWideStringToArray (path.c_str() + 3, arr)

&& (arr.size() == VOLUME_ID_SIZE)

if ((wcslen (volname) == (3 + 2*VOLUME_ID_SIZE)) && _wcsnicmp (volname, L"ID:", 3) == 0)

{

/* Volume ID specified. Use it for matching mounted volumes. */

if (HexWideStringToArray (&volname[3], arr) && (arr.size() == VOLUME_ID_SIZE))

{

return IsMountedVolumeID (&arr[0]);

// Read volume header

DWORD bytesRead;

{

status = ERR_OS_ERROR;

goto error;

if (BrowseFiles (hwndDlg, "SELECT_KEYFILE", keyfilePath, bHistory, FALSE))

{

DWORD keyfileSize;

if (!keyfileData)

{

handleWin32Error (hwndDlg, SRC_POS);

if (DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_NEW_TOKEN_KEYFILE), hwndDlg, (DLGPROC) NewSecurityTokenKeyfileDlgProc, (LPARAM) &newParams) == IDOK)

{

memcpy (&keyfileDataVector.front(), keyfileData, keyfileSize);

try

WaitCursor();

finally_do ({ NormalCursor(); });

keyfile->GetKeyfileData (keyfileData);

return 1;

}

if (!SaveBufferToFile ((char *) &keyfileData.front(), keyfilePath, (DWORD) keyfileData.size(), FALSE, FALSE))

throw SystemException (SRC_POS);

ShellExecuteW (NULL, (!IsAdmin() && IsUacSupported()) ? L"runas" : L"open", cmdPath, param, NULL, SW_SHOW);

}

{

if (bufferSize < patternSize)

return FALSE;

}

{

}

{

}

"[veracrypt_reg]\r\n"

"HKR,,\"" + filterReg + "\",0x0001" + string (registerFilter ? "0008" : "8002") + ",\"" + filter + "\"\r\n";

infFile.Close();

HINF hInf = SetupOpenInfFileW (infFileName.c_str(), NULL, INF_STYLE_OLDNT | INF_STYLE_WIN4, NULL);

ChangeWindowMessageFilter (msg, MSGFLT_ADD);

}

{

if (buffer && bufferSize)

{

size_t pathLen = pathValue? wcslen (pathValue) : 0;

if ((pathLen >= 3) && (_wcsnicmp (pathValue, L"ID:", 3) == 0))

{

if ( (pathLen == (3 + 2*VOLUME_ID_SIZE))

&& HexWideStringToArray (pathValue + 3, arr)

&& (arr.size() == VOLUME_ID_SIZE)

{

LARGE_INTEGER iSeed;

SYSTEMTIME sysTime;

WHIRLPOOL_CTX tctx;

size_t count;

BOOL FileHasReadOnlyAttribute (const wchar_t *path);

BOOL IsFileOnReadOnlyFilesystem (const wchar_t *path);

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

int AskNonSysInPlaceEncryptionResume (HWND hwndDlg, BOOL* pbDecrypt);

BOOL RemoveDeviceWriteProtection (HWND hwndDlg, wchar_t *devicePath);

void EnableElevatedCursorChange (HWND parent);

HRESULT VCStrDupW(LPCWSTR psz, LPWSTR *ppwsz);

void ProcessEntropyEstimate (HWND hProgress, DWORD* pdwInitialValue, DWORD dwCounter, DWORD dwMaxLevel, DWORD* pdwEntropy);

void AllowMessageInUIPI (UINT msg);

BOOL TranslateVolumeID (HWND hwndDlg, wchar_t* pathValue, size_t cchPathValue);

BOOL CopyTextToClipboard (const wchar_t* txtValue);

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

std::wstring GetUserFriendlyVersionString (int version);

std::wstring IntToWideString (int val);

std::wstring ArrayToHexWideString (const unsigned char* pbData, int cbData);

std::wstring FindDeviceByVolumeID (const BYTE volumeID [VOLUME_ID_SIZE], BOOL bFromService);

void RegisterDriverInf (bool registerFilter, const std::string& filter, const std::string& filterReg, HWND ParentWindow, HKEY regKey);

std::wstring GetTempPathString ();

}

#endif

{

return supportedAIDs;

}

EMVCard::EMVCard() : SCard(), m_lastPANDigits(L"")

{

m_lastPANDigits.clear();

}

{

bool hasBeenReset = false;

CommandAPDU command;

ResponseAPDU response;

shared_ptr<TLVNode> rootNode;

shared_ptr<TLVNode> fciNode;

shared_ptr<TLVNode> dfNameNode;

vector<shared_ptr<TLVNode>> pseDirectoryNodes;

unsigned char sfi;

bool usingContactless = false;

if (m_aid.size())

return m_aid;

{

sfi = sfiNode->Value->at(0);

do

{

command = CommandAPDU(CLA_ISO7816, INS_READ_RECORD, rec++, (sfi << 3) | 4, SCardReader::shortAPDUMaxTransSize);

return tokenAID;

}

{

bool hasBeenReset = false;

bool aidSelected = false;

bool iccFound = false;

bool issuerFound = false;

bool cplcFound = false;

shared_ptr<TLVNode> rootNode;

shared_ptr<TLVNode> iccPublicKeyCertNode;

shared_ptr<TLVNode> issuerPublicKeyCertNode;

CommandAPDU command;

ResponseAPDU response;

iccCert.clear();

issuerCert.clear();

// TODO: Send GET PROCESSING OPTIONS to get the AIL and AFL,

// which will then be used to get the actual start and end of sfi and rec.

{

{

command = CommandAPDU(CLA_ISO7816, INS_READ_RECORD, rec, (sfi << 3) | 4, SCardReader::shortAPDUMaxTransSize);

m_reader->ApduProcessData(command, response);

bool hasBeenReset = false;

bool panFound = false;

bool aidSelected = false;

shared_ptr<TLVNode> rootNode;

shared_ptr<TLVNode> panNode;

CommandAPDU command;

ResponseAPDU response;

lastPANDigits = L"";

// TODO: Send GET PROCESSING OPTIONS to get the AIL and AFL,

// which will then be used to get the actual start and end of sfi and rec.

{

{

command = CommandAPDU(CLA_ISO7816, INS_READ_RECORD, rec, (sfi << 3) | 4, SCardReader::shortAPDUMaxTransSize);

m_reader->ApduProcessData(command, response);

{

panFound = true;

panData = *panNode->Value.get();

std::swap(panData[0], panData[1]);

lastPANDigits = ArrayToHexWideString(panData.data(), (int) panData.size());

}

// After the card has been read, and if some or all fields cannot be read, the EMVCard

// object will be considered invalid and will not be included in the list of available cards

// of EMVToken.

wstring m_lastPANDigits;

public:

// Add other AIDS

// https://gist.github.com/pvieito/6224eed92c99b069f6401996c548d0e4

// https://ambimat.com/developer-resources/list-of-application-identifiers-aid/

EMVCard();

EMVCard(size_t slotId);

// Retrieves the card's AID.

// It first checks the card against a list of supported AIDs.

// If that fails, it tries getting the AID from the card using PSE

void GetCardPAN(wstring& lastPANDigits);

};

}

namespace VeraCrypt

{

{

if (cbData > 0 && from <= cbData - 2 && length > 0 && length <= cbData - from)

{

return path.str();

}

{

map <unsigned long int, shared_ptr<EMVCard>>::iterator emvCardsIt;

shared_ptr<EMVCard> card;

bool addNewCard = true;

keyfileData.clear();

virtual ~EMVTokenKeyfile() {};

virtual operator TokenKeyfilePath () const;

};

class EMVToken

static vector<EMVTokenKeyfile> GetAvailableKeyfiles(unsigned long int* slotIdFilter = nullptr, const wstring& keyfileIdFilter = wstring());

static EMVTokenInfo GetTokenInfo(unsigned long int slotId);

static map <unsigned long int, shared_ptr<EMVCard>> EMVCards;

};

struct

{

PCRYPTO_INFO CryptoInfo;

UINT64_STRUCT StartUnitNo;

uint32 UnitCount;

}

{

uint32 fragmentCount;

uint32 unitsPerFragment;

uint32 remainder;

uint64 fragmentStartUnitNo;

EncryptionThreadPoolWorkItem *workItem;

void EncryptionThreadPoolBeginKeyDerivation (TC_EVENT *completionEvent, TC_EVENT *noOutstandingWorkItemEvent, LONG *completionFlag, LONG *outstandingWorkItemCount, int pkcs5Prf, char *password, int passwordLength, char *salt, int iterationCount, char *derivedKey);

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

BOOL EncryptionThreadPoolStart (size_t encryptionFreeCpuCount);

void EncryptionThreadPoolStop ();

size_t GetEncryptionThreadCount ();

typedef struct fatparams_t

{

char volume_name[11];

unsigned int num_sectors; /* total number of sectors */

int cluster_count; /* number of clusters */

int size_root_dir; /* size of the root directory in bytes */

// To prevent fragmentation, write zeroes to reserved header sectors which are going to be filled with random data

if (!volParams->bDevice && !volParams->hiddenVol)

{

DWORD bytesWritten;

ZeroMemory (buf, sizeof (buf));

static volatile BOOL WriteThreadExitRequested;

static HANDLE WriteThreadHandle;

static HANDLE WriteBufferEmptyEvent;

static HANDLE WriteBufferFullEvent;

if (Token::IsKeyfilePathValid (kf->FileName, EMVSupportEnabled? true : false))

{

// Apply security token keyfile

TokenKeyfilePath secPath (kf->FileName);

Token::getTokenKeyfile (secPath)->GetKeyfileData (keyfileData);

namespace VeraCrypt

{

{

uint16 value = 0;

for (uint16 i = 0; i < buff.size(); i++)

return value;

}

{

size_t orgSize = buffer.size ();

buffer.resize (orgSize + cbData);

{

}

{

m_data = data;

m_SW = SW;

return (uint32)m_data.size();

}

{

return m_data;

}

{

}

{

}

uint16 ResponseAPDU::getSW()

return m_SW;

}

{

AppendData(apdu, m_data.data(), m_data.size());

return apdu;

}

{

appendData(data.data(), data.size());

}

{

AppendData(m_data, data, dataLen);

}

m_SW = SW;

}

{

clear();

if (bytes.size() >= 2)

{

m_data.resize(bytes.size() - 2);

SWBytes.resize(2);

{

protected:

uint16 m_SW;

ResponseAPDU();

uint32 getNr();

uint16 getSW();

void setSW(uint16 SW);

};

};

#include <PCSC/wintypes.h>

#include "reader.h"

typedef LPSCARD_READERSTATE_A LPSCARD_READERSTATE;

#define BOOL int

#else

#undef BOOL

#include <winscard.h>

#include <wintypes.h>

#include <reader.h>

#define BOOL int

#endif

#endif

return name;

}

{

LONG lRet = SCARD_S_SUCCESS;

SCARD_READERSTATE state;

bool SCardReader::IsCardPresent()

{

return IsCardPresent(dummy);

}

size_t indexOfLe = 0;

size_t indexOfLcData = 0;

DWORD cbSendLength = 0;

DWORD cbRecvLength = 0;

// 256 is encoded as 0x00

pbSendBuffer[4] = (BYTE)ne;

indexOfLe = 4;

}

else

{

// case 3s

pbSendBuffer[4] = (BYTE)nc;

indexOfLcData = 5;

memcpy(&pbSendBuffer[indexOfLcData], commandAPDU.getData().data(), nc);

}

else

// case 4s

pbSendBuffer[4] = (BYTE)nc;

indexOfLcData = 5;

memcpy(&pbSendBuffer[indexOfLcData], commandAPDU.getData().data(), nc);

pbSendBuffer[indexOfLcData + nc] = (ne != 256) ? (BYTE)ne : 0;

indexOfLe = indexOfLcData + nc;

throw PCSCException(lRet);

}

{

DWORD cByte = 0;

LONG lRet = 0;

/* ================================================================================================ */

/* CLA values */

/* ================================================================================================ */

/* ================================================================================================ */

/* INS values */

/* ================================================================================================ */

/* ================================================================================================ */

/* EMV values */

const uint16 EMV_CPLC_TAG = (uint16)0x9F7F;

const uint16 EMV_ICC_PK_CERT_TAG = (uint16)0x9F46;

const uint16 EMV_FCI_ISSUER_DISCRETIONARY_DATA_TAG = (uint16)0xBF0C;

/* ================================================================================================ */

// Card Connection management methods

// ------------------------------------------------------------------------------------------------------------------------------------- //

bool IsCardPresent();

LONG CardHandleStatus();

void ApduProcessData(CommandAPDU commandAPDU, ResponseAPDU& responseAPDU) const;

};

};

Sessions.erase(Sessions.find(slotId));

}

{

if (name.empty())

throw ParameterIncorrect(SRC_POS);

throw Pkcs11Exception(status);

// Some tokens report success even if the new object was truncated to fit in the available memory

GetObjectAttribute(slotId, keyfileHandle, CKA_VALUE, objectData);

if (objectData.size() != keyfileData.size())

{

keyfile.Token->SlotId = slotId;

keyfile.Token = shared_ptr<SecurityTokenInfo>(new SecurityTokenInfo(token));

GetObjectAttribute(slotId, dataHandle, CKA_PRIVATE, privateAttrib);

if (privateAttrib.size() == sizeof(CK_BBOOL) && *(CK_BBOOL*)&privateAttrib.front() != CK_TRUE)

continue;

GetObjectAttribute(slotId, dataHandle, CKA_LABEL, label);

label.push_back(0);

return token;

}

{

SecurityToken::LoginUserIfRequired(Token->SlotId);

SecurityToken::GetObjectAttribute(Token->SlotId, Handle, CKA_VALUE, keyfileData);

return objects;

}

{

attributeValue.clear();

if (attribute.ulValueLen == 0)

return;

attribute.pValue = &attributeValue.front();

status = Pkcs11Functions->C_GetAttributeValue(Sessions[slotId].Handle, tokenObject, &attribute, 1);

operator TokenKeyfilePath () const;

string IdUtf8;

CK_OBJECT_HANDLE Handle;

public:

static void CloseAllSessions() throw ();

static void CloseLibrary();

static void DeleteKeyfile(const SecurityTokenKeyfile& keyfile);

static vector <SecurityTokenKeyfile> GetAvailableKeyfiles(CK_SLOT_ID* slotIdFilter = nullptr, const wstring keyfileIdFilter = wstring());

static list <SecurityTokenInfo> GetAvailableTokens();

protected:

static void CloseSession(CK_SLOT_ID slotId);

static vector <CK_OBJECT_HANDLE> GetObjects(CK_SLOT_ID slotId, CK_ATTRIBUTE_TYPE objectClass);

static list <CK_SLOT_ID> GetTokenSlots();

static void Login(CK_SLOT_ID slotId, const char* pin);

static void LoginUserIfRequired(CK_SLOT_ID slotId);

static map <CK_SLOT_ID, Pkcs11Session> Sessions;

static unique_ptr <SendExceptionFunctor> WarningCallback;

};

}

}

/* Check if the bit is correct */

{

unsigned char bitvalue[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};

}

/* Parsing one TLV node */

{

size_t index = 0;

size_t i = 0;

shared_ptr<TLVNode> node = TLV_CreateNode();

tag1 = tag2 = 0;

}

/* Parsing TLV from a buffer and constructing TLV structure */

{

shared_ptr<TLVNode> node = TLV_Parse_One(buf, size);

TLV_Parse_Sub(node);

{

uint16 Tag; /* T */

uint16 Length; /* L */

uint16 MoreFlag; /* Used In Sub */

uint16 SubFlag; /* Does it have sub-nodes? */

shared_ptr<vector<shared_ptr<TLVNode>>> Subs;

TLVNode() : Tag(0), Length(0), TagSize(0), LengthSize(0), MoreFlag(0), SubFlag(0)

{

Subs = make_shared<vector<shared_ptr<TLVNode>>>();

}

static shared_ptr<TLVNode> TLV_CreateNode();

/* Check if the bit is correct */

/* Parsing one TLV node */

/* Parsing all TLV nodes */

static int TLV_Parse_SubNodes(shared_ptr<TLVNode> parent);

public:

/* Parsing TLV from a buffer and constructing TLV structure */

/* Finding a TLV node with a particular tag */

static shared_ptr<TLVNode> TLV_Find(shared_ptr<TLVNode> node, uint16 tag);

typedef __int8 int8;

typedef __int16 int16;

typedef __int32 int32;

typedef unsigned __int8 uint8;

typedef unsigned __int16 uint16;

typedef unsigned __int32 uint32;

typedef int16_t int16;

typedef int32_t int32;

typedef int64_t int64;

typedef uint8_t uint8;

typedef uint16_t uint16;

typedef uint32_t uint32;

// AES EncipherBlocks()/DecipherBlocks()

{

uint32 origCrc;

size_t i;

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

{

}

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

{

virtual ~TokenKeyfile() {}

virtual operator TokenKeyfilePath () const = 0;

shared_ptr<TokenInfo> Token;

wstring Id;

{

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

}

{

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

}

{

UINT64_STRUCT uint64Struct;

}

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

{

// compute Whirlpool+SHA512 fingerprint of bootloader including MBR

// we skip user configuration fields:

}

#if !defined(_UEFI)

{

#if TC_VOLUME_HEADER_EFFECTIVE_SIZE > TC_MAX_VOLUME_SECTOR_SIZE

#error TC_VOLUME_HEADER_EFFECTIVE_SIZE > TC_MAX_VOLUME_SECTOR_SIZE

#endif

DISK_GEOMETRY geometry;

if (!device)

}

{

#if TC_VOLUME_HEADER_EFFECTIVE_SIZE > TC_MAX_VOLUME_SECTOR_SIZE

#error TC_VOLUME_HEADER_EFFECTIVE_SIZE > TC_MAX_VOLUME_SECTOR_SIZE

#endif

DWORD bytesDone;

DISK_GEOMETRY geometry;

char temporaryKey[MASTER_KEYDATA_SIZE];

char originalK2[MASTER_KEYDATA_SIZE];

LARGE_INTEGER offset;

int nStatus = ERR_SUCCESS;

extern BOOL ReadVolumeHeaderRecoveryMode;

#if defined(TC_WINDOWS_BOOT)

int ReadVolumeHeader (BOOL bBoot, char *encryptedHeader, Password *password, int pim, PCRYPTO_INFO *retInfo, CRYPTO_INFO *retHeaderCryptoInfo);

#elif defined(_UEFI)

#else

int ReadVolumeHeader (BOOL bBoot, char *encryptedHeader, Password *password, int pkcs5_prf, int pim, PCRYPTO_INFO *retInfo, CRYPTO_INFO *retHeaderCryptoInfo);

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

#endif

#endif

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

int CreateVolumeHeaderInMemory (HWND hwndDlg, BOOL bBoot, char *encryptedHeader, int ea, int mode, Password *password, 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);

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

#endif

#include "Wipe.h"

{

return FALSE;

}

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

{

switch (pass)

{

}

{

switch (pass)

{

// Fill the buffer with wipe patterns defined in the paper "Secure Deletion of Data from Magnetic and Solid-State Memory" by Peter Gutmann.

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

{

int wipePat3Pos;

size_t i;

}

{

switch (algorithm)

{

#define TC_WIPE_RAND_CHAR_COUNT 3

int GetWipePassCount (WipeAlgorithmId algorithm);

#ifdef __cplusplus

}

outerVolume->ReadSectors (bootSectorBuffer, 0);

int fatType;

if (memcmp (bootSector + 54, "FAT12", 5) == 0)

fatType = 12;

}

}

{

int cnt = 0;

/* FAT32 FSInfo */

{

memset (sector, 0, ft->sector_size);

sector[3] = 0x41; /* LeadSig */

sector.Zero();

uint32 volumeId;

writeSector (sector); ++sectorNumber;

/* fat32 boot area */

if (ft->size_fat == 32)

{

/* fsinfo */

writeSector (sector); ++sectorNumber;

/* reserved */

/* bootsector backup */

sector.Zero();

writeSector (sector); ++sectorNumber;

writeSector (sector); ++sectorNumber;

}

if (n == 0)

{

if (ft->size_fat == 32)

{

fat_sig[1] = fat_sig[2] = 0xff;

fat_sig[3] = 0x0f;

fat_sig[4] = fat_sig[5] = fat_sig[6] = 0xff;

}

else if (ft->size_fat == 16)

{

fat_sig[1] = 0xff;

fat_sig[2] = 0xff;

fat_sig[3] = 0xff;

}

else if (ft->size_fat == 12)

{

fat_sig[1] = 0xff;

fat_sig[2] = 0xff;

fat_sig[3] = 0x00;

ScopeLock lock (AccessMutex);

size_t bufferLen = buffer.Size(), loopLen;

// Initialize JitterEntropy RNG for this call

if (0 == jent_entropy_init ())

Buffer buffer (1);

for (size_t i = 0; i < PoolSize * 10; ++i)

{

AddToPool (buffer);

}

// Wait for sync code

while (true)

{

throw_sys_if (read (STDIN_FILENO, &b, 1) != 1);

if (b != 0x00)

continue;

try

{

deserializedObject.reset (Serializable::DeserializeNew (stream));

deserializedException = dynamic_cast <Exception*> (deserializedObject.get());

}

ServiceOutputStream = shared_ptr <Stream> (new FileStream (outPipe->GetReadFD()));

// Send sync code

ServiceInputStream->Write (ConstBufferPtr (sync, array_capacity (sync)));

AdminInputPipe = move_ptr(inPipe);

device.SeekAt (0);

device.ReadCompleteBuffer (bootSector);

return memcmp (b + 3, "NTFS", 4) != 0

&& memcmp (b + 54, "FAT", 3) != 0

dmCreateArgs << nativeDevPath << " 0";

SecureBuffer dmCreateArgsBuf (dmCreateArgs.str().size());

// Keys

const SecureBuffer &cipherKey = cipher.GetKey();

#endif

#if defined (TC_WINDOWS_BOOT)

#endif

void aes_hw_cpu_enable_sse ();

#if defined(__cplusplus)

}

* NTT (Nippon Telegraph and Telephone Corporation) . All rights reserved.

*

* SuperCop integration:

*

* VeraCrypt integration:

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

extern int IsAesHwCpuSupported ();

#endif

/* key constants */

camellia_decrypt_asm (ks, outBlock, inBlock);

}

{

#if !defined (_UEFI)

if ((blockCount >= 16) && IsCpuIntel() && IsAesHwCpuSupported () && HasSAVX()) /* on AMD cpu, AVX is too slow */

camellia_encrypt (in_blk, out_blk, instance);

}

{

#if !defined (_UEFI)

if ((blockCount >= 16) && IsCpuIntel() && IsAesHwCpuSupported () && HasSAVX()) /* on AMD cpu, AVX is too slow */

void camellia_decrypt(const unsigned __int8 *inBlock, unsigned __int8 *outBlock, unsigned __int8 *ks);

#if CRYPTOPP_BOOL_X64 && !defined(CRYPTOPP_DISABLE_ASM)

#endif

#ifdef __cplusplus

#if defined(__GNUC__)

#if CRYPTOPP_BOOL_X64

#endif

__asm__ __volatile__

(

#pragma optimize ("tl", on)

typedef unsigned __int32 uint32;

#include <stdlib.h>

#pragma intrinsic(_lrotr)

memcpy((CTX->hash), (CTX->h), 8 * sizeof(unsigned long long));

}

{

size_t chunksize;

}

}

{

stage3(CTX);

void STREEBOG_init(STREEBOG_CTX *ctx);

void STREEBOG_init256(STREEBOG_CTX *ctx);

#ifdef __cplusplus

}

#if CRYPTOPP_BOOL_X64 && !defined(CRYPTOPP_DISABLE_ASM)

/* these are 64-bit assembly implementation taken from https://github.com/jkivilin/supercop-blockciphers

*/

#if defined(__cplusplus)

extern "C"

{

#endif

#if defined(__cplusplus)

}

#endif

{

while (blockCount >= 3)

{

}

{

while (blockCount >= 3)

{

#endif

{

0xa9, 0x67, 0xb3, 0xe8, 0x04, 0xfd, 0xa3, 0x76, 0x9a, 0x92, 0x80, 0x78, 0xe4, 0xdd, 0xd1, 0x38,

0x0d, 0xc6, 0x35, 0x98, 0x18, 0xf7, 0xec, 0x6c, 0x43, 0x75, 0x37, 0x26, 0xfa, 0x13, 0x94, 0x48,

void twofish_set_key(TwofishInstance *instance, const u4byte in_key[])

{

union {

uint32 S32[4];

} us;

unsigned int i;

us.S32[0] = RS[0][key[0]] ^ RS[1][key[1]] ^ RS[2][key[2]] ^ RS[3][key[3]] ^ RS[4][key[4]] ^ RS[5][key[5]] ^ RS[6][key[6]] ^ RS[7][key[7]];

us.S32[1] = RS[0][key[8]] ^ RS[1][key[9]] ^ RS[2][key[10]] ^ RS[3][key[11]] ^ RS[4][key[12]] ^ RS[5][key[13]] ^ RS[6][key[14]] ^ RS[7][key[15]];

/* in_key must be 32-bytes long */

void twofish_set_key(TwofishInstance *instance, const u4byte in_key[]);

#if CRYPTOPP_BOOL_X64 && !defined(CRYPTOPP_DISABLE_ASM)

#else

void twofish_encrypt(TwofishInstance *instance, const u4byte in_blk[4], u4byte out_blk[4]);

void twofish_decrypt(TwofishInstance *instance, const u4byte in_blk[4], u4byte out_blk[4]);

else

{

uint64* dataBuf = ctx->data;

num = oldCountLo & 63;

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

unsigned int num = ctx->countLo & 63;

uint64* dataBuf = ctx->data;

uint64* stateBuf = ctx->state;

data[num++] = 0x80;

if (num <= 32)

#endif

#endif

#define U32V(v) (v)

#define ROTL32(x,n) rotl32(x, n)

#define GETBYTE(x, y) (unsigned int)((unsigned char)((x)>>(8*(y))))

// these may be faster on other CPUs/compilers

// #define GETBYTE(x, y) (unsigned int)(((x)>>(8*(y)))&255)

#endif

#endif

#if CRYPTOPP_BOOL_SSE2_INTRINSICS_AVAILABLE

#endif

//#define CPPCRYPTO_DEBUG

252, 238, 221, 17, 207, 110, 49, 22, 251, 196, 250, 218, 35, 197, 4, 77, 233, 119, 240, 219, 147, 46, 153, 186, 23, 54, 241, 187, 20, 205, 95, 193,

249, 24, 101, 90, 226, 92, 239, 33, 129, 28, 60, 66, 139, 1, 142, 79, 5, 132, 2, 174, 227, 106, 143, 160, 6, 11, 237, 152, 127, 212, 211, 31,

235, 52, 44, 81, 234, 200, 72, 171, 242, 42, 104, 162, 253, 58, 206, 204, 181, 112, 14, 86, 8, 12, 118, 18, 191, 114, 19, 71, 156, 183, 93, 135,

32, 113, 103, 164, 45, 43, 9, 91, 203, 155, 37, 208, 190, 229, 108, 82, 89, 166, 116, 210, 230, 244, 180, 192, 209, 102, 175, 194, 57, 75, 99, 182

};

165, 45, 50, 143, 14, 48, 56, 192, 84, 230, 158, 57, 85, 126, 82, 145, 100, 3, 87, 90, 28, 96, 7, 24, 33, 114, 168, 209, 41, 198, 164, 63,

224, 39, 141, 12, 130, 234, 174, 180, 154, 99, 73, 229, 66, 228, 21, 183, 200, 6, 112, 157, 65, 117, 25, 201, 170, 252, 77, 191, 42, 115, 132, 213,

195, 175, 43, 134, 167, 177, 178, 91, 70, 211, 159, 253, 212, 15, 156, 47, 155, 67, 239, 217, 121, 182, 83, 127, 193, 240, 35, 231, 37, 94, 181, 30,

};

#define LS(x1,x2,t1,t2) { \

}

#define ILS(x1,x2,t1,t2) { \

}

#define ILSS(x1,x2,t1,t2) { \

}

#define ISI(val) { \

} \

}

{

#if CRYPTOPP_BOOL_SSE2_INTRINSICS_AVAILABLE && !defined(_UEFI) && (!defined (TC_WINDOWS_DRIVER) || (!defined (DEBUG) && defined (_WIN64)))

if(HasSSE2())

}

{

#if CRYPTOPP_BOOL_SSE2_INTRINSICS_AVAILABLE && !defined(_UEFI) && (!defined (TC_WINDOWS_DRIVER) || (!defined (DEBUG) && defined (_WIN64)))

if(HasSSE2())

}

}

{

#if CRYPTOPP_BOOL_SSE2_INTRINSICS_AVAILABLE && !defined(_UEFI) && (!defined (DEBUG) || !defined (TC_WINDOWS_DRIVER))

if(HasSSE2())

}

}

{

#if CRYPTOPP_BOOL_SSE2_INTRINSICS_AVAILABLE && !defined(_UEFI) && (!defined (TC_WINDOWS_DRIVER) || (!defined (DEBUG) && defined (_WIN64)))

if(HasSSE2())

ILS(x1, x2, t1, t2);

t1 ^= kds->rkd[2];

t2 ^= kds->rkd[3];

t1 ^= kds->rkd[0];

t2 ^= kds->rkd[1];

*(uint64*)out = t1;

}

}

{

#if CRYPTOPP_BOOL_SSE2_INTRINSICS_AVAILABLE && !defined(_UEFI) && (!defined (DEBUG) || !defined (TC_WINDOWS_DRIVER))

if(HasSSE2())

#define KUZNYECHIK_KS (sizeof(kuznyechik_kds))

#ifdef __cplusplus

}

applyLSTransformation_4(data1_, data2_, data3_,data4_); \

}

{

const uint_64t *roundKeys_ = (const uint_64t *) kds->rke;

__m128i data_;

_mm_storeu_si128((__m128i*) out, data_);

}

{

const uint_64t *roundKeys_ = (const uint_64t *) kds->rke;

__m128i data1_, data2_, data3_, data4_;

data4_ = _mm_xor_si128(data4_, cache11_); \

}

{

const uint_64t *roundKeys_ = kds->rkd;

__m128i data_;

_mm_storeu_si128((__m128i*) out, data_);

}

{

const uint_64t *roundKeys_ = kds->rkd;

__m128i data1_, data2_,data3_,data4_;

kuznyechik_decrypt_block_simd (out, in, kds);

}

{

scheduleEncryptionRoundKeysForGost15 (kds->rke, key);

scheduleDecryptionRoundKeysForGost15 (kds->rkd, key);

#include "cpu.h"

#include "misc.h"

int RDRAND_getBytes(unsigned char* buf, size_t bufLen)

{

#define T1HA_ALIGN_SUFFIX

#ifdef _MSC_VER

#define uint16_t uint16

#define uint32_t uint32

#define uint64_t uint64

void derive_key_sha512 (char *pwd, int pwd_len, char *salt, int salt_len, uint32 iterations, char *dk, int dklen) {

(void) iterations;

}

void derive_key_sha256 (char *pwd, int pwd_len, char *salt, int salt_len, uint32 iterations, char *dk, int dklen) {

(void) iterations;

}

BOOL BootArgsValid = FALSE;

BootArguments BootArgs;

uint32 BootSecRegionSize = 0;

uint32 BootPkcs5 = 0;

static volatile BOOL BootDriveFound = FALSE;

static DriveFilterExtension *BootDriveFilterExtension = NULL;

static LARGE_INTEGER BootDriveLength;

static BOOL CrashDumpEnabled = FALSE;

static BOOL HibernationEnabled = FALSE;

static BOOL LegacyHibernationDriverFilterActive = FALSE;

static MDL *HibernationWriteBufferMdl = NULL;

static uint32 HibernationPreventionCount = 0;

{

NTSTATUS status = STATUS_UNSUCCESSFUL;

PHYSICAL_ADDRESS bootArgsAddr;

uint16 bootLoaderArgsIndex;

uint64* BootArgsRegionsPtr = bIsEfi? BootArgsRegionsEFI : BootArgsRegionsDefault;

size_t BootArgsRegionsCount = bIsEfi? sizeof(BootArgsRegionsEFI)/ sizeof(BootArgsRegionsEFI[0]) : sizeof(BootArgsRegionsDefault)/ sizeof(BootArgsRegionsDefault[0]);

DumpMem (mappedBootArgs, sizeof (BootArguments));

if (bootArguments->BootLoaderVersion == VERSION_NUM

{

Dump ("BootArguments CRC incorrect\n");

burn (mappedBootArgs, sizeof (BootArguments));

uint32 crc;

PHYSICAL_ADDRESS SecRegionAddress;

SECREGION_BOOT_PARAMS* SecRegionParams = (SECREGION_BOOT_PARAMS*) (mappedCryptoInfo + sizeof(BOOT_CRYPTO_HEADER) + 2);

SecRegionAddress.QuadPart = SecRegionParams->Ptr;

Dump ("SecRegion memory 0x%x %d\n", SecRegionAddress.LowPart, SecRegionParams->Size);

// SecRegion correct?

if( (SecRegionParams->Ptr != 0) && (SecRegionParams->Size > 0)) {

if(crc == SecRegionParams->Crc) {

Dump ("SecRegion crc ok\n");

secRegionData = MmMapIoSpace (SecRegionAddress, SecRegionParams->Size, MmCached);

Dump ("Drive filter encryption keys invalidated!\n");

}

{

NTSTATUS status;

LARGE_INTEGER offset;

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

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

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

offset.QuadPart = 0;

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

// Check boot drive signature first (header CRC search could fail if a user restored the header to a non-boot drive)

if (BootDriveSignatureValid)

{

offset.QuadPart = 0;

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

uint32 crcSaved;

crcSaved = DeList->CRC32;

DeList->CRC32 = 0;

if(crc == crcSaved){

if(DeList->DE[DE_IDX_PWDCACHE].Type == DE_PwdCache) {

uint64 sector = 0;

{

NTSTATUS status = STATUS_SUCCESS;

LARGE_INTEGER offset;

header = TCalloc (TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE);

if (!header)

{

uint32 headerCrc32;

uint64 encryptedAreaLength = Extension->Queue.EncryptedAreaEnd + 1 - Extension->Queue.EncryptedAreaStart;

PCRYPTO_INFO pCryptoInfo = Extension->HeaderCryptoInfo;

#ifdef _WIN64

CRYPTO_INFO tmpCI;

typedef struct

{

#ifdef _WIN64

HiberDriverWriteFunctionB WriteFunctionB;

#else

HiberDriverWriteFunctionB WriteFunctionB;

#endif

HiberDriverWriteFunctionA WriteFunctionA;

LARGE_INTEGER PartitionStartOffset;

} HiberDriverContext;

{

LIST_ENTRY ModuleList;

#ifdef _WIN64

#else

#endif

PVOID ModuleBaseAddress;

HiberDriverEntry ModuleEntryAddress;

#ifdef _WIN64

#else

#endif

UNICODE_STRING ModuleName;

} ModuleTableItem;

BOOL headerUpdateRequired = FALSE;

int64 bytesWrittenSinceHeaderUpdate = 0;

KIRQL irql;

NTSTATUS status;

// generate real random values for wipeRandChars and

// wipeRandCharsUpdate instead of relying on uninitialized stack memory

ChaCha20RngCtx rngCtx;

GetDriverRandomSeed (pbSeed, sizeof (pbSeed));

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

if (SetupRequest.WipeAlgorithm != TC_WIPE_NONE)

{

int wipePassCount = GetWipePassCount (SetupRequest.WipeAlgorithm);

if (wipePassCount <= 0)

{

ULONG wipeBlockSize = TC_ENCRYPTION_SETUP_IO_BLOCK_SIZE;

CRYPTO_INFO *wipeCryptoInfo = NULL;

int wipePass, wipePassCount;

int ea = Extension->Queue.CryptoInfo->ea;

static DriveFilterExtension *BootDriveFilterExtension = NULL;

static LARGE_INTEGER DumpPartitionOffset;

static SIZE_T WriteFilterBufferSize;

}

{

NTSTATUS status = STATUS_INVALID_PARAMETER;

}

{

if (buffer == queue->FragmentBufferA)

{

BOOL

UpdateBuffer(

uint64 bufferDiskOffset,

uint32 bufferLength,

BOOL doUpadte

{

// Up to three subfragments may be required to handle a partially remapped fragment

int subFragment;

for (subFragment = 0 ; subFragment < 3; ++subFragment)

{

&& (item->OriginalLength & (ENCRYPTION_DATA_UNIT_SIZE - 1)) == 0

&& (item->OriginalOffset.QuadPart & (ENCRYPTION_DATA_UNIT_SIZE - 1)) != 0)

{

ULONG alignedLength;

LARGE_INTEGER alignedOffset;

hResult = ULongAdd(item->OriginalLength, ENCRYPTION_DATA_UNIT_SIZE, &alignedLength);

KEVENT CompletionThreadQueueNotEmptyEvent;

// Fragment buffers

KEVENT FragmentBufferAFreeEvent;

KEVENT FragmentBufferBFreeEvent;

ULONG LastReadLength;

LARGE_INTEGER ReadAheadOffset;

ULONG ReadAheadLength;

LARGE_INTEGER MaxReadAheadOffset;

LONG OutstandingIoCount;

LARGE_INTEGER LastPerformanceCounter;

#endif

SIZE_T SecRegionSize;

volatile BOOL ThreadBlockReadWrite;

ULONG Length;

int64 EncryptedOffset;

ULONG EncryptedLength;

LIST_ENTRY ListEntry;

LIST_ENTRY CompletionListEntry;

SecureBuffer alignedBuffer (alignedSize);

FuseService::ReadVolumeSectors (alignedBuffer, alignedOffset);

}

else

{

}

}

catch (MissingVolumeData&)

if (strcmp (path, FuseService::GetControlPath()) == 0)

{

shared_ptr <Buffer> infoBuf = FuseService::GetVolumeInfo();

if (offset >= (off_t) infoBuf->Size())

return 0;

if (strcmp (path, FuseService::GetVolumeImagePath()) == 0)

{

return size;

}

if (FuseService::AuxDeviceInfoReceived())

return -EACCES;

return size;

}

}

sigaction (SIGTERM, &action, nullptr);

// Wait for the exit of the main service

if (read (SignalHandlerPipe->GetReadFD(), buf, sizeof (buf))) { } // Errors ignored

_exit (0);

void GetDriverRandomSeed (unsigned char* pbRandSeed, size_t cbRandSeed)

{

LARGE_INTEGER iSeed, iSeed2;

WHIRLPOOL_CTX tctx;

size_t count;

if (opentest->bDetectTCBootLoader || opentest->DetectFilesystem || opentest->bComputeVolumeIDs)

{

if (!readBuffer)

{

ntStatus = STATUS_INSUFFICIENT_RESOURCES;

if (NT_SUCCESS (ntStatus))

{

if (!readBuffer)

{

Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;

NTSTATUS status;

LARGE_INTEGER sysLength;

LARGE_INTEGER offset;

ULONGLONG startTime;

ULONG sectorSize;

NTSTATUS status;

ULONG sectorSize;

ULONG sectorCount;

*zeroedSectorCount = 0;

}

{

NTSTATUS status;

ULONG sectorSize;

BOOL ValidateIOBufferSize (PIRP irp, size_t requiredBufferSize, ValidateIOBufferSizeType type);

NTSTATUS GetDeviceSectorSize (PDEVICE_OBJECT deviceObject, ULONG *bytesPerSector);

NTSTATUS ZeroUnreadableSectors (PDEVICE_OBJECT deviceObject, LARGE_INTEGER startOffset, ULONG size, uint64 *zeroedSectorCount);

BOOL IsVolumeAccessibleByCurrentUser (PEXTENSION volumeDeviceExtension);

void GetElapsedTimeInit (LARGE_INTEGER *lastPerfCounter);

int64 GetElapsedTime (LARGE_INTEGER *lastPerfCounter);

LARGE_INTEGER diskLengthInfo;

DISK_GEOMETRY_EX dg;

STORAGE_PROPERTY_QUERY storagePropertyQuery = {0};

STORAGE_DEVICE_NUMBER storageDeviceNumber;

ntStatus = IoGetDeviceObjectPointer (&FullFileName,

BOOL bTimeStampValid = FALSE;

LARGE_INTEGER headerOffset;

BOOL backupHeader;

uint32 workChunkSize = TC_VOLUME_HEADER_GROUP_SIZE;

#ifdef _WIN64

CRYPTO_INFO tmpCI;

/* wipe old backup header */

if ( !cryptoInfo->LegacyVolume )

{

UINT64_STRUCT unitNo;

LARGE_INTEGER offset;

WipeAlgorithmId wipeAlgorithm = TC_WIPE_35_GUTMANN;

DebugAddProgressDlgStatus(hwndDlg, GetString("EXPANDER_WIPING_OLD_HEADER"));

if (!wipeBuffer)

{

nStatus = ERR_OUTOFMEMORY;

static volatile BOOL WriteThreadExitRequested;

static HANDLE WriteThreadHandle;

static HANDLE WriteBufferEmptyEvent;

static HANDLE WriteBufferFullEvent;

}

// Write the backup header to the partition

{

nStatus = ERR_OS_ERROR;

goto closing_seq;

}

// Write the fake hidden backup header to the partition

{

nStatus = ERR_OS_ERROR;

goto closing_seq;

PCRYPTO_INFO masterCryptoInfo = NULL, headerCryptoInfo = NULL, tmpCryptoInfo = NULL;

UINT64_STRUCT unitNo;

char *buf = NULL, *header = NULL;

WCHAR dosDev[TC_MAX_PATH] = {0};

WCHAR devName[MAX_PATH] = {0};

WCHAR deviceName[MAX_PATH];

if (wipeAlgorithm != TC_WIPE_NONE)

{

if (!wipeBuffer)

{

nStatus = ERR_OUTOFMEMORY;

// Encrypt the plaintext in RAM

// If enabled, wipe the area to which we will write the ciphertext

if (wipeAlgorithm != TC_WIPE_NONE)

{

int wipePassCount = GetWipePassCount (wipeAlgorithm);

if (wipePassCount <= 0)

// Undo failed write operation

if (workChunkSize > TC_VOLUME_DATA_OFFSET && MoveFilePointer (dev, offset))

{

WriteFile (dev, buf + TC_VOLUME_DATA_OFFSET, workChunkSize - TC_VOLUME_DATA_OFFSET, &n, NULL);

}

// Undo failed write operation

if (workChunkSize > TC_VOLUME_DATA_OFFSET && MoveFilePointer (dev, offset))

{

WriteFile (dev, buf + TC_VOLUME_DATA_OFFSET, workChunkSize - TC_VOLUME_DATA_OFFSET, &n, NULL);

}

offset.QuadPart = TC_VOLUME_HEADER_OFFSET;

if (MoveFilePointer (dev, offset) == 0

{

nStatus = ERR_OS_ERROR;

goto closing_seq;

offset.QuadPart += TC_HIDDEN_VOLUME_HEADER_OFFSET;

if (MoveFilePointer (dev, offset) == 0

{

nStatus = ERR_OS_ERROR;

goto closing_seq;

PCRYPTO_INFO masterCryptoInfo = NULL, headerCryptoInfo = NULL;

UINT64_STRUCT unitNo;

char *buf = NULL;

WCHAR dosDev[TC_MAX_PATH] = {0};

WCHAR devName[MAX_PATH] = {0};

WCHAR deviceName[MAX_PATH];

sectorSize = driveGeometry.BytesPerSector;

if (!tmpSectorBuf)

{

nStatus = ERR_OUTOFMEMORY;

// Decrypt the ciphertext in RAM

LARGE_INTEGER offset;

DWORD n;

int nStatus = ERR_SUCCESS;

DWORD dwError;

uint32 headerCrc32;

PCRYPTO_INFO pCryptoInfo = headerCryptoInfo;

#ifdef _WIN64

BOOL bIsRamEncryptionEnabled = IsRamEncryptionEnabled();

#endif

if (!header)

return ERR_OUTOFMEMORY;

VirtualLock (header, TC_VOLUME_HEADER_EFFECTIVE_SIZE);

offset.QuadPart = deviceSize - TC_VOLUME_HEADER_GROUP_SIZE;

// were decrypted in place, it would be possible to mount them partially encrypted and it wouldn't be possible

// to resume interrupted decryption after the wizard exits.

masterCryptoInfo->HeaderFlags |= TC_HEADER_FLAG_NONSYS_INPLACE_ENC;

mputLong (fieldPos, (masterCryptoInfo->HeaderFlags));

headerCrc32 = GetCrc32 (header + TC_HEADER_OFFSET_MAGIC, TC_HEADER_OFFSET_HEADER_CRC - TC_HEADER_OFFSET_MAGIC);

mputLong (fieldPos, headerCrc32);

EncryptBuffer (header + HEADER_ENCRYPTED_DATA_OFFSET, HEADER_ENCRYPTED_DATA_SIZE, pCryptoInfo);

DWORD n;

int64 sectorCount;

LARGE_INTEGER workOffset;

DWORD dwError;

workOffset.QuadPart = startOffset.QuadPart;

if (!sectorBuffer)

return ERR_OUTOFMEMORY;

offset.QuadPart = deviceSize - TC_VOLUME_HEADER_GROUP_SIZE;

if (MoveFilePointer (dev, offset) == 0

{

nStatus = ERR_OS_ERROR;

goto closing_seq;

static BOOL GetFreeClusterBeforeThreshold (HANDLE volumeHandle, int64 *freeCluster, int64 clusterThreshold)

{

const int bitmapSize = 65536;

VOLUME_BITMAP_BUFFER *bitmap = (VOLUME_BITMAP_BUFFER *) bitmapBuffer;

STARTING_LCN_INPUT_BUFFER startLcn;

startLcn.StartingLcn.QuadPart = 0;

if (wxCONV_FAILED == ulen)

throw PasswordUTF8Invalid (SRC_POS);

SecureBuffer passwordBuf(ulen);

if (wxCONV_FAILED == ulen)

throw PasswordUTF8Invalid (SRC_POS);

if (ulen > maxUtf8Len)

throw PasswordUTF8TooLong (SRC_POS);

}

return shared_ptr<SecureBuffer>(new SecureBuffer (utf8Buffer));

}

else

const 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"};

unsigned long pim;

Pkcs5KdfList prfList = Pkcs5Kdf::GetAvailableAlgorithms ();

memcpy (&pim, buffer.Ptr (), sizeof (unsigned long));

memcpy (salt.Ptr(), tmp_salt, 64);

void EncryptionTestDialog::GetTextCtrlData (wxTextCtrl *textCtrl, Buffer &buffer) const

{

string dataStr = StringConverter::ToSingle (wstring (textCtrl->GetValue()));

for (size_t i = 0; i < dataStr.size() / 2; ++i)

throw StringConversionFailed (SRC_POS);

}

}

if (data.empty())

{

event.Skip();

long coord = event.GetX();

coord = event.GetY();

if (ShowRandomPoolCheckBox->IsChecked())

ShowBytes (RandomPoolStaticText, RandomNumberGenerator::PeekPool().GetRange (0, 24));

#if defined(TC_UNIX) && !defined(TC_MACOSX)

try

{

if (read (ShowRequestFifo, buf, sizeof (buf)) > 0 && Gui->IsInBackgroundMode())

Gui->SetBackgroundMode (false);

}

{

event.Skip();

long coord = event.GetX();

coord = event.GetY();

if (ShowRandomPoolCheckBox->IsChecked())

ShowBytes (RandomPoolStaticText, RandomNumberGenerator::PeekPool().GetRange (0, 24));

{

wxBusyCursor busy;

keyfile->GetKeyfileData (keyfileData);

BufferPtr keyfileDataBuf (&keyfileData.front(), keyfileData.size());

if (keyfile.Length() > 0)

{

BufferPtr keyfileDataBuf (&keyfileData.front(), keyfileData.size());

keyfile.ReadCompleteBuffer (keyfileDataBuf);

event.Skip();

if (!IsWorkInProgress() && RandomNumberGenerator::IsRunning())

{

long coord = event.GetX();

coord = event.GetY();

VolumeCreationProgressWizardPage *page = dynamic_cast <VolumeCreationProgressWizardPage *> (GetCurrentPage());

if (page)

if (!IsWorkInProgress())

{

wxLongLong time = wxGetLocalTimeMillis();

}

}

shared_ptr <VolumePassword> password;

wchar_t passwordBuf[VolumePassword::MaxSize + 1];

size_t maxPasswordLength = (bLegacyPassword || CmdLine->ArgUseLegacyPassword)? VolumePassword::MaxLegacySize: VolumePassword::MaxSize;

#ifdef TC_WINDOWS

int len = GetWindowText (static_cast <HWND> (textCtrl->GetHandle()), passwordBuf, VolumePassword::MaxSize + 1);

int showFifo = open (string (MainFrame::GetShowRequestFifoPath()).c_str(), O_WRONLY | O_NONBLOCK);

throw_sys_if (showFifo == -1);

if (write (showFifo, buf, 1) == 1)

{

close (showFifo);

void LanguageStrings::Init ()

{

{

# include "Common/Language.xml.h"

, 0

hResL = LoadResource (NULL, hRes);

throw_sys_if (!hResL);

throw_sys_if (!resPtr);

return ConstBufferPtr (resPtr, SizeofResource (NULL, hRes));

if ( xml.IsFile() ){

File file;

file.Open (xml, File::OpenRead, File::ShareRead);

BufferPtr keyfileDataBuf (&keyfileData.front(), keyfileData.size());

file.ReadCompleteBuffer (keyfileDataBuf);

file.Close();

string langxml(keyfileData.begin(), keyfileData.end());

return langxml;

}

{

# include "Common/Language.xml.h"

, 0

strBuf.CopyFrom (res);

return string (reinterpret_cast <char *> (strBuf.Ptr()));

#else

{

# include "License.txt.h"

, 0

#ifdef TC_WINDOWS

return wxBitmap (L"IDB_DRIVE_ICON", wxBITMAP_TYPE_BMP_RESOURCE).ConvertToImage().Resize (wxSize (16, 12), wxPoint (0, 0));

#else

{

# include "Mount/Drive_icon_96dpi.bmp.h"

};

wxImage image = wxBitmap (L"IDB_DRIVE_ICON_MASK", wxBITMAP_TYPE_BMP_RESOURCE).ConvertToImage().Resize (wxSize (16, 12), wxPoint (0, 0));

return wxBitmap (image.ConvertToMono (0, 0, 0), 1);

#else

{

# include "Mount/Drive_icon_mask_96dpi.bmp.h"

};

#ifdef TC_WINDOWS

return wxBitmap (L"IDB_LOGO", wxBITMAP_TYPE_BMP_RESOURCE);

#else

{

# include "Mount/Logo_96dpi.bmp.h"

};

#ifdef TC_WINDOWS

return wxBitmap (L"IDB_TEXTUAL_LOGO", wxBITMAP_TYPE_BMP_RESOURCE);

#else

{

# include "Common/Textual_logo_96dpi.bmp.h"

};

#ifdef TC_WINDOWS

return wxBitmap (L"IDB_VOLUME_WIZARD_BITMAP", wxBITMAP_TYPE_BMP_RESOURCE);

#else

{

# include "Format/VeraCrypt_Wizard.bmp.h"

};

finally_do ({ TextUserInterface::SetTerminalEcho (true); });

wchar_t passwordBuf[4096];

shared_ptr<VolumePassword> password;

shared_ptr<TokenKeyfile> tokenKeyfile = Token::getTokenKeyfile(keyfilePath);

tokenKeyfile->GetKeyfileData (keyfileData);

BufferPtr keyfileDataBuf (&keyfileData.front(), keyfileData.size());

if (keyfile.Length() > 0)

{

BufferPtr keyfileDataBuf (&keyfileData.front(), keyfileData.size());

keyfile.ReadCompleteBuffer (keyfileDataBuf);

while (randCharsRequired > 0)

{

wstring randStr = AskString();

randCharsRequired -= randStr.size();

*TextOutStream << L"</VeraCrypt>" << endl;

wxStreamBuffer *buf = MemOutStream->GetOutputStreamBuffer();

OutFile.Close();

TextOutStream.reset();

XmlGetAttributeText (xml, "ID", label, sizeof (label));

if (strlen (label) == (2*VOLUME_ID_SIZE))

{

if (HexWideStringToArray (Utf8StringToWide (label).c_str(), arr) && arr.size() == VOLUME_ID_SIZE)

{

memcpy (favorite.VolumeID, &arr[0], VOLUME_ID_SIZE);

OpenVolumeContext hiddenVolume;

Password hiddenVolPassword;

int hiddenVolPkcs5 = 0, hiddenVolPim = 0;

int EffectiveVolumePkcs5 = CmdVolumePkcs5;

int EffectiveVolumePim = CmdVolumePim;

// Backup headers

bool legacyVolume = volume.CryptoInfo->LegacyVolume ? true : false;

int backupFileSize = legacyVolume ? TC_VOLUME_HEADER_SIZE_LEGACY * 2 : TC_VOLUME_HEADER_GROUP_SIZE;

goto error;

}

{

nStatus = ERR_OS_ERROR;

goto error;

goto error;

}

{

nStatus = ERR_OS_ERROR;

goto error;

goto error;

}

{

nStatus = ERR_OS_ERROR;

goto error;

if (BootEncStatus.DriveMounted && !bSystemIsGPT)

{

string customUserMessage;

uint16 bootLoaderVersion;

{

WORD lw = LOWORD (wParam);

static std::string platforminfo;

static string currentCustomUserMessage;

switch (msg)

LocalizeDialog (hwndDlg, "IDD_SYSENC_SETTINGS");

uint32 driverConfig = ReadDriverConfigurationFlags();

uint32 serviceConfig = ReadServiceConfigurationFlags();

string customUserMessage;

uint16 bootLoaderVersion = 0;

BOOL bPasswordCacheEnabled = (driverConfig & TC_DRIVER_CONFIG_CACHE_BOOT_PASSWORD)? TRUE : FALSE;

if (!bSystemIsGPT)

GetDlgItemTextA (hwndDlg, IDC_CUSTOM_BOOT_LOADER_MESSAGE, customUserMessage, sizeof (customUserMessage));

if (IsDlgButtonChecked (hwndDlg, IDC_DISABLE_BOOT_LOADER_PIM_PROMPT))

userConfig |= TC_BOOT_USER_CFG_FLAG_DISABLE_PIM;

try

{

DataSize = size;

DataAlignment = alignment;

}

public:

ConstBufferPtr ()

: DataPtr (nullptr), DataSize (0) { }

: DataPtr (data), DataSize (size) { }

virtual ~ConstBufferPtr () { }

bool IsDataEqual (const ConstBufferPtr &other) const { return Memory::Compare (DataPtr, DataSize, other.DataPtr, other.DataSize) == 0; }

ConstBufferPtr GetRange (size_t offset, size_t size) const;

size_t Size () const { return DataSize; }

protected:

size_t DataSize;

};

public:

BufferPtr ()

: DataPtr (nullptr), DataSize (0) { }

: DataPtr (data), DataSize (size) { }

virtual ~BufferPtr () { }

void CopyFrom (const ConstBufferPtr &bufferPtr) const;

void Erase () const { Zero(); }

BufferPtr GetRange (size_t offset, size_t size) const;

size_t Size () const { return DataSize; }

void Zero () const { Memory::Zero (DataPtr, DataSize); }

operator ConstBufferPtr () const { return ConstBufferPtr (DataPtr, DataSize); }

protected:

size_t DataSize;

};

virtual void Allocate (size_t size, size_t alignment = 0);

virtual void CopyFrom (const ConstBufferPtr &bufferPtr, size_t alignment = 0);

virtual void Erase ();

virtual void Free ();

virtual BufferPtr GetRange (size_t offset, size_t size) const;

virtual bool IsAllocated () const { return DataSize != 0; }

virtual void Zero ();

virtual operator BufferPtr () const { return BufferPtr (DataPtr, DataSize); }

virtual operator ConstBufferPtr () const { return ConstBufferPtr (DataPtr, DataSize); }

protected:

size_t DataSize;

size_t DataAlignment;

vector <char> buffer (4096);

uint64 len;

str.insert (str.end(), buffer.begin(), buffer.begin() + static_cast <int> (len));

return str;

class Endian

{

public:

{

return x;

}

#endif

}

{

return x;

}

static uint32 MirrorBytes (const uint32 &x)

{

}

static uint64 MirrorBytes (const uint64 &x)

{

}

};

}

MemoryStream::MemoryStream (const ConstBufferPtr &data) :

ReadPosition (0)

{

BufferPtr (&Data[0], Data.size()).CopyFrom (data);

}

virtual void Write (const ConstBufferPtr &data);

protected:

size_t ReadPosition;

};

}

typedef __int16 int16;

typedef __int32 int32;

typedef __int64 int64;

typedef unsigned __int16 uint16;

typedef unsigned __int32 uint32;

typedef unsigned __int64 uint64;

typedef int16_t int16;

typedef int32_t int32;

typedef int64_t int64;

typedef uint16_t uint16;

typedef uint32_t uint32;

typedef uint64_t uint64;

Buffer buffer (10);

for (size_t i = 0; i < buffer.Size(); i++)

ser.Serialize ("int32", i32);

ser.Serialize ("int64", i64);

Buffer dbuffer (10);

ser.Deserialize ("buffer", buffer);

for (size_t i = 0; i < buffer.Size(); i++)

throw TestFailed (SRC_POS);

shared_ptr <ExecutedProcessFailed> dex = Serializable::DeserializeNew <ExecutedProcessFailed> (stream);

bool PlatformTest::TestAll ()

{

// Integer types

if (sizeof (uint16) != 2 || sizeof (int16) != 2 || sizeof (__int16) != 2) throw TestFailed (SRC_POS);

if (sizeof (uint32) != 4 || sizeof (int32) != 4 || sizeof (__int32) != 4) throw TestFailed (SRC_POS);

if (sizeof (uint64) != 8 || sizeof (int64) != 8) throw TestFailed (SRC_POS);

T Serializer::Deserialize ()

{

uint64 size;

if (Endian::Big (size) != sizeof (T))

throw ParameterIncorrect (SRC_POS);

T data;

return Endian::Big (data);

}

void Serializer::Deserialize (const string &name, bool &data)

{

ValidateName (name);

}

{

ValidateName (name);

}

void Serializer::Deserialize (const string &name, int32 &data)

uint64 size = Deserialize <uint64> ();

vector <char> data ((size_t) size);

return string (&data[0]);

}

uint64 size = Deserialize <uint64> ();

vector <wchar_t> data ((size_t) size / sizeof (wchar_t));

return wstring (&data[0]);

}

void Serializer::Serialize (T data)

{

uint64 size = Endian::Big (uint64 (sizeof (data)));

data = Endian::Big (data);

}

void Serializer::Serialize (const string &name, bool data)

{

SerializeString (name);

Serialize (d);

}

{

SerializeString (name);

Serialize (data);

void Serializer::SerializeString (const string &data)

{

Serialize ((uint64) data.size() + 1);

}

void Serializer::SerializeWString (const wstring &data)

{

uint64 size = (data.size() + 1) * sizeof (wchar_t);

Serialize (size);

}

void Serializer::ValidateName (const string &name)

virtual ~Serializer () { }

void Deserialize (const string &name, bool &data);

void Deserialize (const string &name, int32 &data);

void Deserialize (const string &name, int64 &data);

void Deserialize (const string &name, uint32 &data);

wstring DeserializeWString (const string &name);

list <wstring> DeserializeWStringList (const string &name);

void Serialize (const string &name, bool data);

void Serialize (const string &name, const char *data);

void Serialize (const string &name, int32 data);

void Serialize (const string &name, int64 data);

}

BufferPtr (

bufferSize).CopyFrom (

(str.length() + 1) * sizeof (wchar_t)

)

);

outputString.erase();

char c;

{

if (c == '\r')

continue;

try

{

deserializedObject.reset (Serializable::DeserializeNew (stream));

deserializedException = dynamic_cast <Exception*> (deserializedObject.get());

}

{

}

{

if (!Initialized)

throw NotInitialized (SRC_POS);

Decrypt (data);

}

{

if (!Initialized)

throw NotInitialized (SRC_POS);

}

}

{

if (!Initialized)

throw NotInitialized (SRC_POS);

Encrypt (data);

}

{

if (!Initialized)

throw NotInitialized (SRC_POS);

Initialized = true;

}

{

if (!Initialized)

throw NotInitialized (SRC_POS);

EncryptXTS (data, length, startDataUnitNo);

}

{

if (!Initialized)

throw NotInitialized (SRC_POS);

// AES

{

#ifdef TC_AES_HW_CPU

if (IsHwSupportAvailable())

aes_decrypt (data, data, (aes_decrypt_ctx *) (ScheduledKey.Ptr() + sizeof (aes_encrypt_ctx)));

}

{

if (!Initialized)

throw NotInitialized (SRC_POS);

Cipher::DecryptBlocks (data, blockCount);

}