nihilist/VeraCrypt
1
0
Fork 0
mirror of https://github.com/veracrypt/VeraCrypt synced 2024-09-20 04:46:21 +02:00
Code Issues Packages Projects Releases Wiki Activity

Avoid conflict with C++17 features std::byte by using uint8 type instead of byte

Browse Source
This commit is contained in:
Mounir IDRASSI 2024-06-12 12:30:04 +02:00
parent bf9f3ec4f0
commit 455a4f2176
No known key found for this signature in database
GPG Key ID: FC1B00364B3FE937
132 changed files with 1032 additions and 1035 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Boot/Windows/Bios.h
View File

@ -28,6 +28,6 @@ enum
BiosResultTimeout = 0x80
};
typedef byte BiosResult;
typedef uint8 BiosResult;
#endif // TC_HEADER_Boot_Bios

8
src/Boot/Windows/BootCommon.h
View File

@ -43,7 +43,7 @@
typedef struct
{
byte Flags;
uint8 Flags;
} BootSectorConfiguration;
@ -120,7 +120,7 @@ typedef struct {
uint32 Data1;
uint16 Data2;
uint16 Data3;
byte Data4[8];
uint8 Data4[8];
} DCS_GUID;
// DE types
@ -155,7 +155,7 @@ typedef struct _DCS_DISK_ENTRY {
struct {
uint32 Type;
uint32 Offset;
byte reserved[16];
uint8 reserved[16];
uint64 Length; // size of structure at Offset
};
DCS_DISK_ENTRY_SECTORS Sectors;
@ -208,7 +208,7 @@ typedef struct _DCS_DEP_PWD_CACHE {
uint32 Count;
PasswordLegacy Pwd[4];
int32 Pim[4];
byte pad[512 - 8 - 4 - 4 - (sizeof(PasswordLegacy) + 4) * 4];
uint8 pad[512 - 8 - 4 - 4 - (sizeof(PasswordLegacy) + 4) * 4];
} DCS_DEP_PWD_CACHE;
CSTATIC_ASSERT(sizeof(DCS_DEP_PWD_CACHE) == 512, Wrong_size_DCS_DEP_PWD_CACHE);
#pragma pack()

10
src/Boot/Windows/BootConfig.cpp
View File

@ -12,10 +12,10 @@
#include "BootConfig.h"
byte BootSectorFlags;
uint8 BootSectorFlags;
byte BootLoaderDrive;
byte BootDrive;
uint8 BootLoaderDrive;
uint8 BootDrive;
bool BootDriveGeometryValid = false;
bool PreventNormalSystemBoot = false;
bool PreventBootMenu = false;
@ -39,7 +39,7 @@ uint64 HiddenVolumeStartSector;
void ReadBootSectorUserConfiguration ()
{
byte userConfig;
uint8 userConfig;
AcquireSectorBuffer();
@ -83,7 +83,7 @@ void ReadBootSectorUserConfiguration ()
}
BiosResult UpdateBootSectorConfiguration (byte drive)
BiosResult UpdateBootSectorConfiguration (uint8 drive)
{
uint64 mbrSector;
mbrSector.HighPart = 0;

8
src/Boot/Windows/BootConfig.h
View File

@ -17,10 +17,10 @@
#include "Platform.h"
#include "BootDiskIo.h"
extern byte BootSectorFlags;
extern uint8 BootSectorFlags;
extern byte BootLoaderDrive;
extern byte BootDrive;
extern uint8 BootLoaderDrive;
extern uint8 BootDrive;
extern bool BootDriveGeometryValid;
extern DriveGeometry BootDriveGeometry;
extern bool PreventNormalSystemBoot;
@ -41,6 +41,6 @@ extern uint64 HiddenVolumeStartSector;
void ReadBootSectorUserConfiguration ();
BiosResult UpdateBootSectorConfiguration (byte drive);
BiosResult UpdateBootSectorConfiguration (uint8 drive);
#endif // TC_HEADER_Boot_BootConfig

24
src/Boot/Windows/BootConsoleIo.cpp
View File

@ -101,7 +101,7 @@ void Print (const uint64 &number)
}
void PrintHex (byte b)
void PrintHex (uint8 b)
{
PrintChar (((b >> 4) >= 0xA ? 'A' - 0xA : '0') + (b >> 4));
PrintChar (((b & 0xF) >= 0xA ? 'A' - 0xA : '0') + (b & 0xF));
@ -110,8 +110,8 @@ void PrintHex (byte b)
void PrintHex (uint16 data)
{
PrintHex (byte (data >> 8));
PrintHex (byte (data));
PrintHex (uint8 (data >> 8));
PrintHex (uint8 (data));
}
@ -219,9 +219,9 @@ void PrintErrorNoEndl (const char *message)
}
byte GetShiftFlags ()
uint8 GetShiftFlags ()
{
byte flags;
uint8 flags;
__asm
{
mov ah, 2
@ -233,7 +233,7 @@ byte GetShiftFlags ()
}
byte GetKeyboardChar ()
uint8 GetKeyboardChar ()
{
return GetKeyboardChar (nullptr);
}
@ -253,7 +253,7 @@ inline void Sleep ()
}
*/
byte GetKeyboardChar (byte *scanCode)
uint8 GetKeyboardChar (uint8 *scanCode)
{
// Work around potential BIOS bugs (Windows boot manager polls the keystroke buffer)
while (!IsKeyboardCharAvailable())
@ -265,8 +265,8 @@ byte GetKeyboardChar (byte *scanCode)
}
}
byte asciiCode;
byte scan;
uint8 asciiCode;
uint8 scan;
__asm
{
mov ah, 0
@ -302,7 +302,7 @@ bool EscKeyPressed ()
{
if (IsKeyboardCharAvailable ())
{
byte keyScanCode;
uint8 keyScanCode;
GetKeyboardChar (&keyScanCode);
return keyScanCode == TC_BIOS_KEY_ESC;
}
@ -346,8 +346,8 @@ bool IsDigit (char c)
int GetString (char *buffer, size_t bufferSize)
{
byte c;
byte scanCode;
uint8 c;
uint8 scanCode;
size_t pos = 0;
while (pos < bufferSize)

8
src/Boot/Windows/BootConsoleIo.h
View File

@ -45,9 +45,9 @@ void ClearScreen ();
void DisableScreenOutput ();
void EnableScreenOutput ();
bool EscKeyPressed ();
byte GetKeyboardChar ();
byte GetKeyboardChar (byte *scanCode);
byte GetShiftFlags ();
uint8 GetKeyboardChar ();
uint8 GetKeyboardChar (uint8 *scanCode);
uint8 GetShiftFlags ();
int GetString (char *buffer, size_t bufferSize);
void InitVideoMode ();
bool IsKeyboardCharAvailable ();
@ -64,7 +64,7 @@ void PrintEndl (int cnt);
void PrintRepeatedChar (char c, int n);
void PrintError (const char *message);
void PrintErrorNoEndl (const char *message);
void PrintHex (byte b);
void PrintHex (uint8 b);
void PrintHex (uint16 data);
void PrintHex (uint32 data);
void PrintHex (const uint64 &data);

8
src/Boot/Windows/BootDebug.cpp
View File

@ -34,7 +34,7 @@ void InitDebugPort ()
}
void WriteDebugPort (byte dataByte)
void WriteDebugPort (uint8 dataByte)
{
__asm
{
@ -82,7 +82,7 @@ void PrintVal (const char *message, const uint64 &value, bool newLine, bool hex)
}
void PrintHexDump (byte *mem, size_t size, uint16 *memSegment)
void PrintHexDump (uint8 *mem, size_t size, uint16 *memSegment)
{
const size_t width = 16;
for (size_t pos = 0; pos < size; )
@ -92,7 +92,7 @@ void PrintHexDump (byte *mem, size_t size, uint16 *memSegment)
size_t i;
for (i = 0; i < width && pos < size; ++i)
{
byte dataByte;
uint8 dataByte;
if (memSegment)
{
__asm
@ -134,7 +134,7 @@ void PrintHexDump (byte *mem, size_t size, uint16 *memSegment)
void PrintHexDump (uint16 memSegment, uint16 memOffset, size_t size)
{
PrintHexDump ((byte *) memOffset, size, &memSegment);
PrintHexDump ((uint8 *) memOffset, size, &memSegment);
}
#endif // TC_BOOT_DEBUG_ENABLED

4
src/Boot/Windows/BootDebug.h
View File

@ -51,8 +51,8 @@
void InitDebugPort ();
void InitStackChecker ();
void WriteDebugPort (byte dataByte);
void PrintHexDump (byte *mem, size_t size, uint16 *memSegment = nullptr);
void WriteDebugPort (uint8 dataByte);
void PrintHexDump (uint8 *mem, size_t size, uint16 *memSegment = nullptr);
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);

58
src/Boot/Windows/BootDiskIo.cpp
View File

@ -19,7 +19,7 @@
#include "BootStrings.h"
byte SectorBuffer[TC_LB_SIZE];
uint8 SectorBuffer[TC_LB_SIZE];
#ifdef TC_BOOT_DEBUG_ENABLED
static bool SectorBufferInUse = false;
@ -41,9 +41,9 @@ void ReleaseSectorBuffer ()
#endif
bool IsLbaSupported (byte drive)
bool IsLbaSupported (uint8 drive)
{
static byte CachedDrive = TC_INVALID_BIOS_DRIVE;
static uint8 CachedDrive = TC_INVALID_BIOS_DRIVE;
static bool CachedStatus;
uint16 result = 0;
@ -68,7 +68,7 @@ bool IsLbaSupported (byte drive)
}
void PrintDiskError (BiosResult error, bool write, byte drive, const uint64 *sector, const ChsAddress *chs)
void PrintDiskError (BiosResult error, bool write, uint8 drive, const uint64 *sector, const ChsAddress *chs)
{
PrintEndl();
Print (write ? "Write" : "Read"); Print (" error:");
@ -109,17 +109,17 @@ void PrintSectorCountInMB (const uint64 &sectorCount)
}
BiosResult ReadWriteSectors (bool write, uint16 bufferSegment, uint16 bufferOffset, byte drive, const ChsAddress &chs, byte sectorCount, bool silent)
BiosResult ReadWriteSectors (bool write, uint16 bufferSegment, uint16 bufferOffset, uint8 drive, const ChsAddress &chs, uint8 sectorCount, bool silent)
{
CheckStack();
byte cylinderLow = (byte) chs.Cylinder;
byte sector = chs.Sector;
sector |= byte (chs.Cylinder >> 2) & 0xc0;
byte function = write ? 0x03 : 0x02;
uint8 cylinderLow = (uint8) chs.Cylinder;
uint8 sector = chs.Sector;
sector |= uint8 (chs.Cylinder >> 2) & 0xc0;
uint8 function = write ? 0x03 : 0x02;
BiosResult result;
byte tryCount = TC_MAX_BIOS_DISK_IO_RETRIES;
uint8 tryCount = TC_MAX_BIOS_DISK_IO_RETRIES;
do
{
@ -159,20 +159,20 @@ BiosResult ReadWriteSectors (bool write, uint16 bufferSegment, uint16 bufferOffs
#ifdef TC_WINDOWS_BOOT_RESCUE_DISK_MODE
BiosResult ReadWriteSectors (bool write, byte *buffer, byte drive, const ChsAddress &chs, byte sectorCount, bool silent)
BiosResult ReadWriteSectors (bool write, uint8 *buffer, uint8 drive, const ChsAddress &chs, uint8 sectorCount, bool silent)
{
uint16 codeSeg;
__asm mov codeSeg, cs
return ReadWriteSectors (write, codeSeg, (uint16) buffer, drive, chs, sectorCount, silent);
}
BiosResult ReadSectors (byte *buffer, byte drive, const ChsAddress &chs, byte sectorCount, bool silent)
BiosResult ReadSectors (uint8 *buffer, uint8 drive, const ChsAddress &chs, uint8 sectorCount, bool silent)
{
return ReadWriteSectors (false, buffer, drive, chs, sectorCount, silent);
}
#if 0
BiosResult WriteSectors (byte *buffer, byte drive, const ChsAddress &chs, byte sectorCount, bool silent)
BiosResult WriteSectors (uint8 *buffer, uint8 drive, const ChsAddress &chs, uint8 sectorCount, bool silent)
{
return ReadWriteSectors (true, buffer, drive, chs, sectorCount, silent);
}
@ -180,7 +180,7 @@ BiosResult WriteSectors (byte *buffer, byte drive, const ChsAddress &chs, byte s
#endif
static BiosResult ReadWriteSectors (bool write, BiosLbaPacket &dapPacket, byte drive, const uint64 &sector, uint16 sectorCount, bool silent)
static BiosResult ReadWriteSectors (bool write, BiosLbaPacket &dapPacket, uint8 drive, const uint64 &sector, uint16 sectorCount, bool silent)
{
CheckStack();
@ -202,10 +202,10 @@ static BiosResult ReadWriteSectors (bool write, BiosLbaPacket &dapPacket, byte d
dapPacket.SectorCount = sectorCount;
dapPacket.Sector = sector;
byte function = write ? 0x43 : 0x42;
uint8 function = write ? 0x43 : 0x42;
BiosResult result;
byte tryCount = TC_MAX_BIOS_DISK_IO_RETRIES;
uint8 tryCount = TC_MAX_BIOS_DISK_IO_RETRIES;
do
{
@ -237,7 +237,7 @@ static BiosResult ReadWriteSectors (bool write, BiosLbaPacket &dapPacket, byte d
}
BiosResult ReadWriteSectors (bool write, byte *buffer, byte drive, const uint64 &sector, uint16 sectorCount, bool silent)
BiosResult ReadWriteSectors (bool write, uint8 *buffer, uint8 drive, const uint64 &sector, uint16 sectorCount, bool silent)
{
BiosLbaPacket dapPacket;
dapPacket.Buffer = (uint32) buffer;
@ -245,20 +245,20 @@ BiosResult ReadWriteSectors (bool write, byte *buffer, byte drive, const uint64
}
BiosResult ReadWriteSectors (bool write, uint16 bufferSegment, uint16 bufferOffset, byte drive, const uint64 &sector, uint16 sectorCount, bool silent)
BiosResult ReadWriteSectors (bool write, uint16 bufferSegment, uint16 bufferOffset, uint8 drive, const uint64 &sector, uint16 sectorCount, bool silent)
{
BiosLbaPacket dapPacket;
dapPacket.Buffer = ((uint32) bufferSegment << 16) | bufferOffset;
return ReadWriteSectors (write, dapPacket, drive, sector, sectorCount, silent);
}
BiosResult ReadSectors (uint16 bufferSegment, uint16 bufferOffset, byte drive, const uint64 &sector, uint16 sectorCount, bool silent)
BiosResult ReadSectors (uint16 bufferSegment, uint16 bufferOffset, uint8 drive, const uint64 &sector, uint16 sectorCount, bool silent)
{
return ReadWriteSectors (false, bufferSegment, bufferOffset, drive, sector, sectorCount, silent);
}
BiosResult ReadSectors (byte *buffer, byte drive, const uint64 &sector, uint16 sectorCount, bool silent)
BiosResult ReadSectors (uint8 *buffer, uint8 drive, const uint64 &sector, uint16 sectorCount, bool silent)
{
BiosResult result;
uint16 codeSeg;
@ -274,17 +274,17 @@ BiosResult ReadSectors (byte *buffer, byte drive, const uint64 &sector, uint16 s
}
BiosResult WriteSectors (byte *buffer, byte drive, const uint64 &sector, uint16 sectorCount, bool silent)
BiosResult WriteSectors (uint8 *buffer, uint8 drive, const uint64 &sector, uint16 sectorCount, bool silent)
{
return ReadWriteSectors (true, buffer, drive, sector, sectorCount, silent);
}
BiosResult GetDriveGeometry (byte drive, DriveGeometry &geometry, bool silent)
BiosResult GetDriveGeometry (uint8 drive, DriveGeometry &geometry, bool silent)
{
CheckStack();
byte maxCylinderLow, maxHead, maxSector;
uint8 maxCylinderLow, maxHead, maxSector;
BiosResult result;
__asm
{
@ -329,9 +329,9 @@ void ChsToLba (const DriveGeometry &geometry, const ChsAddress &chs, uint64 &lba
void LbaToChs (const DriveGeometry &geometry, const uint64 &lba, ChsAddress &chs)
{
chs.Sector = (byte) ((lba.LowPart % geometry.Sectors) + 1);
chs.Sector = (uint8) ((lba.LowPart % geometry.Sectors) + 1);
uint32 ch = lba.LowPart / geometry.Sectors;
chs.Head = (byte) (ch % geometry.Heads);
chs.Head = (uint8) (ch % geometry.Heads);
chs.Cylinder = (uint16) (ch / geometry.Heads);
}
@ -349,7 +349,7 @@ void PartitionEntryMBRToPartition (const PartitionEntryMBR &partEntry, Partition
}
BiosResult ReadWriteMBR (bool write, byte drive, bool silent)
BiosResult ReadWriteMBR (bool write, uint8 drive, bool silent)
{
uint64 mbrSector;
mbrSector.HighPart = 0;
@ -362,7 +362,7 @@ BiosResult ReadWriteMBR (bool write, byte drive, bool silent)
}
BiosResult GetDrivePartitions (byte drive, Partition *partitionArray, size_t partitionArrayCapacity, size_t &partitionCount, bool activeOnly, Partition *findPartitionFollowingThis, bool silent)
BiosResult GetDrivePartitions (uint8 drive, Partition *partitionArray, size_t partitionArrayCapacity, size_t &partitionCount, bool activeOnly, Partition *findPartitionFollowingThis, bool silent)
{
Partition *followingPartition;
Partition tmpPartition;
@ -419,7 +419,7 @@ BiosResult GetDrivePartitions (byte drive, Partition *partitionArray, size_t par
MBR *extMbr = (MBR *) SectorBuffer;
while (partitionArrayPos < partitionArrayCapacity &&
(result = ReadSectors ((byte *) extMbr, drive, extStartLBA, 1, silent)) == BiosResultSuccess
(result = ReadSectors ((uint8 *) extMbr, drive, extStartLBA, 1, silent)) == BiosResultSuccess
&& extMbr->Signature == 0xaa55)
{
if (extMbr->Partitions[0].SectorCountLBA > 0)
@ -478,7 +478,7 @@ BiosResult GetDrivePartitions (byte drive, Partition *partitionArray, size_t par
}
bool GetActivePartition (byte drive)
bool GetActivePartition (uint8 drive)
{
size_t partCount;

64
src/Boot/Windows/BootDiskIo.h
View File

@ -28,17 +28,17 @@ enum
struct PartitionEntryMBR
{
byte BootIndicator;
uint8 BootIndicator;
byte StartHead;
byte StartCylSector;
byte StartCylinder;
uint8 StartHead;
uint8 StartCylSector;
uint8 StartCylinder;
byte Type;
uint8 Type;
byte EndHead;
byte EndSector;
byte EndCylinder;
uint8 EndHead;
uint8 EndSector;
uint8 EndCylinder;
uint32 StartLBA;
uint32 SectorCountLBA;
@ -46,15 +46,15 @@ struct PartitionEntryMBR
struct MBR
{
byte Code[446];
uint8 Code[446];
PartitionEntryMBR Partitions[4];
uint16 Signature;
};
struct BiosLbaPacket
{
byte Size;
byte Reserved;
uint8 Size;
uint8 Reserved;
uint16 SectorCount;
uint32 Buffer;
uint64 Sector;
@ -66,27 +66,27 @@ struct BiosLbaPacket
struct ChsAddress
{
uint16 Cylinder;
byte Head;
byte Sector;
uint8 Head;
uint8 Sector;
};
struct Partition
{
byte Number;
byte Drive;
uint8 Number;
uint8 Drive;
bool Active;
uint64 EndSector;
bool Primary;
uint64 SectorCount;
uint64 StartSector;
byte Type;
uint8 Type;
};
struct DriveGeometry
{
uint16 Cylinders;
byte Heads;
byte Sectors;
uint8 Heads;
uint8 Sectors;
};
@ -99,23 +99,23 @@ void ReleaseSectorBuffer ();
#endif
void ChsToLba (const DriveGeometry &geometry, const ChsAddress &chs, uint64 &lba);
bool GetActivePartition (byte drive);
BiosResult GetDriveGeometry (byte drive, DriveGeometry &geometry, bool silent = false);
BiosResult GetDrivePartitions (byte drive, Partition *partitionArray, size_t partitionArrayCapacity, size_t &partitionCount, bool activeOnly = false, Partition *findPartitionFollowingThis = nullptr, bool silent = false);
bool IsLbaSupported (byte drive);
bool GetActivePartition (uint8 drive);
BiosResult GetDriveGeometry (uint8 drive, DriveGeometry &geometry, bool silent = false);
BiosResult GetDrivePartitions (uint8 drive, Partition *partitionArray, size_t partitionArrayCapacity, size_t &partitionCount, bool activeOnly = false, Partition *findPartitionFollowingThis = nullptr, bool silent = false);
bool IsLbaSupported (uint8 drive);
void LbaToChs (const DriveGeometry &geometry, const uint64 &lba, ChsAddress &chs);
void Print (const ChsAddress &chs);
void PrintDiskError (BiosResult error, bool write, byte drive, const uint64 *sector, const ChsAddress *chs = nullptr);
void PrintDiskError (BiosResult error, bool write, uint8 drive, const uint64 *sector, const ChsAddress *chs = nullptr);
void PrintSectorCountInMB (const uint64 &sectorCount);
BiosResult ReadWriteMBR (bool write, byte drive, bool silent = false);
BiosResult ReadSectors (uint16 bufferSegment, uint16 bufferOffset, byte drive, const uint64 &sector, uint16 sectorCount, bool silent = false);
BiosResult ReadSectors (byte *buffer, byte drive, const uint64 &sector, uint16 sectorCount, bool silent = false);
BiosResult ReadSectors (byte *buffer, byte drive, const ChsAddress &chs, byte sectorCount, bool silent = false);
BiosResult ReadWriteSectors (bool write, uint16 bufferSegment, uint16 bufferOffset, byte drive, const uint64 &sector, uint16 sectorCount, bool silent);
BiosResult ReadWriteSectors (bool write, byte *buffer, byte drive, const uint64 &sector, uint16 sectorCount, bool silent);
BiosResult WriteSectors (byte *buffer, byte drive, const uint64 &sector, uint16 sectorCount, bool silent = false);
BiosResult WriteSectors (byte *buffer, byte drive, const ChsAddress &chs, byte sectorCount, bool silent = false);
BiosResult ReadWriteMBR (bool write, uint8 drive, bool silent = false);
BiosResult ReadSectors (uint16 bufferSegment, uint16 bufferOffset, uint8 drive, const uint64 &sector, uint16 sectorCount, bool silent = false);
BiosResult ReadSectors (uint8 *buffer, uint8 drive, const uint64 &sector, uint16 sectorCount, bool silent = false);
BiosResult ReadSectors (uint8 *buffer, uint8 drive, const ChsAddress &chs, uint8 sectorCount, bool silent = false);
BiosResult ReadWriteSectors (bool write, uint16 bufferSegment, uint16 bufferOffset, uint8 drive, const uint64 &sector, uint16 sectorCount, bool silent);
BiosResult ReadWriteSectors (bool write, uint8 *buffer, uint8 drive, const uint64 &sector, uint16 sectorCount, bool silent);
BiosResult WriteSectors (uint8 *buffer, uint8 drive, const uint64 &sector, uint16 sectorCount, bool silent = false);
BiosResult WriteSectors (uint8 *buffer, uint8 drive, const ChsAddress &chs, uint8 sectorCount, bool silent = false);
extern byte SectorBuffer[TC_LB_SIZE];
extern uint8 SectorBuffer[TC_LB_SIZE];
#endif // TC_HEADER_Boot_BootDiskIo

4
src/Boot/Windows/BootEncryptedIo.cpp
View File

@ -19,7 +19,7 @@
#include "BootEncryptedIo.h"
BiosResult ReadEncryptedSectors (uint16 destSegment, uint16 destOffset, byte drive, uint64 sector, uint16 sectorCount)
BiosResult ReadEncryptedSectors (uint16 destSegment, uint16 destOffset, uint8 drive, uint64 sector, uint16 sectorCount)
{
BiosResult result;
bool decrypt = true;
@ -76,7 +76,7 @@ BiosResult ReadEncryptedSectors (uint16 destSegment, uint16 destOffset, byte dri
}
BiosResult WriteEncryptedSectors (uint16 sourceSegment, uint16 sourceOffset, byte drive, uint64 sector, uint16 sectorCount)
BiosResult WriteEncryptedSectors (uint16 sourceSegment, uint16 sourceOffset, uint8 drive, uint64 sector, uint16 sectorCount)
{
BiosResult result = BiosResultSuccess;
AcquireSectorBuffer();

4
src/Boot/Windows/BootEncryptedIo.h
View File

@ -15,8 +15,8 @@
#include "Platform.h"
BiosResult ReadEncryptedSectors (uint16 destSegment, uint16 destOffset, byte drive, uint64 sector, uint16 sectorCount);
BiosResult WriteEncryptedSectors (uint16 sourceSegment, uint16 sourceOffset, byte drive, uint64 sector, uint16 sectorCount);
BiosResult ReadEncryptedSectors (uint16 destSegment, uint16 destOffset, uint8 drive, uint64 sector, uint16 sectorCount);
BiosResult WriteEncryptedSectors (uint16 sourceSegment, uint16 sourceOffset, uint8 drive, uint64 sector, uint16 sectorCount);
static bool ReadWritePartiallyCoversEncryptedArea (const uint64 &sector, uint16 sectorCount);
#endif // TC_HEADER_Boot_BootEncryptionIo

46
src/Boot/Windows/BootMain.cpp
View File

@ -84,7 +84,7 @@ static void PrintMainMenu ()
}
static bool IsMenuKey (byte scanCode)
static bool IsMenuKey (uint8 scanCode)
{
#ifdef TC_WINDOWS_BOOT_RESCUE_DISK_MODE
return scanCode == TC_MENU_KEY_REPAIR;
@ -149,12 +149,12 @@ static int AskSelection (const char *options[], size_t optionCount)
}
static byte AskPassword (Password &password, int& pim)
static uint8 AskPassword (Password &password, int& pim)
{
size_t pos = 0;
byte scanCode;
byte asciiCode;
byte hidePassword = 1;
uint8 scanCode;
uint8 asciiCode;
uint8 hidePassword = 1;
pim = 0;
@ -312,7 +312,7 @@ static byte AskPassword (Password &password, int& pim)
}
static void ExecuteBootSector (byte drive, byte *sectorBuffer)
static void ExecuteBootSector (uint8 drive, uint8 *sectorBuffer)
{
Print ("Booting...\r\n");
CopyMemory (sectorBuffer, 0x0000, 0x7c00, TC_LB_SIZE);
@ -338,7 +338,7 @@ static void ExecuteBootSector (byte drive, byte *sectorBuffer)
}
static bool OpenVolume (byte drive, Password &password, int pim, CRYPTO_INFO **cryptoInfo, uint32 *headerSaltCrc32, bool skipNormal, bool skipHidden)
static bool OpenVolume (uint8 drive, Password &password, int pim, CRYPTO_INFO **cryptoInfo, uint32 *headerSaltCrc32, bool skipNormal, bool skipHidden)
{
int volumeType;
bool hiddenVolume;
@ -420,7 +420,7 @@ static bool CheckMemoryRequirements ()
}
static bool MountVolume (byte drive, byte &exitKey, bool skipNormal, bool skipHidden)
static bool MountVolume (uint8 drive, uint8 &exitKey, bool skipNormal, bool skipHidden)
{
BootArguments *bootArguments = (BootArguments *) TC_BOOT_LOADER_ARGS_OFFSET;
int incorrectPasswordCount = 0, pim = 0;
@ -499,7 +499,7 @@ static bool MountVolume (byte drive, byte &exitKey, bool skipNormal, bool skipHi
}
static bool GetSystemPartitions (byte drive)
static bool GetSystemPartitions (uint8 drive)
{
size_t partCount;
@ -524,10 +524,10 @@ static bool GetSystemPartitions (byte drive)
}
static byte BootEncryptedDrive ()
static uint8 BootEncryptedDrive ()
{
BootArguments *bootArguments = (BootArguments *) TC_BOOT_LOADER_ARGS_OFFSET;
byte exitKey;
uint8 exitKey;
BootCryptoInfo = NULL;
if (!GetSystemPartitions (BootDrive))
@ -556,7 +556,7 @@ static byte BootEncryptedDrive ()
if (!InstallInterruptFilters())
goto err;
bootArguments->BootArgumentsCrc32 = GetCrc32 ((byte *) bootArguments, (byte *) &bootArguments->BootArgumentsCrc32 - (byte *) bootArguments);
bootArguments->BootArgumentsCrc32 = GetCrc32 ((uint8 *) bootArguments, (uint8 *) &bootArguments->BootArgumentsCrc32 - (uint8 *) bootArguments);
while (true)
{
@ -587,7 +587,7 @@ static byte BootEncryptedDrive ()
EncryptedVirtualPartition.Drive = TC_INVALID_BIOS_DRIVE;
EraseMemory ((void *) TC_BOOT_LOADER_ARGS_OFFSET, sizeof (BootArguments));
byte scanCode;
uint8 scanCode;
GetKeyboardChar (&scanCode);
return scanCode;
}
@ -601,7 +601,7 @@ static void BootMenu ()
size_t partitionCount;
size_t bootablePartitionCount = 0;
for (byte drive = TC_FIRST_BIOS_DRIVE; drive <= TC_LAST_BIOS_DRIVE; ++drive)
for (uint8 drive = TC_FIRST_BIOS_DRIVE; drive <= TC_LAST_BIOS_DRIVE; ++drive)
{
if (GetDrivePartitions (drive, partitions, array_capacity (partitions), partitionCount, false, nullptr, true) == BiosResultSuccess)
{
@ -689,7 +689,7 @@ static void BootMenu ()
#ifndef TC_WINDOWS_BOOT_RESCUE_DISK_MODE
static bool CopySystemPartitionToHiddenVolume (byte drive, byte &exitKey)
static bool CopySystemPartitionToHiddenVolume (uint8 drive, uint8 &exitKey)
{
bool status = false;
@ -812,9 +812,9 @@ static bool CopySystemPartitionToHiddenVolume (byte drive, byte &exitKey)
#else // TC_WINDOWS_BOOT_RESCUE_DISK_MODE
static void DecryptDrive (byte drive)
static void DecryptDrive (uint8 drive)
{
byte exitKey;
uint8 exitKey;
if (!MountVolume (drive, exitKey, false, true))
return;
@ -925,7 +925,7 @@ static void DecryptDrive (byte drive)
for (int i = 7; i >= 0; --i)
{
SectorBuffer[TC_HEADER_OFFSET_ENCRYPTED_AREA_LENGTH + i] = (byte) encryptedAreaLength.LowPart;
SectorBuffer[TC_HEADER_OFFSET_ENCRYPTED_AREA_LENGTH + i] = (uint8) encryptedAreaLength.LowPart;
encryptedAreaLength = encryptedAreaLength >> 8;
}
@ -933,7 +933,7 @@ static void DecryptDrive (byte drive)
for (i = 3; i >= 0; --i)
{
SectorBuffer[TC_HEADER_OFFSET_HEADER_CRC + i] = (byte) headerCrc32;
SectorBuffer[TC_HEADER_OFFSET_HEADER_CRC + i] = (uint8) headerCrc32;
headerCrc32 >>= 8;
}
@ -1020,7 +1020,7 @@ static void RepairMenu ()
sector.HighPart = 0;
ChsAddress chs;
byte mbrPartTable[TC_LB_SIZE - TC_MAX_MBR_BOOT_CODE_SIZE];
uint8 mbrPartTable[TC_LB_SIZE - TC_MAX_MBR_BOOT_CODE_SIZE];
AcquireSectorBuffer();
for (int i = (selection == RestoreVolumeHeader ? TC_BOOT_VOLUME_HEADER_SECTOR : TC_MBR_SECTOR);
@ -1073,7 +1073,7 @@ static void RepairMenu ()
Password password;
int pim;
byte exitKey = AskPassword (password, pim);
uint8 exitKey = AskPassword (password, pim);
if (exitKey != TC_BIOS_KEY_ENTER)
goto abort;
@ -1221,13 +1221,13 @@ void main ()
while (true)
{
byte exitKey;
uint8 exitKey;
InitScreen();
#ifndef TC_WINDOWS_BOOT_RESCUE_DISK_MODE
// Hidden system setup
byte hiddenSystemCreationPhase = BootSectorFlags & TC_BOOT_CFG_MASK_HIDDEN_OS_CREATION_PHASE;
uint8 hiddenSystemCreationPhase = BootSectorFlags & TC_BOOT_CFG_MASK_HIDDEN_OS_CREATION_PHASE;
if (hiddenSystemCreationPhase != TC_HIDDEN_OS_CREATION_PHASE_NONE)
{

12
src/Boot/Windows/BootMain.h
View File

@ -16,16 +16,16 @@
#include "TCdefs.h"
#include "Platform.h"
static byte AskPassword (Password &password, int& pim);
static uint8 AskPassword (Password &password, int& pim);
static int AskSelection (const char *options[], size_t optionCount);
static bool AskYesNo (const char *message);
static byte BootEncryptedDrive ();
static uint8 BootEncryptedDrive ();
static void BootMenu ();
static void ExecuteBootSector (byte drive, byte *sectorBuffer);
static void ExecuteBootSector (uint8 drive, uint8 *sectorBuffer);
static void InitScreen ();
static bool IsMenuKey (byte scanCode);
static bool MountVolume (byte drive, byte &exitKey);
static bool OpenVolume (byte drive, Password &password, CRYPTO_INFO **cryptoInfo, uint32 *headerSaltCrc32 = nullptr, bool skipNormal = false, bool skipHidden = false);
static bool IsMenuKey (uint8 scanCode);
static bool MountVolume (uint8 drive, uint8 &exitKey);
static bool OpenVolume (uint8 drive, Password &password, CRYPTO_INFO **cryptoInfo, uint32 *headerSaltCrc32 = nullptr, bool skipNormal = false, bool skipHidden = false);
static void PrintMainMenu ();
static void RepairMenu ();

14
src/Boot/Windows/IntFilter.cpp
View File

@ -38,7 +38,7 @@ bool Int13Filter ()
static int ReEntryCount = -1;
++ReEntryCount;
byte function = (byte) (regs.AX >> 8);
uint8 function = (uint8) (regs.AX >> 8);
#ifdef TC_TRACE_INT13
DisableScreenOutput();
@ -63,14 +63,14 @@ bool Int13Filter ()
case 0x2: // Read sectors
case 0x3: // Write sectors
{
byte drive = (byte) regs.DX;
uint8 drive = (uint8) regs.DX;
ChsAddress chs;
chs.Cylinder = ((regs.CX << 2) & 0x300) | (regs.CX >> 8);
chs.Head = regs.DX >> 8;
chs.Sector = regs.CX & 0x3f;
byte sectorCount = (byte) regs.AX;
uint8 sectorCount = (uint8) regs.AX;
#ifdef TC_TRACE_INT13
PrintVal (": Drive", drive - TC_FIRST_BIOS_DRIVE, false);
@ -125,10 +125,10 @@ bool Int13Filter ()
case 0x42: // Read sectors LBA
case 0x43: // Write sectors LBA
{
byte drive = (byte) regs.DX;
uint8 drive = (uint8) regs.DX;
BiosLbaPacket lba;
CopyMemory (regs.DS, regs.SI, (byte *) &lba, sizeof (lba));
CopyMemory (regs.DS, regs.SI, (uint8 *) &lba, sizeof (lba));
#ifdef TC_TRACE_INT13
PrintVal (": Drive", drive - TC_FIRST_BIOS_DRIVE, false);
@ -337,7 +337,7 @@ bool Int15Filter ()
}
else
{
CopyMemory ((byte *) &BiosMemoryMap[IntRegisters.EBX], IntRegisters.ES, IntRegisters.DI, sizeof (BiosMemoryMap[0]));
CopyMemory ((uint8 *) &BiosMemoryMap[IntRegisters.EBX], IntRegisters.ES, IntRegisters.DI, sizeof (BiosMemoryMap[0]));
IntRegisters.Flags &= ~TC_X86_CARRY_FLAG;
IntRegisters.EAX = 0x534D4150UL;
@ -380,7 +380,7 @@ bool Int15Filter ()
#ifdef TC_TRACE_INT15
BiosMemoryMapEntry entry;
CopyMemory (IntRegisters.ES, IntRegisters.DI, (byte *) &entry, sizeof (entry));
CopyMemory (IntRegisters.ES, IntRegisters.DI, (uint8 *) &entry, sizeof (entry));
PrintHex (entry.Type); PrintChar (' ');
PrintHex (entry.BaseAddress); PrintChar (' ');
PrintHex (entry.Length); PrintChar (' ');

2
src/Boot/Windows/Platform.cpp
View File

@ -84,7 +84,7 @@ uint64 operator>> (const uint64 &a, int shiftCount)
{
r.LowPart >>= 1;
if ((byte) r.HighPart & 1)
if ((uint8) r.HighPart & 1)
r.LowPart |= 0x80000000UL;
r.HighPart >>= 1;

10
src/Common/Apidrvr.h
View File

@ -344,23 +344,23 @@ typedef struct
typedef struct
{
byte Fingerprint[WHIRLPOOL_DIGESTSIZE + SHA512_DIGESTSIZE];
uint8 Fingerprint[WHIRLPOOL_DIGESTSIZE + SHA512_DIGESTSIZE];
} BootLoaderFingerprintRequest;
typedef struct
{
wchar_t DevicePath[TC_MAX_PATH];
byte Configuration;
uint8 Configuration;
BOOL DriveIsDynamic;
uint16 BootLoaderVersion;
byte UserConfiguration;
uint8 UserConfiguration;
char CustomUserMessage[TC_BOOT_SECTOR_USER_MESSAGE_MAX_LENGTH + 1];
} GetSystemDriveConfigurationRequest;
typedef struct
{
WipeAlgorithmId WipeAlgorithm;
CRYPTOPP_ALIGN_DATA(16) byte WipeKey[MASTER_KEYDATA_SIZE];
CRYPTOPP_ALIGN_DATA(16) uint8 WipeKey[MASTER_KEYDATA_SIZE];
} WipeDecoySystemRequest;
typedef struct
@ -373,7 +373,7 @@ typedef struct
typedef struct
{
LARGE_INTEGER Offset;
byte Data[TC_SECTOR_SIZE_BIOS];
uint8 Data[TC_SECTOR_SIZE_BIOS];
} WriteBootDriveSectorRequest;
typedef struct

2
src/Common/BaseCom.cpp
View File

@ -450,7 +450,7 @@ DWORD BaseCom::WriteEfiBootSectorUserConfig (DWORD userConfig, BSTR customUserMe
msg [maxSize - 1] = 0;
std::string msgStr = maxSize > 0 ? msg : "";
BootEncryption bootEnc (NULL);
bootEnc.WriteEfiBootSectorUserConfig ((byte) userConfig, msgStr, pim, hashAlg);
bootEnc.WriteEfiBootSectorUserConfig ((uint8) userConfig, msgStr, pim, hashAlg);
}
catch (SystemException &)
{

216
src/Common/BootEncryption.cpp
View File

@ -275,10 +275,10 @@ bool ZipAdd (zip_t *z, const char* name, const unsigned char* pbData, DWORD cbDa
return true;
}
static BOOL IsWindowsMBR (const byte *buffer, size_t bufferSize)
static BOOL IsWindowsMBR (const uint8 *buffer, size_t bufferSize)
{
BOOL bRet = FALSE;
byte g_pbMsSignature[4] = {0x33, 0xc0, 0x8e, 0xd0};
uint8 g_pbMsSignature[4] = {0x33, 0xc0, 0x8e, 0xd0};
const char* g_szStr1 = "Invalid partition table";
const char* g_szStr2 = "Error loading operating system";
const char* g_szStr3 = "Missing operating system";
@ -390,7 +390,7 @@ namespace VeraCrypt
}
}
static void ReadWriteFile (BOOL write, BOOL device, const wstring &filePath, byte *buffer, uint64 offset, uint32 size, DWORD *sizeDone)
static void ReadWriteFile (BOOL write, BOOL device, const wstring &filePath, uint8 *buffer, uint64 offset, uint32 size, DWORD *sizeDone)
{
Elevate();
@ -631,7 +631,7 @@ namespace VeraCrypt
}
}
static void WriteEfiBootSectorUserConfig (byte userConfig, const string &customUserMessage, int pim, int hashAlg)
static void WriteEfiBootSectorUserConfig (uint8 userConfig, const string &customUserMessage, int pim, int hashAlg)
{
Elevate();
@ -742,7 +742,7 @@ namespace VeraCrypt
public:
static void AddReference () { }
static void CallDriver (DWORD ioctl, void *input, DWORD inputSize, void *output, DWORD outputSize) { throw ParameterIncorrect (SRC_POS); }
static void ReadWriteFile (BOOL write, BOOL device, const wstring &filePath, byte *buffer, uint64 offset, uint32 size, DWORD *sizeDone) { throw ParameterIncorrect (SRC_POS); }
static void ReadWriteFile (BOOL write, BOOL device, const wstring &filePath, uint8 *buffer, uint64 offset, uint32 size, DWORD *sizeDone) { 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); }
@ -752,7 +752,7 @@ namespace VeraCrypt
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 WriteEfiBootSectorUserConfig (byte userConfig, const string &customUserMessage, int pim, int hashAlg) { throw ParameterIncorrect (SRC_POS); }
static void WriteEfiBootSectorUserConfig (uint8 userConfig, const string &customUserMessage, int pim, int hashAlg) { throw ParameterIncorrect (SRC_POS); }
static void UpdateSetupConfigFile (bool bForInstall) { throw ParameterIncorrect (SRC_POS); }
static void GetSecureBootConfig (BOOL* pSecureBootEnabled, BOOL *pVeraCryptKeysLoaded) { throw ParameterIncorrect (SRC_POS); }
};
@ -796,7 +796,7 @@ namespace VeraCrypt
FileOpen = false;
}
DWORD File::Read (byte *buffer, DWORD size)
DWORD File::Read (uint8 *buffer, DWORD size)
{
DWORD bytesRead;
@ -901,7 +901,7 @@ namespace VeraCrypt
dwSize = (DWORD) size64;
}
void File::Write (byte *buffer, DWORD size)
void File::Write (uint8 *buffer, DWORD size)
{
DWORD bytesWritten;
@ -1423,7 +1423,7 @@ namespace VeraCrypt
return version;
}
void BootEncryption::GetInstalledBootLoaderFingerprint (byte fingerprint[WHIRLPOOL_DIGESTSIZE + SHA512_DIGESTSIZE])
void BootEncryption::GetInstalledBootLoaderFingerprint (uint8 fingerprint[WHIRLPOOL_DIGESTSIZE + SHA512_DIGESTSIZE])
{
BootLoaderFingerprintRequest request;
CallDriver (VC_IOCTL_GET_BOOT_LOADER_FINGERPRINT, NULL, 0, &request, sizeof (request));
@ -1485,12 +1485,12 @@ namespace VeraCrypt
}
bool BootEncryption::SystemDriveContainsPartitionType (byte type)
bool BootEncryption::SystemDriveContainsPartitionType (uint8 type)
{
Device device (GetSystemDriveConfiguration().DevicePath, true);
device.CheckOpened (SRC_POS);
byte mbrBuf[TC_SECTOR_SIZE_BIOS];
uint8 mbrBuf[TC_SECTOR_SIZE_BIOS];
device.SeekAt (0);
device.Read (mbrBuf, sizeof (mbrBuf));
@ -1532,7 +1532,7 @@ namespace VeraCrypt
continue;
}
if (SystemDriveContainsPartitionType ((byte) partitionType))
if (SystemDriveContainsPartitionType ((uint8) partitionType))
return true;
}
@ -1650,7 +1650,7 @@ namespace VeraCrypt
}
uint32 BootEncryption::GetChecksum (byte *data, size_t size)
uint32 BootEncryption::GetChecksum (uint8 *data, size_t size)
{
uint32 sum = 0;
@ -1664,7 +1664,7 @@ namespace VeraCrypt
}
void BootEncryption::CreateBootLoaderInMemory (byte *buffer, size_t bufferSize, bool rescueDisk, bool hiddenOSCreation)
void BootEncryption::CreateBootLoaderInMemory (uint8 *buffer, size_t bufferSize, bool rescueDisk, bool hiddenOSCreation)
{
if (bufferSize < TC_BOOT_LOADER_AREA_SIZE - TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE)
throw ParameterIncorrect (SRC_POS);
@ -1809,7 +1809,7 @@ namespace VeraCrypt
// Boot sector
DWORD size;
byte *bootSecResourceImg = MapResource (L"BIN", bootSectorId, &size);
uint8 *bootSecResourceImg = MapResource (L"BIN", bootSectorId, &size);
if (!bootSecResourceImg || size != TC_SECTOR_SIZE_BIOS)
throw ParameterIncorrect (SRC_POS);
@ -1827,7 +1827,7 @@ namespace VeraCrypt
{
Device device (GetSystemDriveConfiguration().DevicePath);
device.CheckOpened (SRC_POS);
byte headerSector[TC_SECTOR_SIZE_BIOS];
uint8 headerSector[TC_SECTOR_SIZE_BIOS];
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));
@ -1836,14 +1836,14 @@ namespace VeraCrypt
}
// Decompressor
byte *decompressor = MapResource (L"BIN", IDR_BOOT_LOADER_DECOMPRESSOR, &size);
uint8 *decompressor = MapResource (L"BIN", IDR_BOOT_LOADER_DECOMPRESSOR, &size);
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
byte *bootLoader = MapResource (L"BIN", bootLoaderId, &size);
uint8 *bootLoader = MapResource (L"BIN", bootLoaderId, &size);
if (!bootLoader || size > TC_MAX_BOOT_LOADER_SECTOR_COUNT * TC_SECTOR_SIZE_BIOS)
throw ParameterIncorrect (SRC_POS);
@ -1869,7 +1869,7 @@ namespace VeraCrypt
}
// return false when the user cancel an elevation request
bool BootEncryption::ReadBootSectorConfig (byte *config, size_t bufLength, byte *userConfig, string *customUserMessage, uint16 *bootLoaderVersion)
bool BootEncryption::ReadBootSectorConfig (uint8 *config, size_t bufLength, uint8 *userConfig, string *customUserMessage, uint16 *bootLoaderVersion)
{
bool bCanceled = false, bExceptionOccured = false;
try
@ -1962,11 +1962,11 @@ namespace VeraCrypt
}
void BootEncryption::WriteBootSectorConfig (const byte newConfig[])
void BootEncryption::WriteBootSectorConfig (const uint8 newConfig[])
{
Device device (GetSystemDriveConfiguration().DevicePath);
device.CheckOpened (SRC_POS);
byte mbr[TC_SECTOR_SIZE_BIOS];
uint8 mbr[TC_SECTOR_SIZE_BIOS];
device.SeekAt (0);
device.Read (mbr, sizeof (mbr));
@ -1976,7 +1976,7 @@ namespace VeraCrypt
device.SeekAt (0);
device.Write (mbr, sizeof (mbr));
byte mbrVerificationBuf[TC_SECTOR_SIZE_BIOS];
uint8 mbrVerificationBuf[TC_SECTOR_SIZE_BIOS];
device.SeekAt (0);
device.Read (mbrVerificationBuf, sizeof (mbr));
@ -1984,7 +1984,7 @@ namespace VeraCrypt
throw ErrorException ("ERROR_MBR_PROTECTED", SRC_POS);
}
void BootEncryption::WriteEfiBootSectorUserConfig (byte userConfig, const string &customUserMessage, int pim, int hashAlg)
void BootEncryption::WriteEfiBootSectorUserConfig (uint8 userConfig, const string &customUserMessage, int pim, int hashAlg)
{
if (!IsAdmin() && IsUacSupported())
{
@ -2003,7 +2003,7 @@ namespace VeraCrypt
}
}
void BootEncryption::WriteBootSectorUserConfig (byte userConfig, const string &customUserMessage, int pim, int hashAlg)
void BootEncryption::WriteBootSectorUserConfig (uint8 userConfig, const string &customUserMessage, int pim, int hashAlg)
{
if (GetSystemDriveConfiguration().SystemPartition.IsGPT)
{
@ -2013,7 +2013,7 @@ namespace VeraCrypt
{
Device device (GetSystemDriveConfiguration().DevicePath);
device.CheckOpened (SRC_POS);
byte mbr[TC_SECTOR_SIZE_BIOS];
uint8 mbr[TC_SECTOR_SIZE_BIOS];
device.SeekAt (0);
device.Read (mbr, sizeof (mbr));
@ -2048,7 +2048,7 @@ namespace VeraCrypt
device.SeekAt (0);
device.Write (mbr, sizeof (mbr));
byte mbrVerificationBuf[TC_SECTOR_SIZE_BIOS];
uint8 mbrVerificationBuf[TC_SECTOR_SIZE_BIOS];
device.SeekAt (0);
device.Read (mbrVerificationBuf, sizeof (mbr));
@ -2060,7 +2060,7 @@ namespace VeraCrypt
unsigned int BootEncryption::GetHiddenOSCreationPhase ()
{
byte configFlags [TC_BOOT_CFG_FLAG_AREA_SIZE];
uint8 configFlags [TC_BOOT_CFG_FLAG_AREA_SIZE];
ReadBootSectorConfig (configFlags, sizeof(configFlags));
@ -2073,11 +2073,11 @@ namespace VeraCrypt
#if TC_BOOT_CFG_FLAG_AREA_SIZE != 1
# error TC_BOOT_CFG_FLAG_AREA_SIZE != 1; revise GetHiddenOSCreationPhase() and SetHiddenOSCreationPhase()
#endif
byte configFlags [TC_BOOT_CFG_FLAG_AREA_SIZE];
uint8 configFlags [TC_BOOT_CFG_FLAG_AREA_SIZE];
ReadBootSectorConfig (configFlags, sizeof(configFlags));
configFlags[0] &= (byte) ~TC_BOOT_CFG_MASK_HIDDEN_OS_CREATION_PHASE;
configFlags[0] &= (uint8) ~TC_BOOT_CFG_MASK_HIDDEN_OS_CREATION_PHASE;
configFlags[0] |= newPhase;
@ -2154,7 +2154,7 @@ namespace VeraCrypt
Device device (GetSystemDriveConfiguration().DevicePath);
device.CheckOpened(SRC_POS);
byte mbr[TC_SECTOR_SIZE_BIOS];
uint8 mbr[TC_SECTOR_SIZE_BIOS];
device.SeekAt (0);
device.Read (mbr, sizeof (mbr));
@ -2171,7 +2171,7 @@ namespace VeraCrypt
# error PRAND_DISK_WIPE_PASSES > RNG_POOL_SIZE
#endif
byte randData[PRAND_DISK_WIPE_PASSES];
uint8 randData[PRAND_DISK_WIPE_PASSES];
if (!RandgetBytes (ParentWindow, randData, sizeof (randData), FALSE))
throw ParameterIncorrect (SRC_POS);
@ -2182,7 +2182,7 @@ namespace VeraCrypt
mbr[TC_BOOT_SECTOR_OUTER_VOLUME_BAK_HEADER_CRC_OFFSET + i] = randData[wipePass];
}
mbr[TC_BOOT_SECTOR_CONFIG_OFFSET] &= (byte) ~TC_BOOT_CFG_MASK_HIDDEN_OS_CREATION_PHASE;
mbr[TC_BOOT_SECTOR_CONFIG_OFFSET] &= (uint8) ~TC_BOOT_CFG_MASK_HIDDEN_OS_CREATION_PHASE;
mbr[TC_BOOT_SECTOR_CONFIG_OFFSET] |= randData[wipePass] & TC_BOOT_CFG_MASK_HIDDEN_OS_CREATION_PHASE;
if (wipePass == PRAND_DISK_WIPE_PASSES - 1)
@ -2384,7 +2384,7 @@ namespace VeraCrypt
if (loaderSize > 32768)
{
std::vector<byte> bootLoaderBuf ((size_t) loaderSize);
std::vector<uint8> bootLoaderBuf ((size_t) loaderSize);
EfiBootInst.ReadFile(L"\\EFI\\Microsoft\\Boot\\bootmgfw.efi", &bootLoaderBuf[0], (DWORD) loaderSize);
@ -2699,8 +2699,8 @@ namespace VeraCrypt
uint32 varSize = 56;
varSize += ((uint32) description.length()) * 2 + 2;
varSize += ((uint32) execPath.length()) * 2 + 2;
byte *startVar = new byte[varSize];
byte *pVar = startVar;
uint8 *startVar = new uint8[varSize];
uint8 *pVar = startVar;
// Attributes (1b Active, 1000b - Hidden)
*(uint32 *)pVar = attr;
@ -2721,12 +2721,12 @@ namespace VeraCrypt
/* EFI_DEVICE_PATH_PROTOCOL (HARDDRIVE_DEVICE_PATH \ FILE_PATH \ END) */
// Type
*(byte *)pVar = 0x04;
pVar += sizeof(byte);
*(uint8 *)pVar = 0x04;
pVar += sizeof(uint8);
// SubType
*(byte *)pVar = 0x01;
pVar += sizeof(byte);
*(uint8 *)pVar = 0x01;
pVar += sizeof(uint8);
// HDD dev path length
*(uint16 *)pVar = 0x2A; // 42
@ -2749,12 +2749,12 @@ namespace VeraCrypt
pVar += 16;
// MbrType
*(byte *)pVar = 0x02;
pVar += sizeof(byte);
*(uint8 *)pVar = 0x02;
pVar += sizeof(uint8);
// SigType
*(byte *)pVar = 0x02;
pVar += sizeof(byte);
*(uint8 *)pVar = 0x02;
pVar += sizeof(uint8);
// Type and sub type 04 04 (file path)
*(uint16 *)pVar = 0x0404;
@ -2781,7 +2781,7 @@ namespace VeraCrypt
StringCchPrintfW(varName, ARRAYSIZE (varName), L"%s%04X", type == NULL ? L"Boot" : type, statrtOrderNum);
// only set value if it doesn't already exist
byte* existingVar = new byte[varSize];
uint8* existingVar = new uint8[varSize];
DWORD existingVarLen = GetFirmwareEnvironmentVariableW (varName, EfiVarGuid, existingVar, varSize);
if ((existingVarLen != varSize) || (0 != memcmp (existingVar, startVar, varSize)))
SetFirmwareEnvironmentVariable(varName, EfiVarGuid, startVar, varSize);
@ -2813,7 +2813,7 @@ namespace VeraCrypt
wchar_t varName[256];
StringCchPrintfW(varName, ARRAYSIZE (varName), L"%s%04X", type == NULL ? L"Boot" : type, startOrder[0]);
byte* existingVar = new byte[512];
uint8* existingVar = new uint8[512];
DWORD existingVarLen = GetFirmwareEnvironmentVariableW (varName, EfiVarGuid, existingVar, 512);
if (existingVarLen > 0)
{
@ -2884,8 +2884,8 @@ namespace VeraCrypt
if (size1 == size2)
{
// same size, so now we compare content
std::vector<byte> file1Buf (8096);
std::vector<byte> file2Buf (8096);
std::vector<uint8> file1Buf (8096);
std::vector<uint8> file2Buf (8096);
DWORD remainingBytes = size1, dataToRead;
while (remainingBytes)
@ -2920,7 +2920,7 @@ namespace VeraCrypt
return bRet;
}
bool EfiBoot::CompareFileData (const wchar_t* fileName, const byte* data, DWORD size)
bool EfiBoot::CompareFileData (const wchar_t* fileName, const uint8* data, DWORD size)
{
bool bRet = false;
@ -2937,7 +2937,7 @@ namespace VeraCrypt
if (existingSize == size)
{
std::vector<byte> fileBuf (8096);
std::vector<uint8> fileBuf (8096);
DWORD remainingBytes = size, dataOffset = 0, dataToRead;
while (remainingBytes)
@ -2971,7 +2971,7 @@ namespace VeraCrypt
return bRet;
}
void EfiBoot::SaveFile(const wchar_t* name, byte* data, DWORD size) {
void EfiBoot::SaveFile(const wchar_t* name, uint8* data, DWORD size) {
wstring path = EfiBootPartPath;
path += name;
@ -3000,7 +3000,7 @@ namespace VeraCrypt
f.Close();
}
void EfiBoot::ReadFile(const wchar_t* name, byte* data, DWORD size) {
void EfiBoot::ReadFile(const wchar_t* name, uint8* data, DWORD size) {
wstring path = EfiBootPartPath;
path += name;
File f(path, true);
@ -3297,51 +3297,51 @@ namespace VeraCrypt
}
DWORD sizeDcsBoot;
#ifdef _WIN64
byte *dcsBootImg = MapResource(L"BIN", IDR_EFI_DCSBOOT, &sizeDcsBoot);
uint8 *dcsBootImg = MapResource(L"BIN", IDR_EFI_DCSBOOT, &sizeDcsBoot);
#else
byte *dcsBootImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_DCSBOOT : IDR_EFI_DCSBOOT32, &sizeDcsBoot);
uint8 *dcsBootImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_DCSBOOT : IDR_EFI_DCSBOOT32, &sizeDcsBoot);
#endif
if (!dcsBootImg)
throw ErrorException(L"Out of resource DcsBoot", SRC_POS);
DWORD sizeDcsInt;
#ifdef _WIN64
byte *dcsIntImg = MapResource(L"BIN", IDR_EFI_DCSINT, &sizeDcsInt);
uint8 *dcsIntImg = MapResource(L"BIN", IDR_EFI_DCSINT, &sizeDcsInt);
#else
byte *dcsIntImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_DCSINT: IDR_EFI_DCSINT32, &sizeDcsInt);
uint8 *dcsIntImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_DCSINT: IDR_EFI_DCSINT32, &sizeDcsInt);
#endif
if (!dcsIntImg)
throw ErrorException(L"Out of resource DcsInt", SRC_POS);
DWORD sizeDcsCfg;
#ifdef _WIN64
byte *dcsCfgImg = MapResource(L"BIN", IDR_EFI_DCSCFG, &sizeDcsCfg);
uint8 *dcsCfgImg = MapResource(L"BIN", IDR_EFI_DCSCFG, &sizeDcsCfg);
#else
byte *dcsCfgImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_DCSCFG: IDR_EFI_DCSCFG32, &sizeDcsCfg);
uint8 *dcsCfgImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_DCSCFG: IDR_EFI_DCSCFG32, &sizeDcsCfg);
#endif
if (!dcsCfgImg)
throw ErrorException(L"Out of resource DcsCfg", SRC_POS);
DWORD sizeLegacySpeaker;
#ifdef _WIN64
byte *LegacySpeakerImg = MapResource(L"BIN", IDR_EFI_LEGACYSPEAKER, &sizeLegacySpeaker);
uint8 *LegacySpeakerImg = MapResource(L"BIN", IDR_EFI_LEGACYSPEAKER, &sizeLegacySpeaker);
#else
byte *LegacySpeakerImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_LEGACYSPEAKER: IDR_EFI_LEGACYSPEAKER32, &sizeLegacySpeaker);
uint8 *LegacySpeakerImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_LEGACYSPEAKER: IDR_EFI_LEGACYSPEAKER32, &sizeLegacySpeaker);
#endif
if (!LegacySpeakerImg)
throw ErrorException(L"Out of resource LegacySpeaker", SRC_POS);
#ifdef VC_EFI_CUSTOM_MODE
DWORD sizeBootMenuLocker;
#ifdef _WIN64
byte *BootMenuLockerImg = MapResource(L"BIN", IDR_EFI_DCSBML, &sizeBootMenuLocker);
uint8 *BootMenuLockerImg = MapResource(L"BIN", IDR_EFI_DCSBML, &sizeBootMenuLocker);
#else
byte *BootMenuLockerImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_DCSBML: IDR_EFI_DCSBML32, &sizeBootMenuLocker);
uint8 *BootMenuLockerImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_DCSBML: IDR_EFI_DCSBML32, &sizeBootMenuLocker);
#endif
if (!BootMenuLockerImg)
throw ErrorException(L"Out of resource DcsBml", SRC_POS);
#endif
DWORD sizeDcsInfo;
#ifdef _WIN64
byte *DcsInfoImg = MapResource(L"BIN", IDR_EFI_DCSINFO, &sizeDcsInfo);
uint8 *DcsInfoImg = MapResource(L"BIN", IDR_EFI_DCSINFO, &sizeDcsInfo);
#else
byte *DcsInfoImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_DCSINFO: IDR_EFI_DCSINFO32, &sizeDcsInfo);
uint8 *DcsInfoImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_DCSINFO: IDR_EFI_DCSINFO32, &sizeDcsInfo);
#endif
if (!DcsInfoImg)
throw ErrorException(L"Out of resource DcsInfo", SRC_POS);
@ -3373,7 +3373,7 @@ namespace VeraCrypt
{
if (loaderSize > 32768)
{
std::vector<byte> bootLoaderBuf ((size_t) loaderSize);
std::vector<uint8> bootLoaderBuf ((size_t) loaderSize);
EfiBootInst.ReadFile(L"\\EFI\\Microsoft\\Boot\\bootmgfw.efi", &bootLoaderBuf[0], (DWORD) loaderSize);
@ -3391,7 +3391,7 @@ namespace VeraCrypt
// DcsBoot.efi is always smaller than 32KB
if (loaderSize > 32768)
{
std::vector<byte> bootLoaderBuf ((size_t) loaderSize);
std::vector<uint8> bootLoaderBuf ((size_t) loaderSize);
EfiBootInst.ReadFile(L"\\EFI\\Microsoft\\Boot\\bootmgfw.efi", &bootLoaderBuf[0], (DWORD) loaderSize);
@ -3420,7 +3420,7 @@ namespace VeraCrypt
{
// look for bootmgfw.efi identifiant string
EfiBootInst.GetFileSize(loaderPath.c_str(), loaderSize);
std::vector<byte> bootLoaderBuf ((size_t) loaderSize);
std::vector<uint8> bootLoaderBuf ((size_t) loaderSize);
EfiBootInst.ReadFile(loaderPath.c_str(), &bootLoaderBuf[0], (DWORD) loaderSize);
@ -3453,7 +3453,7 @@ namespace VeraCrypt
EfiBootInst.GetFileSize(szStdEfiBootloader, loaderSize);
if (loaderSize > 32768)
{
std::vector<byte> bootLoaderBuf ((size_t) loaderSize);
std::vector<uint8> bootLoaderBuf ((size_t) loaderSize);
EfiBootInst.ReadFile(szStdEfiBootloader, &bootLoaderBuf[0], (DWORD) loaderSize);
@ -3487,7 +3487,7 @@ namespace VeraCrypt
// 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);
std::vector<byte> bootLoaderBuf ((size_t) loaderSize);
std::vector<uint8> bootLoaderBuf ((size_t) loaderSize);
EfiBootInst.ReadFile(szStdEfiBootloader, &bootLoaderBuf[0], (DWORD) loaderSize);
// look for bootmgfw.efi or VeraCrypt identifiant strings
@ -3539,11 +3539,11 @@ namespace VeraCrypt
{
try
{
byte bootLoaderBuf[TC_BOOT_LOADER_AREA_SIZE - TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE] = {0};
uint8 bootLoaderBuf[TC_BOOT_LOADER_AREA_SIZE - TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE] = {0};
CreateBootLoaderInMemory (bootLoaderBuf, sizeof (bootLoaderBuf), false, hiddenOSCreation);
// Write MBR
byte mbr[TC_SECTOR_SIZE_BIOS];
uint8 mbr[TC_SECTOR_SIZE_BIOS];
device.SeekAt (0);
device.Read (mbr, sizeof (mbr));
@ -3578,7 +3578,7 @@ namespace VeraCrypt
device.SeekAt (0);
device.Write (mbr, sizeof (mbr));
byte mbrVerificationBuf[TC_SECTOR_SIZE_BIOS];
uint8 mbrVerificationBuf[TC_SECTOR_SIZE_BIOS];
device.SeekAt (0);
device.Read (mbrVerificationBuf, sizeof (mbr));
@ -3620,9 +3620,9 @@ namespace VeraCrypt
if (config.SystemPartition.IsGPT)
return true;
byte bootLoaderBuf[TC_BOOT_LOADER_AREA_SIZE - TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE] = {0};
byte fingerprint[WHIRLPOOL_DIGESTSIZE + SHA512_DIGESTSIZE];
byte expectedFingerprint[WHIRLPOOL_DIGESTSIZE + SHA512_DIGESTSIZE];
uint8 bootLoaderBuf[TC_BOOT_LOADER_AREA_SIZE - TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE] = {0};
uint8 fingerprint[WHIRLPOOL_DIGESTSIZE + SHA512_DIGESTSIZE];
uint8 expectedFingerprint[WHIRLPOOL_DIGESTSIZE + SHA512_DIGESTSIZE];
bool bRet = false;
try
@ -3694,59 +3694,59 @@ namespace VeraCrypt
// create EFI disk structure
DWORD sizeDcsBoot;
#ifdef _WIN64
byte *dcsBootImg = MapResource(L"BIN", IDR_EFI_DCSBOOT, &sizeDcsBoot);
uint8 *dcsBootImg = MapResource(L"BIN", IDR_EFI_DCSBOOT, &sizeDcsBoot);
#else
byte *dcsBootImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_DCSBOOT : IDR_EFI_DCSBOOT32, &sizeDcsBoot);
uint8 *dcsBootImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_DCSBOOT : IDR_EFI_DCSBOOT32, &sizeDcsBoot);
#endif
if (!dcsBootImg)
throw ParameterIncorrect (SRC_POS);
DWORD sizeDcsInt;
#ifdef _WIN64
byte *dcsIntImg = MapResource(L"BIN", IDR_EFI_DCSINT, &sizeDcsInt);
uint8 *dcsIntImg = MapResource(L"BIN", IDR_EFI_DCSINT, &sizeDcsInt);
#else
byte *dcsIntImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_DCSINT: IDR_EFI_DCSINT32, &sizeDcsInt);
uint8 *dcsIntImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_DCSINT: IDR_EFI_DCSINT32, &sizeDcsInt);
#endif
if (!dcsIntImg)
throw ParameterIncorrect (SRC_POS);
DWORD sizeDcsCfg;
#ifdef _WIN64
byte *dcsCfgImg = MapResource(L"BIN", IDR_EFI_DCSCFG, &sizeDcsCfg);
uint8 *dcsCfgImg = MapResource(L"BIN", IDR_EFI_DCSCFG, &sizeDcsCfg);
#else
byte *dcsCfgImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_DCSCFG: IDR_EFI_DCSCFG32, &sizeDcsCfg);
uint8 *dcsCfgImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_DCSCFG: IDR_EFI_DCSCFG32, &sizeDcsCfg);
#endif
if (!dcsCfgImg)
throw ParameterIncorrect (SRC_POS);
DWORD sizeLegacySpeaker;
#ifdef _WIN64
byte *LegacySpeakerImg = MapResource(L"BIN", IDR_EFI_LEGACYSPEAKER, &sizeLegacySpeaker);
uint8 *LegacySpeakerImg = MapResource(L"BIN", IDR_EFI_LEGACYSPEAKER, &sizeLegacySpeaker);
#else
byte *LegacySpeakerImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_LEGACYSPEAKER: IDR_EFI_LEGACYSPEAKER32, &sizeLegacySpeaker);
uint8 *LegacySpeakerImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_LEGACYSPEAKER: IDR_EFI_LEGACYSPEAKER32, &sizeLegacySpeaker);
#endif
if (!LegacySpeakerImg)
throw ParameterIncorrect (SRC_POS);
#ifdef VC_EFI_CUSTOM_MODE
DWORD sizeBootMenuLocker;
#ifdef _WIN64
byte *BootMenuLockerImg = MapResource(L"BIN", IDR_EFI_DCSBML, &sizeBootMenuLocker);
uint8 *BootMenuLockerImg = MapResource(L"BIN", IDR_EFI_DCSBML, &sizeBootMenuLocker);
#else
byte *BootMenuLockerImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_DCSBML: IDR_EFI_DCSBML32, &sizeBootMenuLocker);
uint8 *BootMenuLockerImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_DCSBML: IDR_EFI_DCSBML32, &sizeBootMenuLocker);
#endif
if (!BootMenuLockerImg)
throw ParameterIncorrect (SRC_POS);
#endif
DWORD sizeDcsRescue;
#ifdef _WIN64
byte *DcsRescueImg = MapResource(L"BIN", IDR_EFI_DCSRE, &sizeDcsRescue);
uint8 *DcsRescueImg = MapResource(L"BIN", IDR_EFI_DCSRE, &sizeDcsRescue);
#else
byte *DcsRescueImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_DCSRE: IDR_EFI_DCSRE32, &sizeDcsRescue);
uint8 *DcsRescueImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_DCSRE: IDR_EFI_DCSRE32, &sizeDcsRescue);
#endif
if (!DcsRescueImg)
throw ParameterIncorrect (SRC_POS);
DWORD sizeDcsInfo;
#ifdef _WIN64
byte *DcsInfoImg = MapResource(L"BIN", IDR_EFI_DCSINFO, &sizeDcsInfo);
uint8 *DcsInfoImg = MapResource(L"BIN", IDR_EFI_DCSINFO, &sizeDcsInfo);
#else
byte *DcsInfoImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_DCSINFO: IDR_EFI_DCSINFO32, &sizeDcsInfo);
uint8 *DcsInfoImg = MapResource(L"BIN", Is64BitOs()? IDR_EFI_DCSINFO: IDR_EFI_DCSINFO32, &sizeDcsInfo);
#endif
if (!DcsInfoImg)
throw ParameterIncorrect (SRC_POS);
@ -3866,7 +3866,7 @@ namespace VeraCrypt
finally_do_arg (FILE*, ftmpFile, { fclose (finally_arg); });
unsigned long ulZipSize = (unsigned long) _filelength (_fileno (ftmpFile));
RescueZipData = new byte[ulZipSize];
RescueZipData = new uint8[ulZipSize];
if (!RescueZipData)
throw bad_alloc();
@ -3889,7 +3889,7 @@ namespace VeraCrypt
{
Buffer imageBuf (RescueIsoImageSize);
byte *image = imageBuf.Ptr();
uint8 *image = imageBuf.Ptr();
memset (image, 0, RescueIsoImageSize);
// Primary volume descriptor
@ -3997,7 +3997,7 @@ namespace VeraCrypt
// Boot loader backup
CreateBootLoaderInMemory (image + TC_CD_BOOTSECTOR_OFFSET + TC_BOOT_LOADER_BACKUP_RESCUE_DISK_SECTOR_OFFSET, TC_BOOT_LOADER_AREA_SIZE, false);
RescueIsoImage = new byte[RescueIsoImageSize];
RescueIsoImage = new uint8[RescueIsoImageSize];
if (!RescueIsoImage)
throw bad_alloc();
memcpy (RescueIsoImage, image, RescueIsoImageSize);
@ -4370,7 +4370,7 @@ namespace VeraCrypt
if (GetHeaderField32 (RescueVolumeHeader, TC_HEADER_OFFSET_MAGIC) != 0x56455241)
throw ParameterIncorrect (SRC_POS);
byte *fieldPos = RescueVolumeHeader + TC_HEADER_OFFSET_ENCRYPTED_AREA_LENGTH;
uint8 *fieldPos = RescueVolumeHeader + TC_HEADER_OFFSET_ENCRYPTED_AREA_LENGTH;
mputInt64 (fieldPos, volumeSize);
// CRC of the header fields
@ -4394,7 +4394,7 @@ namespace VeraCrypt
device.CheckOpened (SRC_POS);
device.SeekAt (TC_BOOT_VOLUME_HEADER_SECTOR_OFFSET);
device.Write ((byte *) VolumeHeader, sizeof (VolumeHeader));
device.Write ((uint8 *) VolumeHeader, sizeof (VolumeHeader));
}
@ -4435,7 +4435,7 @@ namespace VeraCrypt
}
}
unsigned __int64 loaderSize = 0;
std::vector<byte> bootLoaderBuf;
std::vector<uint8> bootLoaderBuf;
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";
@ -4495,7 +4495,7 @@ namespace VeraCrypt
{
Device device (GetSystemDriveConfiguration().DevicePath, true);
device.CheckOpened (SRC_POS);
byte bootLoaderBuf[TC_BOOT_LOADER_AREA_SECTOR_COUNT * TC_SECTOR_SIZE_BIOS];
uint8 bootLoaderBuf[TC_BOOT_LOADER_AREA_SECTOR_COUNT * TC_SECTOR_SIZE_BIOS];
device.SeekAt (0);
device.Read (bootLoaderBuf, sizeof (bootLoaderBuf));
@ -4558,7 +4558,7 @@ namespace VeraCrypt
const char* g_szMsBootString = "bootmgfw.pdb";
unsigned __int64 loaderSize = 0;
EfiBootInst.GetFileSize(loaderPath.c_str(), loaderSize);
std::vector<byte> bootLoaderBuf ((size_t) loaderSize);
std::vector<uint8> bootLoaderBuf ((size_t) loaderSize);
EfiBootInst.ReadFile(loaderPath.c_str(), &bootLoaderBuf[0], (DWORD) loaderSize);
@ -4592,7 +4592,7 @@ namespace VeraCrypt
}
else
{
byte bootLoaderBuf[TC_BOOT_LOADER_AREA_SECTOR_COUNT * TC_SECTOR_SIZE_BIOS];
uint8 bootLoaderBuf[TC_BOOT_LOADER_AREA_SECTOR_COUNT * TC_SECTOR_SIZE_BIOS];
File backupFile (GetSystemLoaderBackupPath(), true);
backupFile.CheckOpened(SRC_POS);
@ -4603,7 +4603,7 @@ namespace VeraCrypt
device.CheckOpened (SRC_POS);
// Preserve current partition table
byte mbr[TC_SECTOR_SIZE_BIOS];
uint8 mbr[TC_SECTOR_SIZE_BIOS];
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);
@ -4743,7 +4743,7 @@ namespace VeraCrypt
// Register class filter below all other filters in the stack
size_t strSize = filter.size() + 1;
byte regKeyBuf[65536];
uint8 regKeyBuf[65536];
DWORD size = (DWORD) (sizeof (regKeyBuf) - strSize);
// SetupInstallFromInfSection() does not support prepending of values so we have to modify the registry directly
@ -4761,8 +4761,8 @@ namespace VeraCrypt
// read initial value
DWORD strSize = (DWORD) filter.size() + 1, expectedSize;
Buffer expectedRegKeyBuf(65536), outputRegKeyBuf(65536);
byte* pbExpectedRegKeyBuf = expectedRegKeyBuf.Ptr ();
byte* pbOutputRegKeyBuf = outputRegKeyBuf.Ptr ();
uint8* pbExpectedRegKeyBuf = expectedRegKeyBuf.Ptr ();
uint8* pbOutputRegKeyBuf = outputRegKeyBuf.Ptr ();
DWORD initialSize = (DWORD) (expectedRegKeyBuf.Size() - strSize - 2);
if (RegQueryValueExA (regKey, filterReg.c_str(), NULL, NULL, pbExpectedRegKeyBuf, &initialSize) != ERROR_SUCCESS)
@ -4814,7 +4814,7 @@ namespace VeraCrypt
// remove value in case it was not done properly
Buffer regKeyBuf(65536);
byte* pbRegKeyBuf = regKeyBuf.Ptr ();
uint8* pbRegKeyBuf = regKeyBuf.Ptr ();
DWORD initialSize = (DWORD) regKeyBuf.Size() - 2;
@ -5302,12 +5302,12 @@ namespace VeraCrypt
// Verify CRC of header salt
Device device(config.DevicePath, true);
device.CheckOpened(SRC_POS);
byte header[TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE];
uint8 header[TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE];
device.SeekAt(TC_BOOT_VOLUME_HEADER_SECTOR_OFFSET);
device.Read(header, sizeof(header));
if (encStatus.VolumeHeaderSaltCrc32 != GetCrc32((byte *)header, PKCS5_SALT_SIZE))
if (encStatus.VolumeHeaderSaltCrc32 != GetCrc32((uint8 *)header, PKCS5_SALT_SIZE))
throw ParameterIncorrect(SRC_POS);
}
}
@ -5394,7 +5394,7 @@ namespace VeraCrypt
}
device.SeekAt (headerOffset);
device.Read ((byte *) header, sizeof (header));
device.Read ((uint8 *) header, sizeof (header));
PCRYPTO_INFO cryptoInfo = NULL;
@ -5482,7 +5482,7 @@ namespace VeraCrypt
}
device.SeekAt (headerOffset);
device.Write ((byte *) header, sizeof (header));
device.Write ((uint8 *) header, sizeof (header));
headerUpdated = true;
}
@ -5513,7 +5513,7 @@ namespace VeraCrypt
try
{
// check if PIM is stored in MBR
byte userConfig = 0;
uint8 userConfig = 0;
if ( ReadBootSectorConfig (nullptr, 0, &userConfig)
&& (userConfig & TC_BOOT_USER_CFG_FLAG_DISABLE_PIM)
)
@ -5790,7 +5790,7 @@ namespace VeraCrypt
return configMap;
}
void BootEncryption::WriteBootDriveSector (uint64 offset, byte *data)
void BootEncryption::WriteBootDriveSector (uint64 offset, uint8 *data)
{
WriteBootDriveSectorRequest request;
request.Offset.QuadPart = offset;

62
src/Common/BootEncryption.h
View File

@ -37,8 +37,8 @@ namespace VeraCrypt
bool IsOpened () const { return FileOpen;}
void CheckOpened (const char* srcPos) { if (!FileOpen) { SetLastError (LastError); throw SystemException (srcPos);} }
void Close ();
DWORD Read (byte *buffer, DWORD size);
void Write (byte *buffer, DWORD size);
DWORD Read (uint8 *buffer, DWORD size);
void Write (uint8 *buffer, DWORD size);
void SeekAt (int64 position);
void GetFileSize (unsigned __int64& size);
void GetFileSize (DWORD& dwSize);
@ -70,19 +70,19 @@ namespace VeraCrypt
public:
Buffer (size_t size) : DataSize (size)
{
DataPtr = new byte[size];
DataPtr = new uint8[size];
if (!DataPtr)
throw bad_alloc();
}
~Buffer () { delete[] DataPtr; }
byte *Ptr () const { return DataPtr; }
uint8 *Ptr () const { return DataPtr; }
size_t Size () const { return DataSize; }
void Resize (size_t newSize)
{
if (newSize > DataSize)
{
byte *tmp = new byte[newSize];
uint8 *tmp = new uint8[newSize];
if (!tmp)
throw bad_alloc();
memcpy (tmp, DataPtr, DataSize);
@ -93,7 +93,7 @@ namespace VeraCrypt
}
protected:
byte *DataPtr;
uint8 *DataPtr;
size_t DataSize;
};
@ -115,17 +115,17 @@ namespace VeraCrypt
struct PartitionEntryMBR
{
byte BootIndicator;
uint8 BootIndicator;
byte StartHead;
byte StartCylSector;
byte StartCylinder;
uint8 StartHead;
uint8 StartCylSector;
uint8 StartCylinder;
byte Type;
uint8 Type;
byte EndHead;
byte EndSector;
byte EndCylinder;
uint8 EndHead;
uint8 EndSector;
uint8 EndCylinder;
uint32 StartLBA;
uint32 SectorCountLBA;
@ -133,7 +133,7 @@ namespace VeraCrypt
struct MBR
{
byte Code[446];
uint8 Code[446];
PartitionEntryMBR Partitions[4];
uint16 Signature;
};
@ -200,13 +200,13 @@ namespace VeraCrypt
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 SaveFile(const wchar_t* name, byte* data, DWORD size);
void SaveFile(const wchar_t* name, uint8* data, DWORD size);
void GetFileSize(const wchar_t* name, unsigned __int64& size);
void ReadFile(const wchar_t* name, byte* data, DWORD size);
void ReadFile(const wchar_t* name, uint8* data, DWORD 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);
static bool CompareFileData (const wchar_t* fileName, const byte* data, DWORD size);
static bool CompareFileData (const wchar_t* fileName, const uint8* data, DWORD size);
BOOL RenameFile(const wchar_t* name, const wchar_t* nameNew, BOOL bForce);
BOOL DelFile(const wchar_t* name);
@ -258,7 +258,7 @@ namespace VeraCrypt
DWORD GetDriverServiceStartType ();
unsigned int GetHiddenOSCreationPhase ();
uint16 GetInstalledBootLoaderVersion ();
void GetInstalledBootLoaderFingerprint (byte fingerprint[WHIRLPOOL_DIGESTSIZE + SHA512_DIGESTSIZE]);
void GetInstalledBootLoaderFingerprint (uint8 fingerprint[WHIRLPOOL_DIGESTSIZE + SHA512_DIGESTSIZE]);
Partition GetPartitionForHiddenOS ();
bool IsBootLoaderOnDrive (wchar_t *devicePath);
BootEncryptionStatus GetStatus ();
@ -275,7 +275,7 @@ namespace VeraCrypt
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 ();
bool ReadBootSectorConfig (byte *config, size_t bufLength, byte *userConfig = nullptr, string *customUserMessage = nullptr, uint16 *bootLoaderVersion = nullptr);
bool ReadBootSectorConfig (uint8 *config, size_t bufLength, uint8 *userConfig = nullptr, string *customUserMessage = nullptr, uint16 *bootLoaderVersion = nullptr);
uint32 ReadDriverConfigurationFlags ();
uint32 ReadServiceConfigurationFlags ();
void RegisterBootDriver (bool hiddenSystem);
@ -295,7 +295,7 @@ namespace VeraCrypt
void StartDecryption (BOOL discardUnreadableEncryptedSectors);
void StartDecoyOSWipe (WipeAlgorithmId wipeAlgorithm);
void StartEncryption (WipeAlgorithmId wipeAlgorithm, bool zeroUnreadableSectors);
bool SystemDriveContainsPartitionType (byte type);
bool SystemDriveContainsPartitionType (uint8 type);
bool SystemDriveContainsExtendedPartition ();
bool SystemDriveContainsNonStandardPartitions ();
bool SystemPartitionCoversWholeDrive ();
@ -303,10 +303,10 @@ namespace VeraCrypt
bool VerifyRescueDisk ();
bool VerifyRescueDiskImage (const wchar_t* imageFile);
void WipeHiddenOSCreationConfig ();
void WriteBootDriveSector (uint64 offset, byte *data);
void WriteBootSectorConfig (const byte newConfig[]);
void WriteBootSectorUserConfig (byte userConfig, const string &customUserMessage, int pim, int hashAlg);
void WriteEfiBootSectorUserConfig (byte userConfig, const string &customUserMessage, int pim, int hashAlg);
void WriteBootDriveSector (uint64 offset, uint8 *data);
void WriteBootSectorConfig (const uint8 newConfig[]);
void WriteBootSectorUserConfig (uint8 userConfig, const string &customUserMessage, int pim, int hashAlg);
void WriteEfiBootSectorUserConfig (uint8 userConfig, const string &customUserMessage, int pim, int hashAlg);
void WriteLocalMachineRegistryDwordValue (wchar_t *keyPath, wchar_t *valueName, DWORD value);
void GetEfiBootDeviceNumber (PSTORAGE_DEVICE_NUMBER pSdn);
void BackupSystemLoader ();
@ -318,10 +318,10 @@ namespace VeraCrypt
protected:
static const uint32 RescueIsoImageSize = 1835008; // Size of ISO9660 image with bootable emulated 1.44MB floppy disk image
void CreateBootLoaderInMemory (byte *buffer, size_t bufferSize, bool rescueDisk, bool hiddenOSCreation = false);
void CreateBootLoaderInMemory (uint8 *buffer, size_t bufferSize, bool rescueDisk, bool hiddenOSCreation = false);
void CreateVolumeHeader (uint64 volumeSize, uint64 encryptedAreaStart, Password *password, int ea, int mode, int pkcs5, int pim);
wstring GetSystemLoaderBackupPath ();
uint32 GetChecksum (byte *data, size_t size);
uint32 GetChecksum (uint8 *data, size_t size);
DISK_GEOMETRY_EX GetDriveGeometry (int driveNumber);
PartitionList GetDrivePartitions (int driveNumber);
wstring GetRemarksOnHiddenOS ();
@ -334,11 +334,11 @@ namespace VeraCrypt
int SelectedEncryptionAlgorithmId;
int SelectedPrfAlgorithmId;
Partition HiddenOSCandidatePartition;
byte *RescueIsoImage;
byte *RescueZipData;
uint8 *RescueIsoImage;
uint8 *RescueZipData;
unsigned long RescueZipSize;
byte RescueVolumeHeader[TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE];
byte VolumeHeader[TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE];
uint8 RescueVolumeHeader[TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE];
uint8 VolumeHeader[TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE];
bool DriveConfigValid;
bool RealSystemDriveSizeValid;
bool RescueVolumeHeaderValid;

66
src/Common/CommandAPDU.cpp
View File

@ -116,7 +116,7 @@ namespace VeraCrypt
clear();
}
void CommandAPDU::init(byte cla, byte ins, byte p1, byte p2, const byte* data, uint32 dataOffset, uint32 dataLength, uint32 ne)
void CommandAPDU::init(uint8 cla, uint8 ins, uint8 p1, uint8 p2, const uint8* data, uint32 dataOffset, uint32 dataLength, uint32 ne)
{
m_nc = 0;
m_ne = 0;
@ -156,7 +156,7 @@ namespace VeraCrypt
{
// case 2s
// 256 is encoded as 0x00
byte len = (m_ne != 256) ? (byte)m_ne : 0;
uint8 len = (m_ne != 256) ? (uint8)m_ne : 0;
m_apdu.resize(5, 0);
setHeader(cla, ins, p1, p2);
m_apdu[4] = len;
@ -164,7 +164,7 @@ namespace VeraCrypt
else
{
// case 2e
byte l1, l2;
uint8 l1, l2;
// 65536 is encoded as 0x00 0x00
if (m_ne == 65536)
{
@ -173,8 +173,8 @@ namespace VeraCrypt
}
else
{
l1 = (byte)(m_ne >> 8);
l2 = (byte)m_ne;
l1 = (uint8)(m_ne >> 8);
l2 = (uint8)m_ne;
}
m_apdu.resize(7, 0);
setHeader(cla, ins, p1, p2);
@ -194,7 +194,7 @@ namespace VeraCrypt
// case 3s
m_apdu.resize(4 + 1 + dataLength, 0);
setHeader(cla, ins, p1, p2);
m_apdu[4] = (byte)dataLength;
m_apdu[4] = (uint8)dataLength;
m_dataOffset = 5;
memcpy(m_apdu.data() + 5, data + dataOffset, dataLength);
}
@ -204,8 +204,8 @@ namespace VeraCrypt
m_apdu.resize(4 + 3 + dataLength, 0);
setHeader(cla, ins, p1, p2);
m_apdu[4] = 0;
m_apdu[5] = (byte)(dataLength >> 8);
m_apdu[6] = (byte)dataLength;
m_apdu[5] = (uint8)(dataLength >> 8);
m_apdu[6] = (uint8)dataLength;
m_dataOffset = 7;
memcpy(m_apdu.data() + 7, data + dataOffset, dataLength);
m_isExtendedAPDU = true;
@ -219,10 +219,10 @@ namespace VeraCrypt
// case 4s
m_apdu.resize(4 + 2 + dataLength, 0);
setHeader(cla, ins, p1, p2);
m_apdu[4] = (byte)dataLength;
m_apdu[4] = (uint8)dataLength;
m_dataOffset = 5;
memcpy(m_apdu.data() + 5, data + dataOffset, dataLength);
m_apdu[m_apdu.size() - 1] = (m_ne != 256) ? (byte)m_ne : 0;
m_apdu[m_apdu.size() - 1] = (m_ne != 256) ? (uint8)m_ne : 0;
}
else
{
@ -230,15 +230,15 @@ namespace VeraCrypt
m_apdu.resize(4 + 5 + dataLength, 0);
setHeader(cla, ins, p1, p2);
m_apdu[4] = 0;
m_apdu[5] = (byte)(dataLength >> 8);
m_apdu[6] = (byte)dataLength;
m_apdu[5] = (uint8)(dataLength >> 8);
m_apdu[6] = (uint8)dataLength;
m_dataOffset = 7;
memcpy(m_apdu.data() + 7, data + dataOffset, dataLength);
if (ne != 65536)
{
size_t leOfs = m_apdu.size() - 2;
m_apdu[leOfs] = (byte)(m_ne >> 8);
m_apdu[leOfs + 1] = (byte)m_ne;
m_apdu[leOfs] = (uint8)(m_ne >> 8);
m_apdu[leOfs + 1] = (uint8)m_ne;
} // else le == 65536: no need to fill in, encoded as 0
m_isExtendedAPDU = true;
}
@ -248,12 +248,12 @@ namespace VeraCrypt
m_parsedSuccessfully = true;
}
void CommandAPDU::setHeader(byte cla, byte ins, byte p1, byte p2)
void CommandAPDU::setHeader(uint8 cla, uint8 ins, uint8 p1, uint8 p2)
{
m_apdu[0] = (byte)cla;
m_apdu[1] = (byte)ins;
m_apdu[2] = (byte)p1;
m_apdu[3] = (byte)p2;
m_apdu[0] = (uint8)cla;
m_apdu[1] = (uint8)ins;
m_apdu[2] = (uint8)p1;
m_apdu[3] = (uint8)p2;
}
void CommandAPDU::clear()
@ -264,58 +264,58 @@ namespace VeraCrypt
m_dataOffset = 0;
}
CommandAPDU::CommandAPDU(byte cla, byte ins, byte p1, byte p2, const byte* data, uint32 dataOffset, uint32 dataLength, uint32 ne)
CommandAPDU::CommandAPDU(uint8 cla, uint8 ins, uint8 p1, uint8 p2, const uint8* data, uint32 dataOffset, uint32 dataLength, uint32 ne)
{
init(cla, ins, p1, p2, data, dataOffset, dataLength, ne);
}
CommandAPDU::CommandAPDU(byte cla, byte ins, byte p1, byte p2)
CommandAPDU::CommandAPDU(uint8 cla, uint8 ins, uint8 p1, uint8 p2)
{
init(cla, ins, p1, p2, NULL, 0, 0, 0);
}
CommandAPDU::CommandAPDU(byte cla, byte ins, byte p1, byte p2, uint32 ne)
CommandAPDU::CommandAPDU(uint8 cla, uint8 ins, uint8 p1, uint8 p2, uint32 ne)
{
init(cla, ins, p1, p2, NULL, 0, 0, ne);
}
CommandAPDU::CommandAPDU(byte cla, byte ins, byte p1, byte p2, const vector<byte>& data)
CommandAPDU::CommandAPDU(uint8 cla, uint8 ins, uint8 p1, uint8 p2, const vector<uint8>& data)
{
init(cla, ins, p1, p2, data.data(), 0, (uint32)data.size(), 0);
}
CommandAPDU::CommandAPDU(byte cla, byte ins, byte p1, byte p2, const byte* data, uint32 dataOffset, uint32 dataLength)
CommandAPDU::CommandAPDU(uint8 cla, uint8 ins, uint8 p1, uint8 p2, const uint8* data, uint32 dataOffset, uint32 dataLength)
{
init(cla, ins, p1, p2, data, dataOffset, dataLength, 0);
}
CommandAPDU::CommandAPDU(byte cla, byte ins, byte p1, byte p2, const vector<byte>& data, uint32 ne)
CommandAPDU::CommandAPDU(uint8 cla, uint8 ins, uint8 p1, uint8 p2, const vector<uint8>& data, uint32 ne)
{
init(cla, ins, p1, p2, data.data(), 0, (uint32)data.size(), ne);
}
CommandAPDU::CommandAPDU(const vector<byte>& apdu) : m_nc(0), m_ne(0), m_dataOffset(0), m_isExtendedAPDU(false)
CommandAPDU::CommandAPDU(const vector<uint8>& apdu) : m_nc(0), m_ne(0), m_dataOffset(0), m_isExtendedAPDU(false)
{
m_apdu = apdu;
parse();
}
byte CommandAPDU::getCLA()
uint8 CommandAPDU::getCLA()
{
return m_apdu[0] & 0xff;
}
byte CommandAPDU::getINS()
uint8 CommandAPDU::getINS()
{
return m_apdu[1] & 0xff;
}
byte CommandAPDU::getP1()
uint8 CommandAPDU::getP1()
{
return m_apdu[2] & 0xff;
}
byte CommandAPDU::getP2()
uint8 CommandAPDU::getP2()
{
return m_apdu[3] & 0xff;
}
@ -325,9 +325,9 @@ namespace VeraCrypt
return m_nc;
}
const vector<byte> CommandAPDU::getData()
const vector<uint8> CommandAPDU::getData()
{
vector<byte> data;
vector<uint8> data;
if (m_nc > 0)
{
@ -343,7 +343,7 @@ namespace VeraCrypt
return m_ne;
}
const vector<byte> CommandAPDU::getAPDU()
const vector<uint8> CommandAPDU::getAPDU()
{
return m_apdu;
}

32
src/Common/CommandAPDU.h
View File

@ -34,7 +34,7 @@ namespace VeraCrypt
{
protected:
vector<byte> m_apdu;
vector<uint8> m_apdu;
uint32 m_nc;
uint32 m_ne;
uint32 m_dataOffset;
@ -43,8 +43,8 @@ namespace VeraCrypt
bool m_parsedSuccessfully;
void parse();
void init(byte cla, byte ins, byte p1, byte p2, const byte* data, uint32 dataOffset, uint32 dataLength, uint32 ne);
void setHeader(byte cla, byte ins, byte p1, byte p2);
void init(uint8 cla, uint8 ins, uint8 p1, uint8 p2, const uint8* data, uint32 dataOffset, uint32 dataLength, uint32 ne);
void setHeader(uint8 cla, uint8 ins, uint8 p1, uint8 p2);
public:
@ -52,35 +52,35 @@ namespace VeraCrypt
CommandAPDU();
CommandAPDU(byte cla, byte ins, byte p1, byte p2, const byte* data, uint32 dataOffset, uint32 dataLength, uint32 ne);
CommandAPDU(uint8 cla, uint8 ins, uint8 p1, uint8 p2, const uint8* data, uint32 dataOffset, uint32 dataLength, uint32 ne);
CommandAPDU(byte cla, byte ins, byte p1, byte p2);
CommandAPDU(uint8 cla, uint8 ins, uint8 p1, uint8 p2);
CommandAPDU(byte cla, byte ins, byte p1, byte p2, uint32 ne);
CommandAPDU(uint8 cla, uint8 ins, uint8 p1, uint8 p2, uint32 ne);
CommandAPDU(byte cla, byte ins, byte p1, byte p2, const vector<byte>& data);
CommandAPDU(uint8 cla, uint8 ins, uint8 p1, uint8 p2, const vector<uint8>& data);
CommandAPDU(byte cla, byte ins, byte p1, byte p2, const byte* data, uint32 dataOffset, uint32 dataLength);
CommandAPDU(uint8 cla, uint8 ins, uint8 p1, uint8 p2, const uint8* data, uint32 dataOffset, uint32 dataLength);
CommandAPDU(byte cla, byte ins, byte p1, byte p2, const vector<byte>& data, uint32 ne);
CommandAPDU(uint8 cla, uint8 ins, uint8 p1, uint8 p2, const vector<uint8>& data, uint32 ne);
CommandAPDU(const vector<byte>& apdu);
CommandAPDU(const vector<uint8>& apdu);
byte getCLA();
uint8 getCLA();
byte getINS();
uint8 getINS();
byte getP1();
uint8 getP1();
byte getP2();
uint8 getP2();
uint32 getNc();
const vector<byte> getData();
const vector<uint8> getData();
uint32 getNe();
const vector<byte> getAPDU();
const vector<uint8> getAPDU();
bool isValid();

40
src/Common/Crypto.c
View File

@ -219,7 +219,7 @@ void EncipherBlock(int cipher, void *data, void *ks)
void EncipherBlocks (int cipher, void *dataPtr, void *ks, size_t blockCount)
{
byte *data = dataPtr;
uint8 *data = dataPtr;
#if defined (TC_WINDOWS_DRIVER) && !defined (_WIN64)
KFLOATING_SAVE floatingPointState;
#endif
@ -317,7 +317,7 @@ void DecipherBlock(int cipher, void *data, void *ks)
case AES:
#if defined (_WIN64) || !defined (TC_WINDOWS_DRIVER)
if (IsAesHwCpuSupported())
aes_hw_cpu_decrypt ((byte *) ks + sizeof (aes_encrypt_ctx), data);
aes_hw_cpu_decrypt ((uint8 *) ks + sizeof (aes_encrypt_ctx), data);
else
#endif
aes_decrypt (data, data, (void *) ((char *) ks + sizeof(aes_encrypt_ctx)));
@ -334,7 +334,7 @@ void DecipherBlock(int cipher, void *data, void *ks)
void DecipherBlocks (int cipher, void *dataPtr, void *ks, size_t blockCount)
{
byte *data = dataPtr;
uint8 *data = dataPtr;
#if defined (TC_WINDOWS_DRIVER) && !defined (_WIN64)
KFLOATING_SAVE floatingPointState;
#endif
@ -349,7 +349,7 @@ void DecipherBlocks (int cipher, void *dataPtr, void *ks, size_t blockCount)
{
while (blockCount > 0)
{
aes_hw_cpu_decrypt_32_blocks ((byte *) ks + sizeof (aes_encrypt_ctx), data);
aes_hw_cpu_decrypt_32_blocks ((uint8 *) ks + sizeof (aes_encrypt_ctx), data);
data += 32 * 16;
blockCount -= 32;
@ -855,7 +855,7 @@ int GetMaxPkcs5OutSize (void)
#ifdef TC_WINDOWS_BOOT
static byte CryptoInfoBufferInUse = 0;
static uint8 CryptoInfoBufferInUse = 0;
CRYPTO_INFO CryptoInfoBuffer;
#endif
@ -1118,7 +1118,7 @@ void EncipherBlock(int cipher, void *data, void *ks)
{
#ifdef TC_WINDOWS_BOOT_AES
if (IsAesHwCpuSupported())
aes_hw_cpu_encrypt ((byte *) ks, data);
aes_hw_cpu_encrypt ((uint8 *) ks, data);
else
aes_encrypt (data, data, ks);
#elif defined (TC_WINDOWS_BOOT_SERPENT) && !defined (WOLFCRYPT_BACKEND)
@ -1134,9 +1134,9 @@ void DecipherBlock(int cipher, void *data, void *ks)
{
#ifdef TC_WINDOWS_BOOT_AES
if (IsAesHwCpuSupported())
aes_hw_cpu_decrypt ((byte *) ks + sizeof (aes_encrypt_ctx) + 14 * 16, data);
aes_hw_cpu_decrypt ((uint8 *) ks + sizeof (aes_encrypt_ctx) + 14 * 16, data);
else
aes_decrypt (data, data, (aes_decrypt_ctx *) ((byte *) ks + sizeof(aes_encrypt_ctx)));
aes_decrypt (data, data, (aes_decrypt_ctx *) ((uint8 *) ks + sizeof(aes_encrypt_ctx)));
#elif defined (TC_WINDOWS_BOOT_SERPENT) && !defined (WOLFCRYPT_BACKEND)
serpent_decrypt (data, data, ks);
#elif defined (TC_WINDOWS_BOOT_TWOFISH) && !defined (WOLFCRYPT_BACKEND)
@ -1278,7 +1278,7 @@ BOOL IsRamEncryptionEnabled ()
}
/* masking for random index to remove bias */
byte GetRngMask (byte count)
uint8 GetRngMask (uint8 count)
{
if (count >= 128)
return 0xFF;
@ -1297,10 +1297,10 @@ byte GetRngMask (byte count)
return 1;
}
byte GetRandomIndex (ChaCha20RngCtx* pCtx, byte elementsCount)
uint8 GetRandomIndex (ChaCha20RngCtx* pCtx, uint8 elementsCount)
{
byte index = 0;
byte mask = GetRngMask (elementsCount);
uint8 index = 0;
uint8 mask = GetRngMask (elementsCount);
while (TRUE)
{
@ -1315,7 +1315,7 @@ byte GetRandomIndex (ChaCha20RngCtx* pCtx, byte elementsCount)
#if defined(_WIN64) && !defined (_UEFI)
/* declaration of variables and functions used for RAM encryption on 64-bit build */
static byte* pbKeyDerivationArea = NULL;
static uint8* pbKeyDerivationArea = NULL;
static ULONG cbKeyDerivationArea = 0;
static uint64 HashSeedMask = 0;
@ -1331,9 +1331,9 @@ ULONG AllocTag = 'MMCV';
BOOL InitializeSecurityParameters(GetRandSeedFn rngCallback)
{
ChaCha20RngCtx ctx;
byte pbSeed[CHACHA20RNG_KEYSZ + CHACHA20RNG_IVSZ];
uint8 pbSeed[CHACHA20RNG_KEYSZ + CHACHA20RNG_IVSZ];
#ifdef TC_WINDOWS_DRIVER
byte i;
uint8 i;
char randomStr[4];
Dump ("InitializeSecurityParameters BEGIN\n");
#endif
@ -1390,7 +1390,7 @@ BOOL InitializeSecurityParameters(GetRandSeedFn rngCallback)
cbKeyDerivationArea = 1024 * 1024;
do
{
pbKeyDerivationArea = (byte*) TCalloc(cbKeyDerivationArea);
pbKeyDerivationArea = (uint8*) TCalloc(cbKeyDerivationArea);
if (!pbKeyDerivationArea)
cbKeyDerivationArea >>= 1;
} while (!pbKeyDerivationArea && (cbKeyDerivationArea >= (2*PAGE_SIZE)));
@ -1531,25 +1531,25 @@ void VcUnprotectKeys (PCRYPTO_INFO pCryptoInfo, uint64 encID)
#if defined(_M_ARM64) || defined(__arm__) || defined (__arm64__) || defined (__aarch64__)
/* dummy implementation that should never be called */
void aes_hw_cpu_decrypt(const byte* ks, byte* data)
void aes_hw_cpu_decrypt(const uint8* ks, uint8* data)
{
ks = ks;
data = data;
}
void aes_hw_cpu_decrypt_32_blocks(const byte* ks, byte* data)
void aes_hw_cpu_decrypt_32_blocks(const uint8* ks, uint8* data)
{
ks = ks;
data = data;
}
void aes_hw_cpu_encrypt(const byte* ks, byte* data)
void aes_hw_cpu_encrypt(const uint8* ks, uint8* data)
{
ks = ks;
data = data;
}
void aes_hw_cpu_encrypt_32_blocks(const byte* ks, byte* data)
void aes_hw_cpu_encrypt_32_blocks(const uint8* ks, uint8* data)
{
ks = ks;
data = data;

48
src/Common/Dlgcode.c
View File

@ -2884,7 +2884,7 @@ LRESULT CALLBACK CustomDlgProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lPar
static BOOL IsReturnAddress (DWORD64 address)
{
static size_t codeEnd = 0;
byte *sp = (byte *) address;
uint8 *sp = (uint8 *) address;
if (codeEnd == 0)
{
@ -3018,7 +3018,7 @@ void ExceptionHandlerThread (void *threadArg)
MEMORY_BASIC_INFORMATION mi;
VirtualQuery (sp, &mi, sizeof (mi));
PDWORD stackTop = (PDWORD)((byte *) mi.BaseAddress + mi.RegionSize);
PDWORD stackTop = (PDWORD)((uint8 *) mi.BaseAddress + mi.RegionSize);
int i = 0;
while (retAddrs.size() < 16 && &sp[i] < stackTop)
@ -5796,24 +5796,24 @@ wstring ArrayToHexWideString (const unsigned char* pbData, int cbData)
return result;
}
bool HexToByte (wchar_t c, byte& b)
bool HexToByte (wchar_t c, uint8& b)
{
bool bRet = true;
if (c >= L'0' && c <= L'9')
b = (byte) (c - L'0');
b = (uint8) (c - L'0');
else if (c >= L'a' && c <= L'z')
b = (byte) (c - L'a' + 10);
b = (uint8) (c - L'a' + 10);
else if (c >= L'A' && c <= L'Z')
b = (byte) (c - L'A' + 10);
b = (uint8) (c - L'A' + 10);
else
bRet = false;
return bRet;
}
bool HexWideStringToArray (const wchar_t* hexStr, std::vector<byte>& arr)
bool HexWideStringToArray (const wchar_t* hexStr, std::vector<uint8>& arr)
{
byte b1, b2;
uint8 b1, b2;
size_t i, len = wcslen (hexStr);
arr.clear();
@ -8716,7 +8716,7 @@ int MountVolume (HWND hwndDlg,
if ((path.length () >= 3) && (_wcsnicmp (path.c_str(), L"ID:", 3) == 0))
{
std::vector<byte> arr;
std::vector<uint8> arr;
if ( (path.length() == (3 + 2*VOLUME_ID_SIZE))
&& HexWideStringToArray (path.c_str() + 3, arr)
&& (arr.size() == VOLUME_ID_SIZE)
@ -9168,7 +9168,7 @@ BOOL IsMountedVolume (const wchar_t *volname)
if ((wcslen (volname) == (3 + 2*VOLUME_ID_SIZE)) && _wcsnicmp (volname, L"ID:", 3) == 0)
{
/* Volume ID specified. Use it for matching mounted volumes. */
std::vector<byte> arr;
std::vector<uint8> arr;
if (HexWideStringToArray (&volname[3], arr) && (arr.size() == VOLUME_ID_SIZE))
{
return IsMountedVolumeID (&arr[0]);
@ -11577,7 +11577,7 @@ int OpenVolume (OpenVolumeContext *context, const wchar_t *volumePath, Password
// Read volume header
DWORD bytesRead;
if (!ReadEffectiveVolumeHeader (context->IsDevice, context->HostFileHandle, (byte *) buffer, &bytesRead))
if (!ReadEffectiveVolumeHeader (context->IsDevice, context->HostFileHandle, (uint8 *) buffer, &bytesRead))
{
status = ERR_OS_ERROR;
goto error;
@ -12162,7 +12162,7 @@ BOOL CALLBACK SecurityTokenKeyfileDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam
if (BrowseFiles (hwndDlg, "SELECT_KEYFILE", keyfilePath, bHistory, FALSE))
{
DWORD keyfileSize;
byte *keyfileData = (byte *) LoadFile (keyfilePath, &keyfileSize);
uint8 *keyfileData = (uint8 *) LoadFile (keyfilePath, &keyfileSize);
if (!keyfileData)
{
handleWin32Error (hwndDlg, SRC_POS);
@ -12180,7 +12180,7 @@ BOOL CALLBACK SecurityTokenKeyfileDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam
if (DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_NEW_TOKEN_KEYFILE), hwndDlg, (DLGPROC) NewSecurityTokenKeyfileDlgProc, (LPARAM) &newParams) == IDOK)
{
vector <byte> keyfileDataVector (keyfileSize);
vector <uint8> keyfileDataVector (keyfileSize);
memcpy (&keyfileDataVector.front(), keyfileData, keyfileSize);
try
@ -12229,7 +12229,7 @@ BOOL CALLBACK SecurityTokenKeyfileDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam
WaitCursor();
finally_do ({ NormalCursor(); });
vector <byte> keyfileData;
vector <uint8> keyfileData;
keyfile->GetKeyfileData (keyfileData);
@ -12240,7 +12240,7 @@ BOOL CALLBACK SecurityTokenKeyfileDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam
return 1;
}
finally_do_arg (vector <byte> *, &keyfileData, { burn (&finally_arg->front(), finally_arg->size()); });
finally_do_arg (vector <uint8> *, &keyfileData, { burn (&finally_arg->front(), finally_arg->size()); });
if (!SaveBufferToFile ((char *) &keyfileData.front(), keyfilePath, (DWORD) keyfileData.size(), FALSE, FALSE))
throw SystemException (SRC_POS);
@ -13023,7 +13023,7 @@ void CheckFilesystem (HWND hwndDlg, int driveNo, BOOL fixErrors)
ShellExecuteW (NULL, (!IsAdmin() && IsUacSupported()) ? L"runas" : L"open", cmdPath, param, NULL, SW_SHOW);
}
BOOL BufferContainsPattern (const byte *buffer, size_t bufferSize, const byte *pattern, size_t patternSize)
BOOL BufferContainsPattern (const uint8 *buffer, size_t bufferSize, const uint8 *pattern, size_t patternSize)
{
if (bufferSize < patternSize)
return FALSE;
@ -13040,14 +13040,14 @@ BOOL BufferContainsPattern (const byte *buffer, size_t bufferSize, const byte *p
}
BOOL BufferContainsString (const byte *buffer, size_t bufferSize, const char *str)
BOOL BufferContainsString (const uint8 *buffer, size_t bufferSize, const char *str)
{
return BufferContainsPattern (buffer, bufferSize, (const byte*) str, strlen (str));
return BufferContainsPattern (buffer, bufferSize, (const uint8*) str, strlen (str));
}
BOOL BufferContainsWideString (const byte *buffer, size_t bufferSize, const wchar_t *str)
BOOL BufferContainsWideString (const uint8 *buffer, size_t bufferSize, const wchar_t *str)
{
return BufferContainsPattern (buffer, bufferSize, (const byte*) str, 2 * wcslen (str));
return BufferContainsPattern (buffer, bufferSize, (const uint8*) str, 2 * wcslen (str));
}
@ -13507,7 +13507,7 @@ void RegisterDriverInf (bool registerFilter, const string& filter, const string&
"[veracrypt_reg]\r\n"
"HKR,,\"" + filterReg + "\",0x0001" + string (registerFilter ? "0008" : "8002") + ",\"" + filter + "\"\r\n";
infFile.Write ((byte *) infTxt.c_str(), (DWORD) infTxt.size());
infFile.Write ((uint8 *) infTxt.c_str(), (DWORD) infTxt.size());
infFile.Close();
HINF hInf = SetupOpenInfFileW (infFileName.c_str(), NULL, INF_STYLE_OLDNT | INF_STYLE_WIN4, NULL);
@ -13582,7 +13582,7 @@ void AllowMessageInUIPI (UINT msg)
ChangeWindowMessageFilter (msg, MSGFLT_ADD);
}
BOOL IsRepeatedByteArray (byte value, const byte* buffer, size_t bufferSize)
BOOL IsRepeatedByteArray (uint8 value, const uint8* buffer, size_t bufferSize)
{
if (buffer && bufferSize)
{
@ -13606,7 +13606,7 @@ BOOL TranslateVolumeID (HWND hwndDlg, wchar_t* pathValue, size_t cchPathValue)
size_t pathLen = pathValue? wcslen (pathValue) : 0;
if ((pathLen >= 3) && (_wcsnicmp (pathValue, L"ID:", 3) == 0))
{
std::vector<byte> arr;
std::vector<uint8> arr;
if ( (pathLen == (3 + 2*VOLUME_ID_SIZE))
&& HexWideStringToArray (pathValue + 3, arr)
&& (arr.size() == VOLUME_ID_SIZE)
@ -14758,7 +14758,7 @@ void GetAppRandomSeed (unsigned char* pbRandSeed, size_t cbRandSeed)
{
LARGE_INTEGER iSeed;
SYSTEMTIME sysTime;
byte digest[WHIRLPOOL_DIGESTSIZE];
uint8 digest[WHIRLPOOL_DIGESTSIZE];
WHIRLPOOL_CTX tctx;
size_t count;

10
src/Common/Dlgcode.h
View File

@ -550,9 +550,9 @@ BOOL InitSecurityTokenLibrary (HWND hwndDlg);
BOOL FileHasReadOnlyAttribute (const wchar_t *path);
BOOL IsFileOnReadOnlyFilesystem (const wchar_t *path);
void CheckFilesystem (HWND hwndDlg, int driveNo, BOOL fixErrors);
BOOL BufferContainsPattern (const byte *buffer, size_t bufferSize, const byte *pattern, size_t patternSize);
BOOL BufferContainsString (const byte *buffer, size_t bufferSize, const char *str);
BOOL BufferContainsWideString (const byte *buffer, size_t bufferSize, const wchar_t *str);
BOOL BufferContainsPattern (const uint8 *buffer, size_t bufferSize, const uint8 *pattern, size_t patternSize);
BOOL BufferContainsString (const uint8 *buffer, size_t bufferSize, const char *str);
BOOL BufferContainsWideString (const uint8 *buffer, size_t bufferSize, const wchar_t *str);
int AskNonSysInPlaceEncryptionResume (HWND hwndDlg, BOOL* pbDecrypt);
BOOL RemoveDeviceWriteProtection (HWND hwndDlg, wchar_t *devicePath);
void EnableElevatedCursorChange (HWND parent);
@ -573,7 +573,7 @@ int AddBitmapToImageList(HIMAGELIST himl, HBITMAP hbmImage, HBITMAP hbmMask);
HRESULT VCStrDupW(LPCWSTR psz, LPWSTR *ppwsz);
void ProcessEntropyEstimate (HWND hProgress, DWORD* pdwInitialValue, DWORD dwCounter, DWORD dwMaxLevel, DWORD* pdwEntropy);
void AllowMessageInUIPI (UINT msg);
BOOL IsRepeatedByteArray (byte value, const byte* buffer, size_t bufferSize);
BOOL IsRepeatedByteArray (uint8 value, const uint8* buffer, size_t bufferSize);
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);
@ -714,7 +714,7 @@ std::wstring FindLatestFileOrDirectory (const std::wstring &directory, const wch
std::wstring GetUserFriendlyVersionString (int version);
std::wstring IntToWideString (int val);
std::wstring ArrayToHexWideString (const unsigned char* pbData, int cbData);
bool HexWideStringToArray (const wchar_t* hexStr, std::vector<byte>& arr);
bool HexWideStringToArray (const wchar_t* hexStr, std::vector<uint8>& arr);
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 ();

54
src/Common/EMVCard.cpp
View File

@ -40,19 +40,19 @@ namespace VeraCrypt
}
#endif
map<EMVCardType, vector<byte>> InitializeSupportedAIDs()
map<EMVCardType, vector<uint8>> InitializeSupportedAIDs()
{
map<EMVCardType, vector<byte>> supportedAIDs;
supportedAIDs.insert(std::make_pair(EMVCardType::AMEX, vector<byte>(EMVCard::AMEX_AID, EMVCard::AMEX_AID + sizeof(EMVCard::AMEX_AID))));
supportedAIDs.insert(std::make_pair(EMVCardType::MASTERCARD, vector<byte>(EMVCard::MASTERCARD_AID, EMVCard::MASTERCARD_AID + sizeof(EMVCard::MASTERCARD_AID))));
supportedAIDs.insert(std::make_pair(EMVCardType::VISA, vector<byte>(EMVCard::VISA_AID, EMVCard::VISA_AID + sizeof(EMVCard::VISA_AID))));
map<EMVCardType, vector<uint8>> supportedAIDs;
supportedAIDs.insert(std::make_pair(EMVCardType::AMEX, vector<uint8>(EMVCard::AMEX_AID, EMVCard::AMEX_AID + sizeof(EMVCard::AMEX_AID))));
supportedAIDs.insert(std::make_pair(EMVCardType::MASTERCARD, vector<uint8>(EMVCard::MASTERCARD_AID, EMVCard::MASTERCARD_AID + sizeof(EMVCard::MASTERCARD_AID))));
supportedAIDs.insert(std::make_pair(EMVCardType::VISA, vector<uint8>(EMVCard::VISA_AID, EMVCard::VISA_AID + sizeof(EMVCard::VISA_AID))));
return supportedAIDs;
}
const byte EMVCard::AMEX_AID[7] = {0xA0, 0x00, 0x00, 0x00, 0x00, 0x25, 0x10};
const byte EMVCard::MASTERCARD_AID[7] = {0xA0, 0x00, 0x00, 0x00, 0x04, 0x10, 0x10};
const byte EMVCard::VISA_AID[7] = {0xA0, 0x00, 0x00, 0x00, 0x03, 0x10, 0x10};
const map<EMVCardType, vector<byte>> EMVCard::SUPPORTED_AIDS = InitializeSupportedAIDs();
const uint8 EMVCard::AMEX_AID[7] = {0xA0, 0x00, 0x00, 0x00, 0x00, 0x25, 0x10};
const uint8 EMVCard::MASTERCARD_AID[7] = {0xA0, 0x00, 0x00, 0x00, 0x04, 0x10, 0x10};
const uint8 EMVCard::VISA_AID[7] = {0xA0, 0x00, 0x00, 0x00, 0x03, 0x10, 0x10};
const map<EMVCardType, vector<uint8>> EMVCard::SUPPORTED_AIDS = InitializeSupportedAIDs();
EMVCard::EMVCard() : SCard(), m_lastPANDigits(L"")
{
@ -130,15 +130,15 @@ namespace VeraCrypt
m_lastPANDigits.clear();
}
vector<byte> EMVCard::GetCardAID(bool forceContactless)
vector<uint8> EMVCard::GetCardAID(bool forceContactless)
{
vector<vector<byte>> supportedAIDs;
vector<byte> supportedAIDsPriorities;
vector<pair<byte, vector<byte>>> supportedAIDsSorted;
vector<vector<uint8>> supportedAIDs;
vector<uint8> supportedAIDsPriorities;
vector<pair<uint8, vector<uint8>>> supportedAIDsSorted;
bool hasBeenReset = false;
CommandAPDU command;
ResponseAPDU response;
vector<byte> responseData;
vector<uint8> responseData;
shared_ptr<TLVNode> rootNode;
shared_ptr<TLVNode> fciNode;
shared_ptr<TLVNode> dfNameNode;
@ -149,7 +149,7 @@ namespace VeraCrypt
vector<shared_ptr<TLVNode>> pseDirectoryNodes;
unsigned char sfi;
bool usingContactless = false;
vector<byte> tokenAID;
vector<uint8> tokenAID;
if (m_aid.size())
return m_aid;
@ -241,7 +241,7 @@ namespace VeraCrypt
{
sfi = sfiNode->Value->at(0);
byte rec = 1;
uint8 rec = 1;
do
{
command = CommandAPDU(CLA_ISO7816, INS_READ_RECORD, rec++, (sfi << 3) | 4, SCardReader::shortAPDUMaxTransSize);
@ -316,20 +316,20 @@ namespace VeraCrypt
return tokenAID;
}
void EMVCard::GetCardContent(vector<byte>& iccCert, vector<byte>& issuerCert, vector<byte>& cplcData)
void EMVCard::GetCardContent(vector<uint8>& iccCert, vector<uint8>& issuerCert, vector<uint8>& cplcData)
{
bool hasBeenReset = false;
bool aidSelected = false;
bool iccFound = false;
bool issuerFound = false;
bool cplcFound = false;
vector<byte> emvCardAid;
vector<uint8> emvCardAid;
shared_ptr<TLVNode> rootNode;
shared_ptr<TLVNode> iccPublicKeyCertNode;
shared_ptr<TLVNode> issuerPublicKeyCertNode;
CommandAPDU command;
ResponseAPDU response;
vector<byte> responseData;
vector<uint8> responseData;
iccCert.clear();
issuerCert.clear();
@ -374,9 +374,9 @@ namespace VeraCrypt
// 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.
for (byte sfi = 1; sfi < 32 && (!iccFound || !issuerFound); sfi++)
for (uint8 sfi = 1; sfi < 32 && (!iccFound || !issuerFound); sfi++)
{
for (byte rec = 1; rec < 17 && (!iccFound || !issuerFound); rec++)
for (uint8 rec = 1; rec < 17 && (!iccFound || !issuerFound); rec++)
{
command = CommandAPDU(CLA_ISO7816, INS_READ_RECORD, rec, (sfi << 3) | 4, SCardReader::shortAPDUMaxTransSize);
m_reader->ApduProcessData(command, response);
@ -436,13 +436,13 @@ namespace VeraCrypt
bool hasBeenReset = false;
bool panFound = false;
bool aidSelected = false;
vector<byte> EMVCardAid;
vector<byte> panData;
vector<uint8> EMVCardAid;
vector<uint8> panData;
shared_ptr<TLVNode> rootNode;
shared_ptr<TLVNode> panNode;
CommandAPDU command;
ResponseAPDU response;
vector<byte> responseData;
vector<uint8> responseData;
lastPANDigits = L"";
@ -474,9 +474,9 @@ namespace VeraCrypt
// 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.
for (byte sfi = 1; sfi < 32 && !panFound; sfi++)
for (uint8 sfi = 1; sfi < 32 && !panFound; sfi++)
{
for (byte rec = 1; rec < 17 && !panFound; rec++)
for (uint8 rec = 1; rec < 17 && !panFound; rec++)
{
command = CommandAPDU(CLA_ISO7816, INS_READ_RECORD, rec, (sfi << 3) | 4, SCardReader::shortAPDUMaxTransSize);
m_reader->ApduProcessData(command, response);
@ -498,7 +498,7 @@ namespace VeraCrypt
{
panFound = true;
panData = *panNode->Value.get();
panData = vector<byte>(panData.rbegin(), panData.rbegin() + 2); // only interested in last digits
panData = vector<uint8>(panData.rbegin(), panData.rbegin() + 2); // only interested in last digits
std::swap(panData[0], panData[1]);
lastPANDigits = ArrayToHexWideString(panData.data(), (int) panData.size());
}

22
src/Common/EMVCard.h
View File

@ -29,11 +29,11 @@ namespace VeraCrypt
// 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.
vector<byte> m_aid;
vector<vector<byte>> m_supportedAids;
vector<byte> m_iccCert;
vector<byte> m_issuerCert;
vector<byte> m_cplcData;
vector<uint8> m_aid;
vector<vector<uint8>> m_supportedAids;
vector<uint8> m_iccCert;
vector<uint8> m_issuerCert;
vector<uint8> m_cplcData;
wstring m_lastPANDigits;
public:
@ -41,10 +41,10 @@ namespace VeraCrypt
// Add other AIDS
// https://gist.github.com/pvieito/6224eed92c99b069f6401996c548d0e4
// https://ambimat.com/developer-resources/list-of-application-identifiers-aid/
const static byte AMEX_AID[7];
const static byte MASTERCARD_AID[7];
const static byte VISA_AID[7];
const static map<EMVCardType, vector<byte>> SUPPORTED_AIDS;
const static uint8 AMEX_AID[7];
const static uint8 MASTERCARD_AID[7];
const static uint8 VISA_AID[7];
const static map<EMVCardType, vector<uint8>> SUPPORTED_AIDS;
EMVCard();
EMVCard(size_t slotId);
@ -59,9 +59,9 @@ namespace VeraCrypt
// 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
vector<byte> GetCardAID(bool forceContactless = false);
vector<uint8> GetCardAID(bool forceContactless = false);
void GetCardContent(vector<byte>& iccCert, vector<byte>& issuerCert, vector<byte>& cplcData);
void GetCardContent(vector<uint8>& iccCert, vector<uint8>& issuerCert, vector<uint8>& cplcData);
void GetCardPAN(wstring& lastPANDigits);
};
}

10
src/Common/EMVToken.cpp
View File

@ -22,7 +22,7 @@ using namespace std;
namespace VeraCrypt
{
void AppendData(vector<byte>& buffer, const unsigned char* pbData, size_t cbData, size_t from, size_t length, bool bEncodeLength = false)
void AppendData(vector<uint8>& buffer, const unsigned char* pbData, size_t cbData, size_t from, size_t length, bool bEncodeLength = false)
{
if (cbData > 0 && from <= cbData - 2 && length > 0 && length <= cbData - from)
{
@ -74,13 +74,13 @@ namespace VeraCrypt
return path.str();
}
void EMVTokenKeyfile::GetKeyfileData(vector <byte>& keyfileData) const
void EMVTokenKeyfile::GetKeyfileData(vector <uint8>& keyfileData) const
{
map <unsigned long int, shared_ptr<EMVCard>>::iterator emvCardsIt;
shared_ptr<EMVCard> card;
vector<byte> iccCert;
vector<byte> issuerCert;
vector<byte> cplcData;
vector<uint8> iccCert;
vector<uint8> issuerCert;
vector<uint8> cplcData;
bool addNewCard = true;
keyfileData.clear();

4
src/Common/EMVToken.h
View File

@ -23,7 +23,7 @@ namespace VeraCrypt
virtual ~EMVTokenKeyfile() {};
virtual operator TokenKeyfilePath () const;
virtual void GetKeyfileData(vector <byte>& keyfileData) const;
virtual void GetKeyfileData(vector <uint8>& keyfileData) const;
};
class EMVToken
@ -33,7 +33,7 @@ namespace VeraCrypt
static vector<EMVTokenKeyfile> GetAvailableKeyfiles(unsigned long int* slotIdFilter = nullptr, const wstring& keyfileIdFilter = wstring());
static EMVTokenInfo GetTokenInfo(unsigned long int slotId);
friend void EMVTokenKeyfile::GetKeyfileData(vector <byte>& keyfileData) const;
friend void EMVTokenKeyfile::GetKeyfileData(vector <uint8>& keyfileData) const;
static map <unsigned long int, shared_ptr<EMVCard>> EMVCards;
};

6
src/Common/EncryptionThreadPool.c
View File

@ -88,7 +88,7 @@ typedef struct EncryptionThreadPoolWorkItemStruct
struct
{
PCRYPTO_INFO CryptoInfo;
byte *Data;
uint8 *Data;
UINT64_STRUCT StartUnitNo;
uint32 UnitCount;
@ -606,13 +606,13 @@ void EncryptionThreadPoolBeginReadVolumeHeaderFinalization (TC_EVENT *keyDerivat
}
void EncryptionThreadPoolDoWork (EncryptionThreadPoolWorkType type, byte *data, const UINT64_STRUCT *startUnitNo, uint32 unitCount, PCRYPTO_INFO cryptoInfo)
void EncryptionThreadPoolDoWork (EncryptionThreadPoolWorkType type, uint8 *data, const UINT64_STRUCT *startUnitNo, uint32 unitCount, PCRYPTO_INFO cryptoInfo)
{
uint32 fragmentCount;
uint32 unitsPerFragment;
uint32 remainder;
byte *fragmentData;
uint8 *fragmentData;
uint64 fragmentStartUnitNo;
EncryptionThreadPoolWorkItem *workItem;

2
src/Common/EncryptionThreadPool.h
View File

@ -34,7 +34,7 @@ size_t GetCpuCount (WORD* pGroupCount);
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);
void EncryptionThreadPoolDoWork (EncryptionThreadPoolWorkType type, byte *data, const UINT64_STRUCT *startUnitNo, uint32 unitCount, PCRYPTO_INFO cryptoInfo);
void EncryptionThreadPoolDoWork (EncryptionThreadPoolWorkType type, uint8 *data, const UINT64_STRUCT *startUnitNo, uint32 unitCount, PCRYPTO_INFO cryptoInfo);
BOOL EncryptionThreadPoolStart (size_t encryptionFreeCpuCount);
void EncryptionThreadPoolStop ();
size_t GetEncryptionThreadCount ();

2
src/Common/Fat.h
View File

@ -14,7 +14,7 @@
typedef struct fatparams_t
{
char volume_name[11];
byte volume_id[4];
uint8 volume_id[4];
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 */

4
src/Common/Format.c
View File

@ -532,7 +532,7 @@ int TCFormatVolume (volatile FORMAT_VOL_PARAMETERS *volParams)
// To prevent fragmentation, write zeroes to reserved header sectors which are going to be filled with random data
if (!volParams->bDevice && !volParams->hiddenVol)
{
byte buf[TC_VOLUME_HEADER_GROUP_SIZE - TC_VOLUME_HEADER_EFFECTIVE_SIZE];
uint8 buf[TC_VOLUME_HEADER_GROUP_SIZE - TC_VOLUME_HEADER_EFFECTIVE_SIZE];
DWORD bytesWritten;
ZeroMemory (buf, sizeof (buf));
@ -1392,7 +1392,7 @@ static volatile BOOL WriteThreadRunning;
static volatile BOOL WriteThreadExitRequested;
static HANDLE WriteThreadHandle;
static byte *WriteThreadBuffer;
static uint8 *WriteThreadBuffer;
static HANDLE WriteBufferEmptyEvent;
static HANDLE WriteBufferFullEvent;

2
src/Common/Keyfiles.c
View File

@ -253,7 +253,7 @@ BOOL KeyFilesApply (HWND hwndDlg, Password *password, KeyFile *firstKeyFile, con
if (Token::IsKeyfilePathValid (kf->FileName, EMVSupportEnabled? true : false))
{
// Apply security token keyfile
vector <byte> keyfileData;
vector <uint8> keyfileData;
TokenKeyfilePath secPath (kf->FileName);
Token::getTokenKeyfile (secPath)->GetKeyfileData (keyfileData);

32
src/Common/ResponseAPDU.cpp
View File

@ -5,7 +5,7 @@ using namespace std;
namespace VeraCrypt
{
uint16 BytesToUInt16(const vector<byte>& buff)
uint16 BytesToUInt16(const vector<uint8>& buff)
{
uint16 value = 0;
for (uint16 i = 0; i < buff.size(); i++)
@ -17,7 +17,7 @@ namespace VeraCrypt
return value;
}
void AppendData (vector<byte>& buffer, const byte* pbData, size_t cbData)
void AppendData (vector<uint8>& buffer, const uint8* pbData, size_t cbData)
{
size_t orgSize = buffer.size ();
buffer.resize (orgSize + cbData);
@ -36,7 +36,7 @@ namespace VeraCrypt
{
}
ResponseAPDU::ResponseAPDU(const vector<byte>& data, uint16 SW)
ResponseAPDU::ResponseAPDU(const vector<uint8>& data, uint16 SW)
{
m_data = data;
m_SW = SW;
@ -47,19 +47,19 @@ namespace VeraCrypt
return (uint32)m_data.size();
}
const vector<byte> ResponseAPDU::getData()
const vector<uint8> ResponseAPDU::getData()
{
return m_data;
}
byte ResponseAPDU::getSW1()
uint8 ResponseAPDU::getSW1()
{
return (byte)((0xFF00 & m_SW) >> 8);
return (uint8)((0xFF00 & m_SW) >> 8);
}
byte ResponseAPDU::getSW2()
uint8 ResponseAPDU::getSW2()
{
return (byte)(0x00FF & m_SW);
return (uint8)(0x00FF & m_SW);
}
uint16 ResponseAPDU::getSW()
@ -67,23 +67,23 @@ namespace VeraCrypt
return m_SW;
}
const vector<byte> ResponseAPDU::getBytes()
const vector<uint8> ResponseAPDU::getBytes()
{
vector<byte> apdu;
vector<uint8> apdu;
AppendData(apdu, m_data.data(), m_data.size());
apdu.push_back((byte)getSW1());
apdu.push_back((byte)getSW2());
apdu.push_back((uint8)getSW1());
apdu.push_back((uint8)getSW2());
return apdu;
}
void ResponseAPDU::appendData(const vector<byte>& data)
void ResponseAPDU::appendData(const vector<uint8>& data)
{
appendData(data.data(), data.size());
}
void ResponseAPDU::appendData(const byte* data, size_t dataLen)
void ResponseAPDU::appendData(const uint8* data, size_t dataLen)
{
AppendData(m_data, data, dataLen);
}
@ -93,12 +93,12 @@ namespace VeraCrypt
m_SW = SW;
}
void ResponseAPDU::setBytes(const vector<byte>& bytes)
void ResponseAPDU::setBytes(const vector<uint8>& bytes)
{
clear();
if (bytes.size() >= 2)
{
vector<byte> SWBytes;
vector<uint8> SWBytes;
m_data.resize(bytes.size() - 2);
SWBytes.resize(2);

18
src/Common/ResponseAPDU.h
View File

@ -9,7 +9,7 @@ namespace VeraCrypt
{
protected:
vector<byte> m_data;
vector<uint8> m_data;
uint16 m_SW;
@ -19,25 +19,25 @@ namespace VeraCrypt
ResponseAPDU();
ResponseAPDU(const vector<byte>& data, uint16 SW);
ResponseAPDU(const vector<uint8>& data, uint16 SW);
uint32 getNr();
const vector<byte> getData();
const vector<uint8> getData();
byte getSW1();
uint8 getSW1();
byte getSW2();
uint8 getSW2();
uint16 getSW();
const vector<byte> getBytes();
const vector<uint8> getBytes();
void setSW(uint16 SW);
void setBytes(const vector<byte>& bytes);
void setBytes(const vector<uint8>& bytes);
void appendData(const vector<byte>& data);
void appendData(const byte* data, size_t dataLen);
void appendData(const vector<uint8>& data);
void appendData(const uint8* data, size_t dataLen);
};
};

4
src/Common/SCardLoader.h
View File

@ -14,7 +14,7 @@
#include <PCSC/wintypes.h>
#include "reader.h"
typedef LPSCARD_READERSTATE_A LPSCARD_READERSTATE;
using VeraCrypt::byte;
using VeraCrypt::uint8;
#define BOOL int
#else
#undef BOOL
@ -22,7 +22,7 @@ using VeraCrypt::byte;
#include <winscard.h>
#include <wintypes.h>
#include <reader.h>
using VeraCrypt::byte;
using VeraCrypt::uint8;
#define BOOL int
#endif
#endif

18
src/Common/SCardReader.cpp
View File

@ -117,7 +117,7 @@ namespace VeraCrypt
return name;
}
bool SCardReader::IsCardPresent(vector<byte>& cardAtr)
bool SCardReader::IsCardPresent(vector<uint8>& cardAtr)
{
LONG lRet = SCARD_S_SUCCESS;
SCARD_READERSTATE state;
@ -165,7 +165,7 @@ namespace VeraCrypt
bool SCardReader::IsCardPresent()
{
vector<byte> dummy;
vector<uint8> dummy;
return IsCardPresent(dummy);
}
@ -398,8 +398,8 @@ namespace VeraCrypt
size_t indexOfLe = 0;
size_t indexOfLcData = 0;
vector<byte> pbSendBuffer;
vector<byte> pbRecvBuffer;
vector<uint8> pbSendBuffer;
vector<uint8> pbRecvBuffer;
DWORD cbSendLength = 0;
DWORD cbRecvLength = 0;
@ -460,7 +460,7 @@ namespace VeraCrypt
// 256 is encoded as 0x00
pbSendBuffer[4] = (BYTE)ne;
indexOfLe = 4;
cbSendLength = 4 + 1; // header || Le (1 byte)
cbSendLength = 4 + 1; // header || Le (1 uint8)
}
else
{
@ -494,7 +494,7 @@ namespace VeraCrypt
// case 3s
pbSendBuffer[4] = (BYTE)nc;
indexOfLcData = 5;
cbSendLength = 4 + 1 + nc; // header || Lc (1 byte) || Data
cbSendLength = 4 + 1 + nc; // header || Lc (1 uint8) || Data
memcpy(&pbSendBuffer[indexOfLcData], commandAPDU.getData().data(), nc);
}
else
@ -518,7 +518,7 @@ namespace VeraCrypt
// case 4s
pbSendBuffer[4] = (BYTE)nc;
indexOfLcData = 5;
cbSendLength = 4 + 1 + nc + 1; // header || Lc (1 byte) || Data || Le (1 byte)
cbSendLength = 4 + 1 + nc + 1; // header || Lc (1 uint8) || Data || Le (1 uint8)
memcpy(&pbSendBuffer[indexOfLcData], commandAPDU.getData().data(), nc);
pbSendBuffer[indexOfLcData + nc] = (ne != 256) ? (BYTE)ne : 0;
indexOfLe = indexOfLcData + nc;
@ -646,9 +646,9 @@ namespace VeraCrypt
throw PCSCException(lRet);
}
void SCardReader::GetATRFromHandle(vector<byte>& atrValue)
void SCardReader::GetATRFromHandle(vector<uint8>& atrValue)
{
vector<byte> pbATR;
vector<uint8> pbATR;
DWORD cByte = 0;
LONG lRet = 0;

114
src/Common/SCardReader.h
View File

@ -51,52 +51,52 @@ namespace VeraCrypt
/* ================================================================================================ */
/* CLA values */
/* ================================================================================================ */
const byte CLA_ISO7816 = (byte)0x00;
const byte CLA_COMMAND_CHAINING = (byte)0x10;
const uint8 CLA_ISO7816 = (uint8)0x00;
const uint8 CLA_COMMAND_CHAINING = (uint8)0x10;
/* ================================================================================================ */
/* INS values */
/* ================================================================================================ */
const byte INS_ERASE_BINARY = 0x0E;
const byte INS_VERIFY = 0x20;
const byte INS_CHANGE_CHV = 0x24;
const byte INS_UNBLOCK_CHV = 0x2C;
const byte INS_DECREASE = 0x30;
const byte INS_INCREASE = 0x32;
const byte INS_DECREASE_STAMPED = 0x34;
const byte INS_REHABILITATE_CHV = 0x44;
const byte INS_MANAGE_CHANNEL = 0x70;
const byte INS_EXTERNAL_AUTHENTICATE = (byte)0x82;
const byte INS_MUTUAL_AUTHENTICATE = (byte)0x82;
const byte INS_GET_CHALLENGE = (byte)0x84;
const byte INS_ASK_RANDOM = (byte)0x84;
const byte INS_GIVE_RANDOM = (byte)0x86;
const byte INS_INTERNAL_AUTHENTICATE = (byte)0x88;
const byte INS_SEEK = (byte)0xA2;
const byte INS_SELECT = (byte)0xA4;
const byte INS_SELECT_FILE = (byte)0xA4;
const byte INS_CLOSE_APPLICATION = (byte)0xAC;
const byte INS_READ_BINARY = (byte)0xB0;
const byte INS_READ_BINARY2 = (byte)0xB1;
const byte INS_READ_RECORD = (byte)0xB2;
const byte INS_READ_RECORD2 = (byte)0xB3;
const byte INS_READ_RECORDS = (byte)0xB2;
const byte INS_READ_BINARY_STAMPED = (byte)0xB4;
const byte INS_READ_RECORD_STAMPED = (byte)0xB6;
const byte INS_GET_RESPONSE = (byte)0xC0;
const byte INS_ENVELOPE = (byte)0xC2;
const byte INS_GET_DATA = (byte)0xCA;
const byte INS_WRITE_BINARY = (byte)0xD0;
const byte INS_WRITE_RECORD = (byte)0xD2;
const byte INS_UPDATE_BINARY = (byte)0xD6;
const byte INS_LOAD_KEY_FILE = (byte)0xD8;
const byte INS_PUT_DATA = (byte)0xDA;
const byte INS_UPDATE_RECORD = (byte)0xDC;
const byte INS_CREATE_FILE = (byte)0xE0;
const byte INS_APPEND_RECORD = (byte)0xE2;
const byte INS_DELETE_FILE = (byte)0xE4;
const byte INS_PSO = (byte)0x2A;
const byte INS_MSE = (byte)0x22;
const uint8 INS_ERASE_BINARY = 0x0E;
const uint8 INS_VERIFY = 0x20;
const uint8 INS_CHANGE_CHV = 0x24;
const uint8 INS_UNBLOCK_CHV = 0x2C;
const uint8 INS_DECREASE = 0x30;
const uint8 INS_INCREASE = 0x32;
const uint8 INS_DECREASE_STAMPED = 0x34;
const uint8 INS_REHABILITATE_CHV = 0x44;
const uint8 INS_MANAGE_CHANNEL = 0x70;
const uint8 INS_EXTERNAL_AUTHENTICATE = (uint8)0x82;
const uint8 INS_MUTUAL_AUTHENTICATE = (uint8)0x82;
const uint8 INS_GET_CHALLENGE = (uint8)0x84;
const uint8 INS_ASK_RANDOM = (uint8)0x84;
const uint8 INS_GIVE_RANDOM = (uint8)0x86;
const uint8 INS_INTERNAL_AUTHENTICATE = (uint8)0x88;
const uint8 INS_SEEK = (uint8)0xA2;
const uint8 INS_SELECT = (uint8)0xA4;
const uint8 INS_SELECT_FILE = (uint8)0xA4;
const uint8 INS_CLOSE_APPLICATION = (uint8)0xAC;
const uint8 INS_READ_BINARY = (uint8)0xB0;
const uint8 INS_READ_BINARY2 = (uint8)0xB1;
const uint8 INS_READ_RECORD = (uint8)0xB2;
const uint8 INS_READ_RECORD2 = (uint8)0xB3;
const uint8 INS_READ_RECORDS = (uint8)0xB2;
const uint8 INS_READ_BINARY_STAMPED = (uint8)0xB4;
const uint8 INS_READ_RECORD_STAMPED = (uint8)0xB6;
const uint8 INS_GET_RESPONSE = (uint8)0xC0;
const uint8 INS_ENVELOPE = (uint8)0xC2;
const uint8 INS_GET_DATA = (uint8)0xCA;
const uint8 INS_WRITE_BINARY = (uint8)0xD0;
const uint8 INS_WRITE_RECORD = (uint8)0xD2;
const uint8 INS_UPDATE_BINARY = (uint8)0xD6;
const uint8 INS_LOAD_KEY_FILE = (uint8)0xD8;
const uint8 INS_PUT_DATA = (uint8)0xDA;
const uint8 INS_UPDATE_RECORD = (uint8)0xDC;
const uint8 INS_CREATE_FILE = (uint8)0xE0;
const uint8 INS_APPEND_RECORD = (uint8)0xE2;
const uint8 INS_DELETE_FILE = (uint8)0xE4;
const uint8 INS_PSO = (uint8)0x2A;
const uint8 INS_MSE = (uint8)0x22;
/* ================================================================================================ */
/* EMV values */
@ -104,19 +104,19 @@ namespace VeraCrypt
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;
const byte EMV_ISS_PK_CERT_TAG = (byte)0x90;
const byte EMV_PAN_TAG = (byte)0x5A;
const byte EMV_FCI_TAG = (byte)0x6F;
const byte EMV_DFNAME_TAG = (byte)0x84;
const byte EMV_FCI_ISSUER_TAG = (byte)0xA5;
const byte EMV_DIRECTORY_ENTRY_TAG = (byte)0x61;
const byte EMV_SFI_TAG = (byte)0x88;
const byte EMV_TEMPLATE_TAG = (byte)0x70;
const byte EMV_AID_TAG = (byte)0x4F;
const byte EMV_LABEL_TAG = (byte)0x50;
const byte EMV_PRIORITY_TAG = (byte)0x87;
const byte EMV_PSE1[] = { 0x31, 0x50, 0x41, 0x59, 0x2E, 0x53, 0x59, 0x53, 0x2E, 0x44, 0x44, 0x46, 0x30, 0x31 }; // "1PAY.SYS.DDF01" (contact)
const byte EMV_PSE2[] = { 0x32, 0x50, 0x41, 0x59, 0x2E, 0x53, 0x59, 0x53, 0x2E, 0x44, 0x44, 0x46, 0x30, 0x31 }; // "2PAY.SYS.DDF01" (contactless)
const uint8 EMV_ISS_PK_CERT_TAG = (uint8)0x90;
const uint8 EMV_PAN_TAG = (uint8)0x5A;
const uint8 EMV_FCI_TAG = (uint8)0x6F;
const uint8 EMV_DFNAME_TAG = (uint8)0x84;
const uint8 EMV_FCI_ISSUER_TAG = (uint8)0xA5;
const uint8 EMV_DIRECTORY_ENTRY_TAG = (uint8)0x61;
const uint8 EMV_SFI_TAG = (uint8)0x88;
const uint8 EMV_TEMPLATE_TAG = (uint8)0x70;
const uint8 EMV_AID_TAG = (uint8)0x4F;
const uint8 EMV_LABEL_TAG = (uint8)0x50;
const uint8 EMV_PRIORITY_TAG = (uint8)0x87;
const uint8 EMV_PSE1[] = { 0x31, 0x50, 0x41, 0x59, 0x2E, 0x53, 0x59, 0x53, 0x2E, 0x44, 0x44, 0x46, 0x30, 0x31 }; // "1PAY.SYS.DDF01" (contact)
const uint8 EMV_PSE2[] = { 0x32, 0x50, 0x41, 0x59, 0x2E, 0x53, 0x59, 0x53, 0x2E, 0x44, 0x44, 0x46, 0x30, 0x31 }; // "2PAY.SYS.DDF01" (contactless)
/* ================================================================================================ */
@ -173,7 +173,7 @@ namespace VeraCrypt
// Card Connection management methods
// ------------------------------------------------------------------------------------------------------------------------------------- //
bool IsCardPresent(vector<byte>& cardAtr);
bool IsCardPresent(vector<uint8>& cardAtr);
bool IsCardPresent();
LONG CardHandleStatus();
@ -193,7 +193,7 @@ namespace VeraCrypt
void ApduProcessData(CommandAPDU commandAPDU, ResponseAPDU& responseAPDU) const;
void GetATRFromHandle(vector<byte>& atrValue);
void GetATRFromHandle(vector<uint8>& atrValue);
};
};

16
src/Common/SecurityToken.cpp
View File

@ -123,7 +123,7 @@ namespace VeraCrypt
Sessions.erase(Sessions.find(slotId));
}
void SecurityToken::CreateKeyfile(CK_SLOT_ID slotId, vector <byte>& keyfileData, const string& name)
void SecurityToken::CreateKeyfile(CK_SLOT_ID slotId, vector <uint8>& keyfileData, const string& name)
{
if (name.empty())
throw ParameterIncorrect(SRC_POS);
@ -167,10 +167,10 @@ namespace VeraCrypt
throw Pkcs11Exception(status);
// Some tokens report success even if the new object was truncated to fit in the available memory
vector <byte> objectData;
vector <uint8> objectData;
GetObjectAttribute(slotId, keyfileHandle, CKA_VALUE, objectData);
finally_do_arg(vector <byte> *, &objectData, { if (!finally_arg->empty()) burn(&finally_arg->front(), finally_arg->size()); });
finally_do_arg(vector <uint8> *, &objectData, { if (!finally_arg->empty()) burn(&finally_arg->front(), finally_arg->size()); });
if (objectData.size() != keyfileData.size())
{
@ -227,13 +227,13 @@ namespace VeraCrypt
keyfile.Token->SlotId = slotId;
keyfile.Token = shared_ptr<SecurityTokenInfo>(new SecurityTokenInfo(token));
vector <byte> privateAttrib;
vector <uint8> privateAttrib;
GetObjectAttribute(slotId, dataHandle, CKA_PRIVATE, privateAttrib);
if (privateAttrib.size() == sizeof(CK_BBOOL) && *(CK_BBOOL*)&privateAttrib.front() != CK_TRUE)
continue;
vector <byte> label;
vector <uint8> label;
GetObjectAttribute(slotId, dataHandle, CKA_LABEL, label);
label.push_back(0);
@ -320,7 +320,7 @@ namespace VeraCrypt
return token;
}
void SecurityTokenKeyfile::GetKeyfileData(vector <byte>& keyfileData) const
void SecurityTokenKeyfile::GetKeyfileData(vector <uint8>& keyfileData) const
{
SecurityToken::LoginUserIfRequired(Token->SlotId);
SecurityToken::GetObjectAttribute(Token->SlotId, Handle, CKA_VALUE, keyfileData);
@ -361,7 +361,7 @@ namespace VeraCrypt
return objects;
}
void SecurityToken::GetObjectAttribute(CK_SLOT_ID slotId, CK_OBJECT_HANDLE tokenObject, CK_ATTRIBUTE_TYPE attributeType, vector <byte>& attributeValue)
void SecurityToken::GetObjectAttribute(CK_SLOT_ID slotId, CK_OBJECT_HANDLE tokenObject, CK_ATTRIBUTE_TYPE attributeType, vector <uint8>& attributeValue)
{
attributeValue.clear();
@ -379,7 +379,7 @@ namespace VeraCrypt
if (attribute.ulValueLen == 0)
return;
attributeValue = vector <byte>(attribute.ulValueLen);
attributeValue = vector <uint8>(attribute.ulValueLen);
attribute.pValue = &attributeValue.front();
status = Pkcs11Functions->C_GetAttributeValue(Sessions[slotId].Handle, tokenObject, &attribute, 1);

8
src/Common/SecurityToken.h
View File

@ -76,7 +76,7 @@ namespace VeraCrypt
operator TokenKeyfilePath () const;
void GetKeyfileData(vector<byte>& keyfileData) const;
void GetKeyfileData(vector<uint8>& keyfileData) const;
string IdUtf8;
CK_OBJECT_HANDLE Handle;
@ -181,7 +181,7 @@ namespace VeraCrypt
public:
static void CloseAllSessions() throw ();
static void CloseLibrary();
static void CreateKeyfile(CK_SLOT_ID slotId, vector <byte>& keyfileData, const string& name);
static void CreateKeyfile(CK_SLOT_ID slotId, vector <uint8>& keyfileData, const string& name);
static void DeleteKeyfile(const SecurityTokenKeyfile& keyfile);
static vector <SecurityTokenKeyfile> GetAvailableKeyfiles(CK_SLOT_ID* slotIdFilter = nullptr, const wstring keyfileIdFilter = wstring());
static list <SecurityTokenInfo> GetAvailableTokens();
@ -199,7 +199,7 @@ namespace VeraCrypt
protected:
static void CloseSession(CK_SLOT_ID slotId);
static vector <CK_OBJECT_HANDLE> GetObjects(CK_SLOT_ID slotId, CK_ATTRIBUTE_TYPE objectClass);
static void GetObjectAttribute(CK_SLOT_ID slotId, CK_OBJECT_HANDLE tokenObject, CK_ATTRIBUTE_TYPE attributeType, vector <byte>& attributeValue);
static void GetObjectAttribute(CK_SLOT_ID slotId, CK_OBJECT_HANDLE tokenObject, CK_ATTRIBUTE_TYPE attributeType, vector <uint8>& attributeValue);
static list <CK_SLOT_ID> GetTokenSlots();
static void Login(CK_SLOT_ID slotId, const char* pin);
static void LoginUserIfRequired(CK_SLOT_ID slotId);
@ -217,7 +217,7 @@ namespace VeraCrypt
static map <CK_SLOT_ID, Pkcs11Session> Sessions;
static unique_ptr <SendExceptionFunctor> WarningCallback;
friend void SecurityTokenKeyfile::GetKeyfileData(vector <byte>& keyfileData) const;
friend void SecurityTokenKeyfile::GetKeyfileData(vector <uint8>& keyfileData) const;
};
}

12
src/Common/TLVParser.cpp
View File

@ -13,7 +13,7 @@ namespace VeraCrypt
}
/* Check if the bit is correct */
uint16 TLVParser::CheckBit(byte value, int bit)
uint16 TLVParser::CheckBit(uint8 value, int bit)
{
unsigned char bitvalue[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
@ -36,13 +36,13 @@ namespace VeraCrypt
}
/* Parsing one TLV node */
shared_ptr<TLVNode> TLVParser::TLV_Parse_One(byte* buf, size_t size)
shared_ptr<TLVNode> TLVParser::TLV_Parse_One(uint8* buf, size_t size)
{
size_t index = 0;
size_t i = 0;
byte tag1, tag2, tagsize;
byte len, lensize;
shared_ptr<vector<byte>> value = make_shared<vector<byte>>();
uint8 tag1, tag2, tagsize;
uint8 len, lensize;
shared_ptr<vector<uint8>> value = make_shared<vector<uint8>>();
shared_ptr<TLVNode> node = TLV_CreateNode();
tag1 = tag2 = 0;
@ -157,7 +157,7 @@ namespace VeraCrypt
}
/* Parsing TLV from a buffer and constructing TLV structure */
shared_ptr<TLVNode> TLVParser::TLV_Parse(byte* buf, size_t size)
shared_ptr<TLVNode> TLVParser::TLV_Parse(uint8* buf, size_t size)
{
shared_ptr<TLVNode> node = TLV_Parse_One(buf, size);
TLV_Parse_Sub(node);

14
src/Common/TLVParser.h
View File

@ -10,16 +10,16 @@ namespace VeraCrypt
{
uint16 Tag; /* T */
uint16 Length; /* L */
shared_ptr<vector<byte>> Value; /* V */
byte TagSize;
byte LengthSize;
shared_ptr<vector<uint8>> Value; /* V */
uint8 TagSize;
uint8 LengthSize;
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)
{
Value = make_shared<vector<byte>>();
Value = make_shared<vector<uint8>>();
Subs = make_shared<vector<shared_ptr<TLVNode>>>();
}
@ -37,10 +37,10 @@ namespace VeraCrypt
static shared_ptr<TLVNode> TLV_CreateNode();
/* Check if the bit is correct */
static uint16 CheckBit(byte value, int bit);
static uint16 CheckBit(uint8 value, int bit);
/* Parsing one TLV node */
static shared_ptr<TLVNode> TLV_Parse_One(byte* buf, size_t size);
static shared_ptr<TLVNode> TLV_Parse_One(uint8* buf, size_t size);
/* Parsing all TLV nodes */
static int TLV_Parse_SubNodes(shared_ptr<TLVNode> parent);
@ -54,7 +54,7 @@ namespace VeraCrypt
public:
/* Parsing TLV from a buffer and constructing TLV structure */
static shared_ptr<TLVNode> TLV_Parse(byte* buf, size_t size);
static shared_ptr<TLVNode> TLV_Parse(uint8* buf, size_t size);
/* Finding a TLV node with a particular tag */
static shared_ptr<TLVNode> TLV_Find(shared_ptr<TLVNode> node, uint16 tag);

2
src/Common/Tcdefs.h
View File

@ -95,7 +95,6 @@ extern unsigned short _rotl16(unsigned short value, unsigned char shift);
typedef __int8 int8;
typedef __int16 int16;
typedef __int32 int32;
typedef unsigned __int8 byte;
typedef unsigned __int8 uint8;
typedef unsigned __int16 uint16;
typedef unsigned __int32 uint32;
@ -122,7 +121,6 @@ typedef int8_t int8;
typedef int16_t int16;
typedef int32_t int32;
typedef int64_t int64;
typedef uint8_t byte;
typedef uint8_t uint8;
typedef uint16_t uint16;
typedef uint32_t uint32;

4
src/Common/Tests.c
View File

@ -1340,13 +1340,13 @@ static BOOL DoAutoTestAlgorithms (void)
// AES EncipherBlocks()/DecipherBlocks()
{
byte testData[1024];
uint8 testData[1024];
uint32 origCrc;
size_t i;
for (i = 0; i < sizeof (testData); ++i)
{
testData[i] = (byte) i;
testData[i] = (uint8) i;
}
origCrc = GetCrc32 (testData, sizeof (testData));

2
src/Common/Token.h
View File

@ -41,7 +41,7 @@ namespace VeraCrypt
{
virtual ~TokenKeyfile() {}
virtual operator TokenKeyfilePath () const = 0;
virtual void GetKeyfileData(vector <byte>& keyfileData) const = 0;
virtual void GetKeyfileData(vector <uint8>& keyfileData) const = 0;
shared_ptr<TokenInfo> Token;
wstring Id;

18
src/Common/Volumes.c
View File

@ -130,19 +130,19 @@
uint16 GetHeaderField16 (byte *header, int offset)
uint16 GetHeaderField16 (uint8 *header, int offset)
{
return BE16 (*(uint16 *) (header + offset));
}
uint32 GetHeaderField32 (byte *header, int offset)
uint32 GetHeaderField32 (uint8 *header, int offset)
{
return BE32 (*(uint32 *) (header + offset));
}
UINT64_STRUCT GetHeaderField64 (byte *header, int offset)
UINT64_STRUCT GetHeaderField64 (uint8 *header, int offset)
{
UINT64_STRUCT uint64Struct;
@ -640,7 +640,7 @@ KeyReady: ;
}
#if defined(_WIN32) && !defined(_UEFI)
void ComputeBootloaderFingerprint (byte *bootLoaderBuf, unsigned int bootLoaderSize, byte* fingerprint)
void ComputeBootloaderFingerprint (uint8 *bootLoaderBuf, unsigned int bootLoaderSize, uint8* fingerprint)
{
// compute Whirlpool+SHA512 fingerprint of bootloader including MBR
// we skip user configuration fields:
@ -1214,13 +1214,13 @@ int CreateVolumeHeaderInMemory (HWND hwndDlg, BOOL bBoot, char *header, int ea,
}
#if !defined(_UEFI)
BOOL ReadEffectiveVolumeHeader (BOOL device, HANDLE fileHandle, byte *header, DWORD *bytesRead)
BOOL ReadEffectiveVolumeHeader (BOOL device, HANDLE fileHandle, uint8 *header, DWORD *bytesRead)
{
#if TC_VOLUME_HEADER_EFFECTIVE_SIZE > TC_MAX_VOLUME_SECTOR_SIZE
#error TC_VOLUME_HEADER_EFFECTIVE_SIZE > TC_MAX_VOLUME_SECTOR_SIZE
#endif
byte sectorBuffer[TC_MAX_VOLUME_SECTOR_SIZE];
uint8 sectorBuffer[TC_MAX_VOLUME_SECTOR_SIZE];
DISK_GEOMETRY geometry;
if (!device)
@ -1247,13 +1247,13 @@ BOOL ReadEffectiveVolumeHeader (BOOL device, HANDLE fileHandle, byte *header, DW
}
BOOL WriteEffectiveVolumeHeader (BOOL device, HANDLE fileHandle, byte *header)
BOOL WriteEffectiveVolumeHeader (BOOL device, HANDLE fileHandle, uint8 *header)
{
#if TC_VOLUME_HEADER_EFFECTIVE_SIZE > TC_MAX_VOLUME_SECTOR_SIZE
#error TC_VOLUME_HEADER_EFFECTIVE_SIZE > TC_MAX_VOLUME_SECTOR_SIZE
#endif
byte sectorBuffer[TC_MAX_VOLUME_SECTOR_SIZE];
uint8 sectorBuffer[TC_MAX_VOLUME_SECTOR_SIZE];
DWORD bytesDone;
DISK_GEOMETRY geometry;
@ -1322,7 +1322,7 @@ int WriteRandomDataToReservedHeaderAreas (HWND hwndDlg, HANDLE dev, CRYPTO_INFO
char temporaryKey[MASTER_KEYDATA_SIZE];
char originalK2[MASTER_KEYDATA_SIZE];
byte buf[TC_VOLUME_HEADER_GROUP_SIZE];
uint8 buf[TC_VOLUME_HEADER_GROUP_SIZE];
LARGE_INTEGER offset;
int nStatus = ERR_SUCCESS;

12
src/Common/Volumes.h
View File

@ -129,9 +129,9 @@ extern "C" {
extern BOOL ReadVolumeHeaderRecoveryMode;
uint16 GetHeaderField16 (byte *header, int offset);
uint32 GetHeaderField32 (byte *header, int offset);
UINT64_STRUCT GetHeaderField64 (byte *header, int offset);
uint16 GetHeaderField16 (uint8 *header, int offset);
uint32 GetHeaderField32 (uint8 *header, int offset);
UINT64_STRUCT GetHeaderField64 (uint8 *header, int offset);
#if defined(TC_WINDOWS_BOOT)
int ReadVolumeHeader (BOOL bBoot, char *encryptedHeader, Password *password, int pim, PCRYPTO_INFO *retInfo, CRYPTO_INFO *retHeaderCryptoInfo);
#elif defined(_UEFI)
@ -141,14 +141,14 @@ BOOL RandgetBytes(unsigned char *buf, int len, BOOL forceSlowPoll);
#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)
void ComputeBootloaderFingerprint (byte *bootLoaderBuf, unsigned int bootLoaderSize, byte* fingerprint);
void ComputeBootloaderFingerprint (uint8 *bootLoaderBuf, unsigned int bootLoaderSize, uint8* fingerprint);
#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);
BOOL ReadEffectiveVolumeHeader (BOOL device, HANDLE fileHandle, byte *header, DWORD *bytesRead);
BOOL WriteEffectiveVolumeHeader (BOOL device, HANDLE fileHandle, byte *header);
BOOL ReadEffectiveVolumeHeader (BOOL device, HANDLE fileHandle, uint8 *header, DWORD *bytesRead);
BOOL WriteEffectiveVolumeHeader (BOOL device, HANDLE fileHandle, uint8 *header);
int WriteRandomDataToReservedHeaderAreas (HWND hwndDlg, HANDLE dev, CRYPTO_INFO *cryptoInfo, uint64 dataAreaSize, BOOL bPrimaryOnly, BOOL bBackupOnly);
#endif

16
src/Common/Wipe.c
View File

@ -14,7 +14,7 @@
#include "Wipe.h"
static BOOL Wipe1PseudoRandom (int pass, byte *buffer, size_t size)
static BOOL Wipe1PseudoRandom (int pass, uint8 *buffer, size_t size)
{
return FALSE;
}
@ -23,9 +23,9 @@ static BOOL Wipe1PseudoRandom (int pass, byte *buffer, size_t size)
// Fill buffer with wipe patterns defined in "National Industrial Security Program Operating Manual", US DoD 5220.22-M.
// Return: FALSE = buffer must be filled with random data
static BOOL Wipe3Dod5220 (int pass, byte *buffer, size_t size)
static BOOL Wipe3Dod5220 (int pass, uint8 *buffer, size_t size)
{
byte wipeChar;
uint8 wipeChar;
switch (pass)
{
@ -46,9 +46,9 @@ static BOOL Wipe3Dod5220 (int pass, byte *buffer, size_t size)
}
static BOOL Wipe7Dod5220 (int pass, byte randChars[TC_WIPE_RAND_CHAR_COUNT], byte *buffer, size_t size)
static BOOL Wipe7Dod5220 (int pass, uint8 randChars[TC_WIPE_RAND_CHAR_COUNT], uint8 *buffer, size_t size)
{
byte wipeChar;
uint8 wipeChar;
switch (pass)
{
@ -84,9 +84,9 @@ static BOOL Wipe7Dod5220 (int pass, byte randChars[TC_WIPE_RAND_CHAR_COUNT], byt
// 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
static BOOL Wipe35Gutmann (int pass, byte *buffer, size_t size)
static BOOL Wipe35Gutmann (int pass, uint8 *buffer, size_t size)
{
byte wipePat3[] = { 0x92, 0x49, 0x24 };
uint8 wipePat3[] = { 0x92, 0x49, 0x24 };
int wipePat3Pos;
size_t i;
@ -167,7 +167,7 @@ int GetWipePassCount (WipeAlgorithmId algorithm)
}
BOOL WipeBuffer (WipeAlgorithmId algorithm, byte randChars[TC_WIPE_RAND_CHAR_COUNT], int pass, byte *buffer, size_t size)
BOOL WipeBuffer (WipeAlgorithmId algorithm, uint8 randChars[TC_WIPE_RAND_CHAR_COUNT], int pass, uint8 *buffer, size_t size)
{
switch (algorithm)
{

2
src/Common/Wipe.h
View File

@ -36,7 +36,7 @@ typedef enum
#define TC_WIPE_RAND_CHAR_COUNT 3
int GetWipePassCount (WipeAlgorithmId algorithm);
BOOL WipeBuffer (WipeAlgorithmId algorithm, byte randChars[TC_WIPE_RAND_CHAR_COUNT], int pass, byte *buffer, size_t size);
BOOL WipeBuffer (WipeAlgorithmId algorithm, uint8 randChars[TC_WIPE_RAND_CHAR_COUNT], int pass, uint8 *buffer, size_t size);
#ifdef __cplusplus
}

2
src/Core/CoreBase.cpp
View File

@ -144,7 +144,7 @@ namespace VeraCrypt
outerVolume->ReadSectors (bootSectorBuffer, 0);
int fatType;
byte *bootSector = bootSectorBuffer.Ptr();
uint8 *bootSector = bootSectorBuffer.Ptr();
if (memcmp (bootSector + 54, "FAT12", 5) == 0)
fatType = 12;

22
src/Core/FatFormatter.cpp
View File

@ -149,7 +149,7 @@ namespace VeraCrypt
}
}
static void PutBoot (fatparams * ft, byte *boot, uint32 volumeId)
static void PutBoot (fatparams * ft, uint8 *boot, uint32 volumeId)
{
int cnt = 0;
@ -244,7 +244,7 @@ namespace VeraCrypt
/* FAT32 FSInfo */
static void PutFSInfo (byte *sector, fatparams *ft)
static void PutFSInfo (uint8 *sector, fatparams *ft)
{
memset (sector, 0, ft->sector_size);
sector[3] = 0x41; /* LeadSig */
@ -294,16 +294,16 @@ namespace VeraCrypt
sector.Zero();
uint32 volumeId;
RandomNumberGenerator::GetDataFast (BufferPtr ((byte *) &volumeId, sizeof (volumeId)));
RandomNumberGenerator::GetDataFast (BufferPtr ((uint8 *) &volumeId, sizeof (volumeId)));
PutBoot (ft, (byte *) sector, volumeId);
PutBoot (ft, (uint8 *) sector, volumeId);
writeSector (sector); ++sectorNumber;
/* fat32 boot area */
if (ft->size_fat == 32)
{
/* fsinfo */
PutFSInfo((byte *) sector, ft);
PutFSInfo((uint8 *) sector, ft);
writeSector (sector); ++sectorNumber;
/* reserved */
@ -317,10 +317,10 @@ namespace VeraCrypt
/* bootsector backup */
sector.Zero();
PutBoot (ft, (byte *) sector, volumeId);
PutBoot (ft, (uint8 *) sector, volumeId);
writeSector (sector); ++sectorNumber;
PutFSInfo((byte *) sector, ft);
PutFSInfo((uint8 *) sector, ft);
writeSector (sector); ++sectorNumber;
}
@ -340,10 +340,10 @@ namespace VeraCrypt
if (n == 0)
{
byte fat_sig[12];
uint8 fat_sig[12];
if (ft->size_fat == 32)
{
fat_sig[0] = (byte) ft->media;
fat_sig[0] = (uint8) ft->media;
fat_sig[1] = fat_sig[2] = 0xff;
fat_sig[3] = 0x0f;
fat_sig[4] = fat_sig[5] = fat_sig[6] = 0xff;
@ -354,7 +354,7 @@ namespace VeraCrypt
}
else if (ft->size_fat == 16)
{
fat_sig[0] = (byte) ft->media;
fat_sig[0] = (uint8) ft->media;
fat_sig[1] = 0xff;
fat_sig[2] = 0xff;
fat_sig[3] = 0xff;
@ -362,7 +362,7 @@ namespace VeraCrypt
}
else if (ft->size_fat == 12)
{
fat_sig[0] = (byte) ft->media;
fat_sig[0] = (uint8) ft->media;
fat_sig[1] = 0xff;
fat_sig[2] = 0xff;
fat_sig[3] = 0x00;

4
src/Core/RandomNumberGenerator.cpp
View File

@ -114,7 +114,7 @@ namespace VeraCrypt
ScopeLock lock (AccessMutex);
size_t bufferLen = buffer.Size(), loopLen;
byte* pbBuffer = buffer.Get();
uint8* pbBuffer = buffer.Get();
// Initialize JitterEntropy RNG for this call
if (0 == jent_entropy_init ())
@ -267,7 +267,7 @@ namespace VeraCrypt
Buffer buffer (1);
for (size_t i = 0; i < PoolSize * 10; ++i)
{
buffer[0] = (byte) i;
buffer[0] = (uint8) i;
AddToPool (buffer);
}

6
src/Core/Unix/CoreService.cpp
View File

@ -57,7 +57,7 @@ namespace VeraCrypt
// Wait for sync code
while (true)
{
byte b;
uint8 b;
throw_sys_if (read (STDIN_FILENO, &b, 1) != 1);
if (b != 0x00)
continue;
@ -543,7 +543,7 @@ namespace VeraCrypt
try
{
shared_ptr <Stream> stream (new MemoryStream (ConstBufferPtr ((byte *) &errOutput[0], errOutput.size())));
shared_ptr <Stream> stream (new MemoryStream (ConstBufferPtr ((uint8 *) &errOutput[0], errOutput.size())));
deserializedObject.reset (Serializable::DeserializeNew (stream));
deserializedException = dynamic_cast <Exception*> (deserializedObject.get());
}
@ -575,7 +575,7 @@ namespace VeraCrypt
ServiceOutputStream = shared_ptr <Stream> (new FileStream (outPipe->GetReadFD()));
// Send sync code
byte sync[] = { 0, 0x11, 0x22 };
uint8 sync[] = { 0, 0x11, 0x22 };
ServiceInputStream->Write (ConstBufferPtr (sync, array_capacity (sync)));
AdminInputPipe = move_ptr(inPipe);

2
src/Core/Unix/CoreUnix.cpp
View File

@ -241,7 +241,7 @@ namespace VeraCrypt
device.SeekAt (0);
device.ReadCompleteBuffer (bootSector);
byte *b = bootSector.Ptr();
uint8 *b = bootSector.Ptr();
return memcmp (b + 3, "NTFS", 4) != 0
&& memcmp (b + 54, "FAT", 3) != 0

2
src/Core/Unix/Linux/CoreLinux.cpp
View File

@ -386,7 +386,7 @@ namespace VeraCrypt
dmCreateArgs << nativeDevPath << " 0";
SecureBuffer dmCreateArgsBuf (dmCreateArgs.str().size());
dmCreateArgsBuf.CopyFrom (ConstBufferPtr ((byte *) dmCreateArgs.str().c_str(), dmCreateArgs.str().size()));
dmCreateArgsBuf.CopyFrom (ConstBufferPtr ((uint8 *) dmCreateArgs.str().c_str(), dmCreateArgs.str().size()));
// Keys
const SecureBuffer &cipherKey = cipher.GetKey();

10
src/Crypto/Aes_hw_cpu.h
View File

@ -21,13 +21,13 @@ extern "C"
#endif
#if defined (TC_WINDOWS_BOOT)
byte is_aes_hw_cpu_supported ();
uint8 is_aes_hw_cpu_supported ();
#endif
void aes_hw_cpu_enable_sse ();
void aes_hw_cpu_decrypt (const byte *ks, byte *data);
void aes_hw_cpu_decrypt_32_blocks (const byte *ks, byte *data);
void aes_hw_cpu_encrypt (const byte *ks, byte *data);
void aes_hw_cpu_encrypt_32_blocks (const byte *ks, byte *data);
void aes_hw_cpu_decrypt (const uint8 *ks, uint8 *data);
void aes_hw_cpu_decrypt_32_blocks (const uint8 *ks, uint8 *data);
void aes_hw_cpu_encrypt (const uint8 *ks, uint8 *data);
void aes_hw_cpu_encrypt_32_blocks (const uint8 *ks, uint8 *data);
#if defined(__cplusplus)
}

20
src/Crypto/Camellia.c
View File

@ -11,10 +11,10 @@
* NTT (Nippon Telegraph and Telephone Corporation) . All rights reserved.
*
* SuperCop integration:
* Copyright © 2013 Jussi Kivilinna <jussi.kivilinna@iki.fi>
* Copyright © 2013 Jussi Kivilinna <jussi.kivilinna@iki.fi>
*
* VeraCrypt integration:
* Copyright © 2017 Mounir IDRASSI <mounir.idrassi@idrix.fr>
* Copyright © 2017 Mounir IDRASSI <mounir.idrassi@idrix.fr>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@ -51,12 +51,12 @@
extern int IsAesHwCpuSupported ();
#endif
void camellia_encrypt_asm(const byte *ctx, void *dst, const void *src);
void camellia_decrypt_asm(const byte *ctx, void *dst, const void *src);
void camellia_enc_blk2(const byte *ctx, byte *dst, const byte *src);
void camellia_dec_blk2(const byte *ctx, byte *dst, const byte *src);
void camellia_ecb_enc_16way(const byte *ctx, byte *dst, const byte *src);
void camellia_ecb_dec_16way(const byte *ctx, byte *dst, const byte *src);
void camellia_encrypt_asm(const uint8 *ctx, void *dst, const void *src);
void camellia_decrypt_asm(const uint8 *ctx, void *dst, const void *src);
void camellia_enc_blk2(const uint8 *ctx, uint8 *dst, const uint8 *src);
void camellia_dec_blk2(const uint8 *ctx, uint8 *dst, const uint8 *src);
void camellia_ecb_enc_16way(const uint8 *ctx, uint8 *dst, const uint8 *src);
void camellia_ecb_dec_16way(const uint8 *ctx, uint8 *dst, const uint8 *src);
/* key constants */
@ -1093,7 +1093,7 @@ void camellia_decrypt(const unsigned __int8 *inBlock, unsigned __int8 *outBlock
camellia_decrypt_asm (ks, outBlock, inBlock);
}
void camellia_encrypt_blocks(unsigned __int8 *instance, const byte* in_blk, byte* out_blk, uint32 blockCount)
void camellia_encrypt_blocks(unsigned __int8 *instance, const uint8* in_blk, uint8* out_blk, uint32 blockCount)
{
#if !defined (_UEFI)
if ((blockCount >= 16) && IsCpuIntel() && IsAesHwCpuSupported () && HasSAVX()) /* on AMD cpu, AVX is too slow */
@ -1129,7 +1129,7 @@ void camellia_encrypt_blocks(unsigned __int8 *instance, const byte* in_blk, byte
camellia_encrypt (in_blk, out_blk, instance);
}
void camellia_decrypt_blocks(unsigned __int8 *instance, const byte* in_blk, byte* out_blk, uint32 blockCount)
void camellia_decrypt_blocks(unsigned __int8 *instance, const uint8* in_blk, uint8* out_blk, uint32 blockCount)
{
#if !defined (_UEFI)
if ((blockCount >= 16) && IsCpuIntel() && IsAesHwCpuSupported () && HasSAVX()) /* on AMD cpu, AVX is too slow */

4
src/Crypto/Camellia.h
View File

@ -18,8 +18,8 @@ void camellia_encrypt(const unsigned __int8 *inBlock, unsigned __int8 *outBlock,
void camellia_decrypt(const unsigned __int8 *inBlock, unsigned __int8 *outBlock, unsigned __int8 *ks);
#if CRYPTOPP_BOOL_X64 && !defined(CRYPTOPP_DISABLE_ASM)
void camellia_encrypt_blocks(unsigned __int8 *ks, const byte* in_blk, byte* out_blk, uint32 blockCount);
void camellia_decrypt_blocks(unsigned __int8 *ks, const byte* in_blk, byte* out_blk, uint32 blockCount);
void camellia_encrypt_blocks(unsigned __int8 *ks, const uint8* in_blk, uint8* out_blk, uint32 blockCount);
void camellia_decrypt_blocks(unsigned __int8 *ks, const uint8* in_blk, uint8* out_blk, uint32 blockCount);
#endif
#ifdef __cplusplus

2
src/Crypto/Sha2.c
View File

@ -447,7 +447,7 @@ static void CRYPTOPP_FASTCALL X86_SHA256_HashBlocks(uint_32t *state, const uint_
#if defined(__GNUC__)
#if CRYPTOPP_BOOL_X64
CRYPTOPP_ALIGN_DATA(16) byte workspace[LOCALS_SIZE] ;
CRYPTOPP_ALIGN_DATA(16) uint8 workspace[LOCALS_SIZE] ;
#endif
__asm__ __volatile__
(

2
src/Crypto/Sha2Small.c
View File

@ -20,7 +20,7 @@
#pragma optimize ("tl", on)
typedef unsigned __int32 uint32;
typedef unsigned __int8 byte;
typedef unsigned __int8 uint8;
#include <stdlib.h>
#pragma intrinsic(_lrotr)

4
src/Crypto/Streebog.c
View File

@ -2253,7 +2253,7 @@ stage3(STREEBOG_CTX *CTX)
memcpy((CTX->hash), (CTX->h), 8 * sizeof(unsigned long long));
}
void STREEBOG_add(STREEBOG_CTX *CTX, const byte *data, size_t len)
void STREEBOG_add(STREEBOG_CTX *CTX, const uint8 *data, size_t len)
{
size_t chunksize;
@ -2286,7 +2286,7 @@ void STREEBOG_add(STREEBOG_CTX *CTX, const byte *data, size_t len)
}
}
void STREEBOG_finalize(STREEBOG_CTX *CTX, byte *digest)
void STREEBOG_finalize(STREEBOG_CTX *CTX, uint8 *digest)
{
stage3(CTX);

4
src/Crypto/Streebog.h
View File

@ -31,8 +31,8 @@ typedef STREEBOG_ALIGN(16) struct _STREEBOG_CTX
void STREEBOG_init(STREEBOG_CTX *ctx);
void STREEBOG_init256(STREEBOG_CTX *ctx);
void STREEBOG_add(STREEBOG_CTX *ctx, const byte *msg, size_t len);
void STREEBOG_finalize(STREEBOG_CTX *ctx, byte *out);
void STREEBOG_add(STREEBOG_CTX *ctx, const uint8 *msg, size_t len);
void STREEBOG_finalize(STREEBOG_CTX *ctx, uint8 *out);
#ifdef __cplusplus
}

24
src/Crypto/Twofish.c
View File

@ -57,25 +57,25 @@
#if CRYPTOPP_BOOL_X64 && !defined(CRYPTOPP_DISABLE_ASM)
/* these are 64-bit assembly implementation taken from https://github.com/jkivilin/supercop-blockciphers
Copyright © 2011-2013 Jussi Kivilinna <jussi.kivilinna@iki.fi>
Copyright © 2011-2013 Jussi Kivilinna <jussi.kivilinna@iki.fi>
*/
#if defined(__cplusplus)
extern "C"
{
#endif
void twofish_enc_blk(TwofishInstance *ks, byte *dst, const byte *src);
void twofish_dec_blk(TwofishInstance *ks, byte *dst, const byte *src);
void twofish_enc_blk2(TwofishInstance *ks, byte *dst, const byte *src);
void twofish_dec_blk2(TwofishInstance *ks, byte *dst, const byte *src);
void twofish_enc_blk3(TwofishInstance *ks, byte *dst, const byte *src);
void twofish_dec_blk3(TwofishInstance *ks, byte *dst, const byte *src);
void twofish_enc_blk(TwofishInstance *ks, uint8 *dst, const uint8 *src);
void twofish_dec_blk(TwofishInstance *ks, uint8 *dst, const uint8 *src);
void twofish_enc_blk2(TwofishInstance *ks, uint8 *dst, const uint8 *src);
void twofish_dec_blk2(TwofishInstance *ks, uint8 *dst, const uint8 *src);
void twofish_enc_blk3(TwofishInstance *ks, uint8 *dst, const uint8 *src);
void twofish_dec_blk3(TwofishInstance *ks, uint8 *dst, const uint8 *src);
#if defined(__cplusplus)
}
#endif
void twofish_encrypt_blocks(TwofishInstance *instance, const byte* in_blk, byte* out_blk, uint32 blockCount)
void twofish_encrypt_blocks(TwofishInstance *instance, const uint8* in_blk, uint8* out_blk, uint32 blockCount)
{
while (blockCount >= 3)
{
@ -96,7 +96,7 @@ void twofish_encrypt_blocks(TwofishInstance *instance, const byte* in_blk, byte*
}
void twofish_decrypt_blocks(TwofishInstance *instance, const byte* in_blk, byte* out_blk, uint32 blockCount)
void twofish_decrypt_blocks(TwofishInstance *instance, const uint8* in_blk, uint8* out_blk, uint32 blockCount)
{
while (blockCount >= 3)
{
@ -120,7 +120,7 @@ void twofish_decrypt_blocks(TwofishInstance *instance, const byte* in_blk, byte*
#endif
static const byte Q[2][256] = {
static const uint8 Q[2][256] = {
{
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,
@ -604,11 +604,11 @@ static const uint32 RS[8][256] = {
void twofish_set_key(TwofishInstance *instance, const u4byte in_key[])
{
union {
byte S8[16];
uint8 S8[16];
uint32 S32[4];
} us;
unsigned int i;
const byte* key = (const byte*) in_key;
const uint8* key = (const uint8*) in_key;
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]];

8
src/Crypto/Twofish.h
View File

@ -55,10 +55,10 @@ typedef struct
/* 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)
void twofish_encrypt_blocks(TwofishInstance *instance, const byte* in_blk, byte* out_blk, uint32 blockCount);
void twofish_decrypt_blocks(TwofishInstance *instance, const byte* in_blk, byte* out_blk, uint32 blockCount);
#define twofish_encrypt(instance,in_blk,out_blk) twofish_encrypt_blocks(instance, (const byte*) in_blk, (byte*) out_blk, 1)
#define twofish_decrypt(instance,in_blk,out_blk) twofish_decrypt_blocks(instance, (const byte*) in_blk, (byte*) out_blk, 1)
void twofish_encrypt_blocks(TwofishInstance *instance, const uint8* in_blk, uint8* out_blk, uint32 blockCount);
void twofish_decrypt_blocks(TwofishInstance *instance, const uint8* in_blk, uint8* out_blk, uint32 blockCount);
#define twofish_encrypt(instance,in_blk,out_blk) twofish_encrypt_blocks(instance, (const uint8*) in_blk, (uint8*) out_blk, 1)
#define twofish_decrypt(instance,in_blk,out_blk) twofish_decrypt_blocks(instance, (const uint8*) in_blk, (uint8*) out_blk, 1)
#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]);

4
src/Crypto/Whirlpool.c
View File

@ -936,7 +936,7 @@ void WHIRLPOOL_add(const unsigned char * input,
else
{
uint64* dataBuf = ctx->data;
byte* data = (byte *)dataBuf;
uint8* data = (uint8 *)dataBuf;
num = oldCountLo & 63;
if (num != 0) // process left over data
@ -996,7 +996,7 @@ void WHIRLPOOL_finalize(WHIRLPOOL_CTX * const ctx,
unsigned int num = ctx->countLo & 63;
uint64* dataBuf = ctx->data;
uint64* stateBuf = ctx->state;
byte* data = (byte *)dataBuf;
uint8* data = (uint8 *)dataBuf;
data[num++] = 0x80;
if (num <= 32)

1
src/Crypto/chacha-xmm.c
View File

@ -43,7 +43,6 @@ __inline __m128i _mm_set1_epi64x(int64 a)
#endif
#endif
#define uint8 byte
#define U32V(v) (v)
#define ROTL32(x,n) rotl32(x, n)

4
src/Crypto/config.h
View File

@ -209,8 +209,8 @@
#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)
// #define GETBYTE(x, y) (((byte *)&(x))[y])
// #define GETBYTE(x, y) (((uint8 *)&(x))[y])
#define CRYPTOPP_GET_BYTE_AS_BYTE(x, y) ((byte)((x)>>(8*(y))))
#define CRYPTOPP_GET_BYTE_AS_BYTE(x, y) ((uint8)((x)>>(8*(y))))
#endif

64
src/Crypto/kuznyechik.c
View File

@ -12,16 +12,16 @@ and released into public domain.
#endif
#if CRYPTOPP_BOOL_SSE2_INTRINSICS_AVAILABLE
void kuznyechik_set_key_simd(const byte* key, kuznyechik_kds *kds);
void kuznyechik_encrypt_block_simd(byte* out, const byte* in, kuznyechik_kds* kds);
void kuznyechik_encrypt_blocks_simd(byte* out, const byte* in, size_t blocks, kuznyechik_kds* kds);
void kuznyechik_decrypt_block_simd(byte* out, const byte* in, kuznyechik_kds* kds);
void kuznyechik_decrypt_blocks_simd(byte* out, const byte* in, size_t blocks, kuznyechik_kds* kds);
void kuznyechik_set_key_simd(const uint8* key, kuznyechik_kds *kds);
void kuznyechik_encrypt_block_simd(uint8* out, const uint8* in, kuznyechik_kds* kds);
void kuznyechik_encrypt_blocks_simd(uint8* out, const uint8* in, size_t blocks, kuznyechik_kds* kds);
void kuznyechik_decrypt_block_simd(uint8* out, const uint8* in, kuznyechik_kds* kds);
void kuznyechik_decrypt_blocks_simd(uint8* out, const uint8* in, size_t blocks, kuznyechik_kds* kds);
#endif
//#define CPPCRYPTO_DEBUG
static const byte S[256] = {
static const uint8 S[256] = {
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,7 +32,7 @@ void kuznyechik_decrypt_blocks_simd(byte* out, const byte* in, size_t blocks, ku
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
};
static const byte IS[256] = {
static const uint8 IS[256] = {
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,
@ -2144,30 +2144,30 @@ void kuznyechik_decrypt_blocks_simd(byte* out, const byte* in, size_t blocks, ku
};
#define LS(x1,x2,t1,t2) { \
t1 = T[0][(byte)(x1)][0] ^ T[1][(byte)(x1 >> 8)][0] ^ T[2][(byte)(x1 >> 16)][0] ^ T[3][(byte)(x1 >> 24)][0] ^ T[4][(byte)(x1 >> 32)][0] ^ T[5][(byte)(x1 >> 40)][0] ^ \
T[6][(byte)(x1 >> 48)][0] ^ T[7][(byte)(x1 >> 56)][0] ^ T[8][(byte)(x2)][0] ^ T[9][(byte)(x2 >> 8)][0] ^ T[10][(byte)(x2 >> 16)][0] ^ T[11][(byte)(x2 >> 24)][0] ^ \
T[12][(byte)(x2 >> 32)][0] ^ T[13][(byte)(x2 >> 40)][0] ^ T[14][(byte)(x2 >> 48)][0] ^ T[15][(byte)(x2 >> 56)][0]; \
t2 = T[0][(byte)(x1)][1] ^ T[1][(byte)(x1 >> 8)][1] ^ T[2][(byte)(x1 >> 16)][1] ^ T[3][(byte)(x1 >> 24)][1] ^ T[4][(byte)(x1 >> 32)][1] ^ T[5][(byte)(x1 >> 40)][1] ^ \
T[6][(byte)(x1 >> 48)][1] ^ T[7][(byte)(x1 >> 56)][1] ^ T[8][(byte)(x2)][1] ^ T[9][(byte)(x2 >> 8)][1] ^ T[10][(byte)(x2 >> 16)][1] ^ T[11][(byte)(x2 >> 24)][1] ^ \
T[12][(byte)(x2 >> 32)][1] ^ T[13][(byte)(x2 >> 40)][1] ^ T[14][(byte)(x2 >> 48)][1] ^ T[15][(byte)(x2 >> 56)][1]; \
t1 = T[0][(uint8)(x1)][0] ^ T[1][(uint8)(x1 >> 8)][0] ^ T[2][(uint8)(x1 >> 16)][0] ^ T[3][(uint8)(x1 >> 24)][0] ^ T[4][(uint8)(x1 >> 32)][0] ^ T[5][(uint8)(x1 >> 40)][0] ^ \
T[6][(uint8)(x1 >> 48)][0] ^ T[7][(uint8)(x1 >> 56)][0] ^ T[8][(uint8)(x2)][0] ^ T[9][(uint8)(x2 >> 8)][0] ^ T[10][(uint8)(x2 >> 16)][0] ^ T[11][(uint8)(x2 >> 24)][0] ^ \
T[12][(uint8)(x2 >> 32)][0] ^ T[13][(uint8)(x2 >> 40)][0] ^ T[14][(uint8)(x2 >> 48)][0] ^ T[15][(uint8)(x2 >> 56)][0]; \
t2 = T[0][(uint8)(x1)][1] ^ T[1][(uint8)(x1 >> 8)][1] ^ T[2][(uint8)(x1 >> 16)][1] ^ T[3][(uint8)(x1 >> 24)][1] ^ T[4][(uint8)(x1 >> 32)][1] ^ T[5][(uint8)(x1 >> 40)][1] ^ \
T[6][(uint8)(x1 >> 48)][1] ^ T[7][(uint8)(x1 >> 56)][1] ^ T[8][(uint8)(x2)][1] ^ T[9][(uint8)(x2 >> 8)][1] ^ T[10][(uint8)(x2 >> 16)][1] ^ T[11][(uint8)(x2 >> 24)][1] ^ \
T[12][(uint8)(x2 >> 32)][1] ^ T[13][(uint8)(x2 >> 40)][1] ^ T[14][(uint8)(x2 >> 48)][1] ^ T[15][(uint8)(x2 >> 56)][1]; \
}
#define ILS(x1,x2,t1,t2) { \
t1 = IT[0][(byte)(x1)][0] ^ IT[1][(byte)(x1 >> 8)][0] ^ IT[2][(byte)(x1 >> 16)][0] ^ IT[3][(byte)(x1 >> 24)][0] ^ IT[4][(byte)(x1 >> 32)][0] ^ IT[5][(byte)(x1 >> 40)][0] ^ \
IT[6][(byte)(x1 >> 48)][0] ^ IT[7][(byte)(x1 >> 56)][0] ^ IT[8][(byte)(x2)][0] ^ IT[9][(byte)(x2 >> 8)][0] ^ IT[10][(byte)(x2 >> 16)][0] ^ IT[11][(byte)(x2 >> 24)][0] ^ \
IT[12][(byte)(x2 >> 32)][0] ^ IT[13][(byte)(x2 >> 40)][0] ^ IT[14][(byte)(x2 >> 48)][0] ^ IT[15][(byte)(x2 >> 56)][0]; \
t2 = IT[0][(byte)(x1)][1] ^ IT[1][(byte)(x1 >> 8)][1] ^ IT[2][(byte)(x1 >> 16)][1] ^ IT[3][(byte)(x1 >> 24)][1] ^ IT[4][(byte)(x1 >> 32)][1] ^ IT[5][(byte)(x1 >> 40)][1] ^ \
IT[6][(byte)(x1 >> 48)][1] ^ IT[7][(byte)(x1 >> 56)][1] ^ IT[8][(byte)(x2)][1] ^ IT[9][(byte)(x2 >> 8)][1] ^ IT[10][(byte)(x2 >> 16)][1] ^ IT[11][(byte)(x2 >> 24)][1] ^ \
IT[12][(byte)(x2 >> 32)][1] ^ IT[13][(byte)(x2 >> 40)][1] ^ IT[14][(byte)(x2 >> 48)][1] ^ IT[15][(byte)(x2 >> 56)][1]; \
t1 = IT[0][(uint8)(x1)][0] ^ IT[1][(uint8)(x1 >> 8)][0] ^ IT[2][(uint8)(x1 >> 16)][0] ^ IT[3][(uint8)(x1 >> 24)][0] ^ IT[4][(uint8)(x1 >> 32)][0] ^ IT[5][(uint8)(x1 >> 40)][0] ^ \
IT[6][(uint8)(x1 >> 48)][0] ^ IT[7][(uint8)(x1 >> 56)][0] ^ IT[8][(uint8)(x2)][0] ^ IT[9][(uint8)(x2 >> 8)][0] ^ IT[10][(uint8)(x2 >> 16)][0] ^ IT[11][(uint8)(x2 >> 24)][0] ^ \
IT[12][(uint8)(x2 >> 32)][0] ^ IT[13][(uint8)(x2 >> 40)][0] ^ IT[14][(uint8)(x2 >> 48)][0] ^ IT[15][(uint8)(x2 >> 56)][0]; \
t2 = IT[0][(uint8)(x1)][1] ^ IT[1][(uint8)(x1 >> 8)][1] ^ IT[2][(uint8)(x1 >> 16)][1] ^ IT[3][(uint8)(x1 >> 24)][1] ^ IT[4][(uint8)(x1 >> 32)][1] ^ IT[5][(uint8)(x1 >> 40)][1] ^ \
IT[6][(uint8)(x1 >> 48)][1] ^ IT[7][(uint8)(x1 >> 56)][1] ^ IT[8][(uint8)(x2)][1] ^ IT[9][(uint8)(x2 >> 8)][1] ^ IT[10][(uint8)(x2 >> 16)][1] ^ IT[11][(uint8)(x2 >> 24)][1] ^ \
IT[12][(uint8)(x2 >> 32)][1] ^ IT[13][(uint8)(x2 >> 40)][1] ^ IT[14][(uint8)(x2 >> 48)][1] ^ IT[15][(uint8)(x2 >> 56)][1]; \
}
#define ILSS(x1,x2,t1,t2) { \
t1 = IT[0][S[(byte)(x1)]][0] ^ IT[1][S[(byte)(x1 >> 8)]][0] ^ IT[2][S[(byte)(x1 >> 16)]][0] ^ IT[3][S[(byte)(x1 >> 24)]][0] ^ IT[4][S[(byte)(x1 >> 32)]][0] ^ IT[5][S[(byte)(x1 >> 40)]][0] ^ \
IT[6][S[(byte)(x1 >> 48)]][0] ^ IT[7][S[(byte)(x1 >> 56)]][0] ^ IT[8][S[(byte)(x2)]][0] ^ IT[9][S[(byte)(x2 >> 8)]][0] ^ IT[10][S[(byte)(x2 >> 16)]][0] ^ IT[11][S[(byte)(x2 >> 24)]][0] ^ \
IT[12][S[(byte)(x2 >> 32)]][0] ^ IT[13][S[(byte)(x2 >> 40)]][0] ^ IT[14][S[(byte)(x2 >> 48)]][0] ^ IT[15][S[(byte)(x2 >> 56)]][0]; \
t2 = IT[0][S[(byte)(x1)]][1] ^ IT[1][S[(byte)(x1 >> 8)]][1] ^ IT[2][S[(byte)(x1 >> 16)]][1] ^ IT[3][S[(byte)(x1 >> 24)]][1] ^ IT[4][S[(byte)(x1 >> 32)]][1] ^ IT[5][S[(byte)(x1 >> 40)]][1] ^ \
IT[6][S[(byte)(x1 >> 48)]][1] ^ IT[7][S[(byte)(x1 >> 56)]][1] ^ IT[8][S[(byte)(x2)]][1] ^ IT[9][S[(byte)(x2 >> 8)]][1] ^ IT[10][S[(byte)(x2 >> 16)]][1] ^ IT[11][S[(byte)(x2 >> 24)]][1] ^ \
IT[12][S[(byte)(x2 >> 32)]][1] ^ IT[13][S[(byte)(x2 >> 40)]][1] ^ IT[14][S[(byte)(x2 >> 48)]][1] ^ IT[15][S[(byte)(x2 >> 56)]][1]; \
t1 = IT[0][S[(uint8)(x1)]][0] ^ IT[1][S[(uint8)(x1 >> 8)]][0] ^ IT[2][S[(uint8)(x1 >> 16)]][0] ^ IT[3][S[(uint8)(x1 >> 24)]][0] ^ IT[4][S[(uint8)(x1 >> 32)]][0] ^ IT[5][S[(uint8)(x1 >> 40)]][0] ^ \
IT[6][S[(uint8)(x1 >> 48)]][0] ^ IT[7][S[(uint8)(x1 >> 56)]][0] ^ IT[8][S[(uint8)(x2)]][0] ^ IT[9][S[(uint8)(x2 >> 8)]][0] ^ IT[10][S[(uint8)(x2 >> 16)]][0] ^ IT[11][S[(uint8)(x2 >> 24)]][0] ^ \
IT[12][S[(uint8)(x2 >> 32)]][0] ^ IT[13][S[(uint8)(x2 >> 40)]][0] ^ IT[14][S[(uint8)(x2 >> 48)]][0] ^ IT[15][S[(uint8)(x2 >> 56)]][0]; \
t2 = IT[0][S[(uint8)(x1)]][1] ^ IT[1][S[(uint8)(x1 >> 8)]][1] ^ IT[2][S[(uint8)(x1 >> 16)]][1] ^ IT[3][S[(uint8)(x1 >> 24)]][1] ^ IT[4][S[(uint8)(x1 >> 32)]][1] ^ IT[5][S[(uint8)(x1 >> 40)]][1] ^ \
IT[6][S[(uint8)(x1 >> 48)]][1] ^ IT[7][S[(uint8)(x1 >> 56)]][1] ^ IT[8][S[(uint8)(x2)]][1] ^ IT[9][S[(uint8)(x2 >> 8)]][1] ^ IT[10][S[(uint8)(x2 >> 16)]][1] ^ IT[11][S[(uint8)(x2 >> 24)]][1] ^ \
IT[12][S[(uint8)(x2 >> 32)]][1] ^ IT[13][S[(uint8)(x2 >> 40)]][1] ^ IT[14][S[(uint8)(x2 >> 48)]][1] ^ IT[15][S[(uint8)(x2 >> 56)]][1]; \
}
#define ISI(val) { \
@ -2199,7 +2199,7 @@ void kuznyechik_decrypt_blocks_simd(byte* out, const byte* in, size_t blocks, ku
} \
}
void kuznyechik_set_key(const byte* key, kuznyechik_kds* kds)
void kuznyechik_set_key(const uint8* key, kuznyechik_kds* kds)
{
#if CRYPTOPP_BOOL_SSE2_INTRINSICS_AVAILABLE && !defined(_UEFI) && (!defined (TC_WINDOWS_DRIVER) || (!defined (DEBUG) && defined (_WIN64)))
if(HasSSE2())
@ -2258,7 +2258,7 @@ void kuznyechik_decrypt_blocks_simd(byte* out, const byte* in, size_t blocks, ku
}
void kuznyechik_encrypt_block(byte* out, const byte* in, kuznyechik_kds* kds)
void kuznyechik_encrypt_block(uint8* out, const uint8* in, kuznyechik_kds* kds)
{
#if CRYPTOPP_BOOL_SSE2_INTRINSICS_AVAILABLE && !defined(_UEFI) && (!defined (TC_WINDOWS_DRIVER) || (!defined (DEBUG) && defined (_WIN64)))
if(HasSSE2())
@ -2305,7 +2305,7 @@ void kuznyechik_decrypt_blocks_simd(byte* out, const byte* in, size_t blocks, ku
}
}
void kuznyechik_encrypt_blocks(byte* out, const byte* in, size_t blocks, kuznyechik_kds* kds)
void kuznyechik_encrypt_blocks(uint8* out, const uint8* in, size_t blocks, kuznyechik_kds* kds)
{
#if CRYPTOPP_BOOL_SSE2_INTRINSICS_AVAILABLE && !defined(_UEFI) && (!defined (DEBUG) || !defined (TC_WINDOWS_DRIVER))
if(HasSSE2())
@ -2325,7 +2325,7 @@ void kuznyechik_decrypt_blocks_simd(byte* out, const byte* in, size_t blocks, ku
}
}
void kuznyechik_decrypt_block(byte* out, const byte* in, kuznyechik_kds* kds)
void kuznyechik_decrypt_block(uint8* out, const uint8* in, kuznyechik_kds* kds)
{
#if CRYPTOPP_BOOL_SSE2_INTRINSICS_AVAILABLE && !defined(_UEFI) && (!defined (TC_WINDOWS_DRIVER) || (!defined (DEBUG) && defined (_WIN64)))
if(HasSSE2())
@ -2366,8 +2366,8 @@ void kuznyechik_decrypt_blocks_simd(byte* out, const byte* in, size_t blocks, ku
ILS(x1, x2, t1, t2);
t1 ^= kds->rkd[2];
t2 ^= kds->rkd[3];
ISI((byte*)&t1);
ISI((byte*)&t2);
ISI((uint8*)&t1);
ISI((uint8*)&t2);
t1 ^= kds->rkd[0];
t2 ^= kds->rkd[1];
*(uint64*)out = t1;
@ -2375,7 +2375,7 @@ void kuznyechik_decrypt_blocks_simd(byte* out, const byte* in, size_t blocks, ku
}
}
void kuznyechik_decrypt_blocks(byte* out, const byte* in, size_t blocks, kuznyechik_kds* kds)
void kuznyechik_decrypt_blocks(uint8* out, const uint8* in, size_t blocks, kuznyechik_kds* kds)
{
#if CRYPTOPP_BOOL_SSE2_INTRINSICS_AVAILABLE && !defined(_UEFI) && (!defined (DEBUG) || !defined (TC_WINDOWS_DRIVER))
if(HasSSE2())

10
src/Crypto/kuznyechik.h
View File

@ -22,11 +22,11 @@ typedef struct _kuznyechik_kds
#define KUZNYECHIK_KS (sizeof(kuznyechik_kds))
void kuznyechik_encrypt_block(byte* out, const byte* in, kuznyechik_kds* kds);
void kuznyechik_encrypt_blocks(byte* out, const byte* in, size_t blocks, kuznyechik_kds* kds);
void kuznyechik_decrypt_block(byte* out, const byte* in, kuznyechik_kds* kds);
void kuznyechik_decrypt_blocks(byte* out, const byte* in, size_t blocks, kuznyechik_kds* kds);
void kuznyechik_set_key(const byte* key, kuznyechik_kds *kds);
void kuznyechik_encrypt_block(uint8* out, const uint8* in, kuznyechik_kds* kds);
void kuznyechik_encrypt_blocks(uint8* out, const uint8* in, size_t blocks, kuznyechik_kds* kds);
void kuznyechik_decrypt_block(uint8* out, const uint8* in, kuznyechik_kds* kds);
void kuznyechik_decrypt_blocks(uint8* out, const uint8* in, size_t blocks, kuznyechik_kds* kds);
void kuznyechik_set_key(const uint8* key, kuznyechik_kds *kds);
#ifdef __cplusplus
}

10
src/Crypto/kuznyechik_simd.c
View File

@ -9169,7 +9169,7 @@ VC_INLINE void scheduleDecryptionRoundKeysForGost15(
applyLSTransformation_4(data1_, data2_, data3_,data4_); \
}
void kuznyechik_encrypt_block_simd(byte* out, const byte* in, kuznyechik_kds* kds)
void kuznyechik_encrypt_block_simd(uint8* out, const uint8* in, kuznyechik_kds* kds)
{
const uint_64t *roundKeys_ = (const uint_64t *) kds->rke;
__m128i data_;
@ -9200,7 +9200,7 @@ void kuznyechik_encrypt_block_simd(byte* out, const byte* in, kuznyechik_kds* kd
_mm_storeu_si128((__m128i*) out, data_);
}
void kuznyechik_encrypt_blocks_simd(byte* out, const byte* in, size_t blocks, kuznyechik_kds* kds)
void kuznyechik_encrypt_blocks_simd(uint8* out, const uint8* in, size_t blocks, kuznyechik_kds* kds)
{
const uint_64t *roundKeys_ = (const uint_64t *) kds->rke;
__m128i data1_, data2_, data3_, data4_;
@ -9347,7 +9347,7 @@ void kuznyechik_encrypt_blocks_simd(byte* out, const byte* in, size_t blocks, ku
data4_ = _mm_xor_si128(data4_, cache11_); \
}
void kuznyechik_decrypt_block_simd(byte* out, const byte* in, kuznyechik_kds* kds)
void kuznyechik_decrypt_block_simd(uint8* out, const uint8* in, kuznyechik_kds* kds)
{
const uint_64t *roundKeys_ = kds->rkd;
__m128i data_;
@ -9383,7 +9383,7 @@ void kuznyechik_decrypt_block_simd(byte* out, const byte* in, kuznyechik_kds* kd
_mm_storeu_si128((__m128i*) out, data_);
}
void kuznyechik_decrypt_blocks_simd(byte* out, const byte* in, size_t blocks, kuznyechik_kds* kds)
void kuznyechik_decrypt_blocks_simd(uint8* out, const uint8* in, size_t blocks, kuznyechik_kds* kds)
{
const uint_64t *roundKeys_ = kds->rkd;
__m128i data1_, data2_,data3_,data4_;
@ -9508,7 +9508,7 @@ void kuznyechik_decrypt_blocks_simd(byte* out, const byte* in, size_t blocks, ku
kuznyechik_decrypt_block_simd (out, in, kds);
}
void kuznyechik_set_key_simd(const byte* key, kuznyechik_kds *kds)
void kuznyechik_set_key_simd(const uint8* key, kuznyechik_kds *kds)
{
scheduleEncryptionRoundKeysForGost15 (kds->rke, key);
scheduleDecryptionRoundKeysForGost15 (kds->rkd, key);

4
src/Crypto/rdrand.c
View File

@ -6,8 +6,8 @@
#include "cpu.h"
#include "misc.h"
void CRYPTOPP_FASTCALL MASM_RDRAND_GenerateBlock(byte*, size_t);
void CRYPTOPP_FASTCALL MASM_RDSEED_GenerateBlock(byte*, size_t);
void CRYPTOPP_FASTCALL MASM_RDRAND_GenerateBlock(uint8*, size_t);
void CRYPTOPP_FASTCALL MASM_RDSEED_GenerateBlock(uint8*, size_t);
int RDRAND_getBytes(unsigned char* buf, size_t bufLen)
{

2
src/Crypto/t1ha.h
View File

@ -183,7 +183,7 @@ extern "C" {
#define T1HA_ALIGN_SUFFIX
#ifdef _MSC_VER
#define uint8_t byte
#define uint8_t uint8
#define uint16_t uint16
#define uint32_t uint32
#define uint64_t uint64

4
src/Crypto/wolfCrypt.c
View File

@ -234,10 +234,10 @@ void sha512(unsigned char * result, const unsigned char* source, uint_64t source
void derive_key_sha512 (char *pwd, int pwd_len, char *salt, int salt_len, uint32 iterations, char *dk, int dklen) {
(void) iterations;
wc_HKDF(WC_SHA512, (byte*)pwd, (word32)pwd_len, (byte*)salt, (word32)salt_len, NULL, 0, (byte*)dk, (word32)dklen);
wc_HKDF(WC_SHA512, (uint8*)pwd, (word32)pwd_len, (uint8*)salt, (word32)salt_len, NULL, 0, (uint8*)dk, (word32)dklen);
}
void derive_key_sha256 (char *pwd, int pwd_len, char *salt, int salt_len, uint32 iterations, char *dk, int dklen) {
(void) iterations;
wc_HKDF(WC_SHA256, (byte*)pwd, (word32)pwd_len, (byte*)salt, (word32)salt_len, NULL, 0, (byte*)dk, (word32)dklen);
wc_HKDF(WC_SHA256, (uint8*)pwd, (word32)pwd_len, (uint8*)salt, (word32)salt_len, NULL, 0, (uint8*)dk, (word32)dklen);
}

64
src/Driver/DriveFilter.c
View File

@ -35,7 +35,7 @@ static BOOL DeviceFilterActive = FALSE;
BOOL BootArgsValid = FALSE;
BootArguments BootArgs;
byte* BootSecRegionData = NULL;
uint8* BootSecRegionData = NULL;
uint32 BootSecRegionSize = 0;
uint32 BootPkcs5 = 0;
@ -47,13 +47,13 @@ static KMUTEX MountMutex;
static volatile BOOL BootDriveFound = FALSE;
static DriveFilterExtension *BootDriveFilterExtension = NULL;
static LARGE_INTEGER BootDriveLength;
static byte BootLoaderFingerprint[WHIRLPOOL_DIGESTSIZE + SHA512_DIGESTSIZE];
static uint8 BootLoaderFingerprint[WHIRLPOOL_DIGESTSIZE + SHA512_DIGESTSIZE];
static BOOL CrashDumpEnabled = FALSE;
static BOOL HibernationEnabled = FALSE;
static BOOL LegacyHibernationDriverFilterActive = FALSE;
static byte *HibernationWriteBuffer = NULL;
static uint8 *HibernationWriteBuffer = NULL;
static MDL *HibernationWriteBufferMdl = NULL;
static uint32 HibernationPreventionCount = 0;
@ -82,8 +82,8 @@ NTSTATUS LoadBootArguments (BOOL bIsEfi)
{
NTSTATUS status = STATUS_UNSUCCESSFUL;
PHYSICAL_ADDRESS bootArgsAddr;
byte *mappedBootArgs;
byte *mappedCryptoInfo = NULL;
uint8 *mappedBootArgs;
uint8 *mappedCryptoInfo = NULL;
uint16 bootLoaderArgsIndex;
uint64* BootArgsRegionsPtr = bIsEfi? BootArgsRegionsEFI : BootArgsRegionsDefault;
size_t BootArgsRegionsCount = bIsEfi? sizeof(BootArgsRegionsEFI)/ sizeof(BootArgsRegionsEFI[0]) : sizeof(BootArgsRegionsDefault)/ sizeof(BootArgsRegionsDefault[0]);
@ -109,7 +109,7 @@ NTSTATUS LoadBootArguments (BOOL bIsEfi)
DumpMem (mappedBootArgs, sizeof (BootArguments));
if (bootArguments->BootLoaderVersion == VERSION_NUM
&& bootArguments->BootArgumentsCrc32 != GetCrc32 ((byte *) bootArguments, (int) ((byte *) &bootArguments->BootArgumentsCrc32 - (byte *) bootArguments)))
&& bootArguments->BootArgumentsCrc32 != GetCrc32 ((uint8 *) bootArguments, (int) ((uint8 *) &bootArguments->BootArgumentsCrc32 - (uint8 *) bootArguments)))
{
Dump ("BootArguments CRC incorrect\n");
burn (mappedBootArgs, sizeof (BootArguments));
@ -166,13 +166,13 @@ NTSTATUS LoadBootArguments (BOOL bIsEfi)
uint32 crc;
PHYSICAL_ADDRESS SecRegionAddress;
SECREGION_BOOT_PARAMS* SecRegionParams = (SECREGION_BOOT_PARAMS*) (mappedCryptoInfo + sizeof(BOOT_CRYPTO_HEADER) + 2);
byte *secRegionData = NULL;
uint8 *secRegionData = NULL;
SecRegionAddress.QuadPart = SecRegionParams->Ptr;
Dump ("SecRegion memory 0x%x %d\n", SecRegionAddress.LowPart, SecRegionParams->Size);
// SecRegion correct?
if( (SecRegionParams->Ptr != 0) && (SecRegionParams->Size > 0)) {
crc = GetCrc32((byte*)SecRegionParams, 12);
crc = GetCrc32((uint8*)SecRegionParams, 12);
if(crc == SecRegionParams->Crc) {
Dump ("SecRegion crc ok\n");
secRegionData = MmMapIoSpace (SecRegionAddress, SecRegionParams->Size, MmCached);
@ -329,7 +329,7 @@ static void InvalidateDriveFilterKeys (DriveFilterExtension *Extension)
Dump ("Drive filter encryption keys invalidated!\n");
}
static void ComputeBootLoaderFingerprint(PDEVICE_OBJECT LowerDeviceObject, byte* ioBuffer /* ioBuffer must be at least 512 bytes long */)
static void ComputeBootLoaderFingerprint(PDEVICE_OBJECT LowerDeviceObject, uint8* ioBuffer /* ioBuffer must be at least 512 bytes long */)
{
NTSTATUS status;
LARGE_INTEGER offset;
@ -433,7 +433,7 @@ static NTSTATUS MountDrive (DriveFilterExtension *Extension, Password *password,
// Check disk MBR id and GPT ID if BootSecRegion is available to detect boot drive
if (BootSecRegionData != NULL && BootSecRegionSize >= 1024) {
byte mbr[TC_SECTOR_SIZE_BIOS];
uint8 mbr[TC_SECTOR_SIZE_BIOS];
DCS_DISK_ENTRY_LIST* DeList = (DCS_DISK_ENTRY_LIST*)(BootSecRegionData + 512);
offset.QuadPart = 0;
status = TCReadDevice (Extension->LowerDeviceObject, mbr, offset, TC_SECTOR_SIZE_BIOS);
@ -459,7 +459,7 @@ static NTSTATUS MountDrive (DriveFilterExtension *Extension, Password *password,
// Check boot drive signature first (header CRC search could fail if a user restored the header to a non-boot drive)
if (BootDriveSignatureValid)
{
byte mbr[TC_SECTOR_SIZE_BIOS];
uint8 mbr[TC_SECTOR_SIZE_BIOS];
offset.QuadPart = 0;
status = TCReadDevice (Extension->LowerDeviceObject, mbr, offset, TC_SECTOR_SIZE_BIOS);
@ -585,7 +585,7 @@ static NTSTATUS MountDrive (DriveFilterExtension *Extension, Password *password,
uint32 crcSaved;
crcSaved = DeList->CRC32;
DeList->CRC32 = 0;
crc = GetCrc32((byte*)DeList, 512);
crc = GetCrc32((uint8*)DeList, 512);
if(crc == crcSaved){
if(DeList->DE[DE_IDX_PWDCACHE].Type == DE_PwdCache) {
uint64 sector = 0;
@ -696,7 +696,7 @@ static NTSTATUS SaveDriveVolumeHeader (DriveFilterExtension *Extension)
{
NTSTATUS status = STATUS_SUCCESS;
LARGE_INTEGER offset;
byte *header;
uint8 *header;
header = TCalloc (TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE);
if (!header)
@ -727,7 +727,7 @@ static NTSTATUS SaveDriveVolumeHeader (DriveFilterExtension *Extension)
{
uint32 headerCrc32;
uint64 encryptedAreaLength = Extension->Queue.EncryptedAreaEnd + 1 - Extension->Queue.EncryptedAreaStart;
byte *fieldPos = header + TC_HEADER_OFFSET_ENCRYPTED_AREA_LENGTH;
uint8 *fieldPos = header + TC_HEADER_OFFSET_ENCRYPTED_AREA_LENGTH;
PCRYPTO_INFO pCryptoInfo = Extension->HeaderCryptoInfo;
#ifdef _WIN64
CRYPTO_INFO tmpCI;
@ -1234,16 +1234,16 @@ typedef NTSTATUS (*HiberDriverWriteFunctionB) (PLARGE_INTEGER writeOffset, PMDL
typedef struct
{
#ifdef _WIN64
byte FieldPad1[64];
uint8 FieldPad1[64];
HiberDriverWriteFunctionB WriteFunctionB;
byte FieldPad2[56];
uint8 FieldPad2[56];
#else
byte FieldPad1[48];
uint8 FieldPad1[48];
HiberDriverWriteFunctionB WriteFunctionB;
byte FieldPad2[32];
uint8 FieldPad2[32];
#endif
HiberDriverWriteFunctionA WriteFunctionA;
byte FieldPad3[24];
uint8 FieldPad3[24];
LARGE_INTEGER PartitionStartOffset;
} HiberDriverContext;
@ -1253,16 +1253,16 @@ typedef struct
{
LIST_ENTRY ModuleList;
#ifdef _WIN64
byte FieldPad1[32];
uint8 FieldPad1[32];
#else
byte FieldPad1[16];
uint8 FieldPad1[16];
#endif
PVOID ModuleBaseAddress;
HiberDriverEntry ModuleEntryAddress;
#ifdef _WIN64
byte FieldPad2[24];
uint8 FieldPad2[24];
#else
byte FieldPad2[12];
uint8 FieldPad2[12];
#endif
UNICODE_STRING ModuleName;
} ModuleTableItem;
@ -1572,10 +1572,10 @@ static VOID SetupThreadProc (PVOID threadArg)
BOOL headerUpdateRequired = FALSE;
int64 bytesWrittenSinceHeaderUpdate = 0;
byte *buffer = NULL;
byte *wipeBuffer = NULL;
byte wipeRandChars[TC_WIPE_RAND_CHAR_COUNT];
byte wipeRandCharsUpdate[TC_WIPE_RAND_CHAR_COUNT];
uint8 *buffer = NULL;
uint8 *wipeBuffer = NULL;
uint8 wipeRandChars[TC_WIPE_RAND_CHAR_COUNT];
uint8 wipeRandCharsUpdate[TC_WIPE_RAND_CHAR_COUNT];
KIRQL irql;
NTSTATUS status;
@ -1583,7 +1583,7 @@ static VOID SetupThreadProc (PVOID threadArg)
// generate real random values for wipeRandChars and
// wipeRandCharsUpdate instead of relying on uninitialized stack memory
ChaCha20RngCtx rngCtx;
byte pbSeed[CHACHA20RNG_KEYSZ + CHACHA20RNG_IVSZ];
uint8 pbSeed[CHACHA20RNG_KEYSZ + CHACHA20RNG_IVSZ];
GetDriverRandomSeed (pbSeed, sizeof (pbSeed));
ChaCha20RngInit (&rngCtx, pbSeed, GetDriverRandomSeed, 0);
@ -1757,7 +1757,7 @@ static VOID SetupThreadProc (PVOID threadArg)
if (SetupRequest.WipeAlgorithm != TC_WIPE_NONE)
{
byte wipePass;
uint8 wipePass;
int wipePassCount = GetWipePassCount (SetupRequest.WipeAlgorithm);
if (wipePassCount <= 0)
{
@ -2193,9 +2193,9 @@ static VOID DecoySystemWipeThreadProc (PVOID threadArg)
ULONG wipeBlockSize = TC_ENCRYPTION_SETUP_IO_BLOCK_SIZE;
CRYPTO_INFO *wipeCryptoInfo = NULL;
byte *wipeBuffer = NULL;
byte *wipeRandBuffer = NULL;
byte wipeRandChars[TC_WIPE_RAND_CHAR_COUNT];
uint8 *wipeBuffer = NULL;
uint8 *wipeRandBuffer = NULL;
uint8 wipeRandChars[TC_WIPE_RAND_CHAR_COUNT];
int wipePass, wipePassCount;
int ea = Extension->Queue.CryptoInfo->ea;

2
src/Driver/DumpFilter.c
View File

@ -18,7 +18,7 @@
static DriveFilterExtension *BootDriveFilterExtension = NULL;
static LARGE_INTEGER DumpPartitionOffset;
static byte *WriteFilterBuffer = NULL;
static uint8 *WriteFilterBuffer = NULL;
static SIZE_T WriteFilterBufferSize;

12
src/Driver/EncryptedIoQueue.c
View File

@ -191,7 +191,7 @@ static NTSTATUS CompleteOriginalIrp (EncryptedIoQueueItem *item, NTSTATUS status
}
static void AcquireFragmentBuffer (EncryptedIoQueue *queue, byte *buffer)
static void AcquireFragmentBuffer (EncryptedIoQueue *queue, uint8 *buffer)
{
NTSTATUS status = STATUS_INVALID_PARAMETER;
@ -209,7 +209,7 @@ static void AcquireFragmentBuffer (EncryptedIoQueue *queue, byte *buffer)
}
static void ReleaseFragmentBuffer (EncryptedIoQueue *queue, byte *buffer)
static void ReleaseFragmentBuffer (EncryptedIoQueue *queue, uint8 *buffer)
{
if (buffer == queue->FragmentBufferA)
{
@ -227,8 +227,8 @@ static void ReleaseFragmentBuffer (EncryptedIoQueue *queue, byte *buffer)
BOOL
UpdateBuffer(
byte* buffer,
byte* secRegion,
uint8* buffer,
uint8* secRegion,
uint64 bufferDiskOffset,
uint32 bufferLength,
BOOL doUpadte
@ -393,7 +393,7 @@ static VOID IoThreadProc (PVOID threadArg)
{
// Up to three subfragments may be required to handle a partially remapped fragment
int subFragment;
byte *subFragmentData = request->Data;
uint8 *subFragmentData = request->Data;
for (subFragment = 0 ; subFragment < 3; ++subFragment)
{
@ -615,7 +615,7 @@ static VOID MainThreadProc (PVOID threadArg)
&& (item->OriginalLength & (ENCRYPTION_DATA_UNIT_SIZE - 1)) == 0
&& (item->OriginalOffset.QuadPart & (ENCRYPTION_DATA_UNIT_SIZE - 1)) != 0)
{
byte *buffer;
uint8 *buffer;
ULONG alignedLength;
LARGE_INTEGER alignedOffset;
hResult = ULongAdd(item->OriginalLength, ENCRYPTION_DATA_UNIT_SIZE, &alignedLength);

12
src/Driver/EncryptedIoQueue.h
View File

@ -83,8 +83,8 @@ typedef struct
KEVENT CompletionThreadQueueNotEmptyEvent;
// Fragment buffers
byte *FragmentBufferA;
byte *FragmentBufferB;
uint8 *FragmentBufferA;
uint8 *FragmentBufferB;
KEVENT FragmentBufferAFreeEvent;
KEVENT FragmentBufferBFreeEvent;
@ -94,7 +94,7 @@ typedef struct
ULONG LastReadLength;
LARGE_INTEGER ReadAheadOffset;
ULONG ReadAheadLength;
byte *ReadAheadBuffer;
uint8 *ReadAheadBuffer;
LARGE_INTEGER MaxReadAheadOffset;
LONG OutstandingIoCount;
@ -119,7 +119,7 @@ typedef struct
LARGE_INTEGER LastPerformanceCounter;
#endif
byte* SecRegionData;
uint8* SecRegionData;
SIZE_T SecRegionSize;
volatile BOOL ThreadBlockReadWrite;
@ -153,8 +153,8 @@ typedef struct
ULONG Length;
int64 EncryptedOffset;
ULONG EncryptedLength;
byte *Data;
byte *OrigDataBufferFragment;
uint8 *Data;
uint8 *OrigDataBufferFragment;
LIST_ENTRY ListEntry;
LIST_ENTRY CompletionListEntry;

12
src/Driver/Fuse/FuseService.cpp
View File

@ -223,11 +223,11 @@ namespace VeraCrypt
SecureBuffer alignedBuffer (alignedSize);
FuseService::ReadVolumeSectors (alignedBuffer, alignedOffset);
BufferPtr ((byte *) buf, size).CopyFrom (alignedBuffer.GetRange (offset % sectorSize, size));
BufferPtr ((uint8 *) buf, size).CopyFrom (alignedBuffer.GetRange (offset % sectorSize, size));
}
else
{
FuseService::ReadVolumeSectors (BufferPtr ((byte *) buf, size), offset);
FuseService::ReadVolumeSectors (BufferPtr ((uint8 *) buf, size), offset);
}
}
catch (MissingVolumeData&)
@ -241,7 +241,7 @@ namespace VeraCrypt
if (strcmp (path, FuseService::GetControlPath()) == 0)
{
shared_ptr <Buffer> infoBuf = FuseService::GetVolumeInfo();
BufferPtr outBuf ((byte *)buf, size);
BufferPtr outBuf ((uint8 *)buf, size);
if (offset >= (off_t) infoBuf->Size())
return 0;
@ -293,7 +293,7 @@ namespace VeraCrypt
if (strcmp (path, FuseService::GetVolumeImagePath()) == 0)
{
FuseService::WriteVolumeSectors (BufferPtr ((byte *) buf, size), offset);
FuseService::WriteVolumeSectors (BufferPtr ((uint8 *) buf, size), offset);
return size;
}
@ -302,7 +302,7 @@ namespace VeraCrypt
if (FuseService::AuxDeviceInfoReceived())
return -EACCES;
FuseService::ReceiveAuxDeviceInfo (ConstBufferPtr ((const byte *)buf, size));
FuseService::ReceiveAuxDeviceInfo (ConstBufferPtr ((const uint8 *)buf, size));
return size;
}
}
@ -584,7 +584,7 @@ namespace VeraCrypt
sigaction (SIGTERM, &action, nullptr);
// Wait for the exit of the main service
byte buf[1];
uint8 buf[1];
if (read (SignalHandlerPipe->GetReadFD(), buf, sizeof (buf))) { } // Errors ignored
_exit (0);

12
src/Driver/Ntdriver.c
View File

@ -216,7 +216,7 @@ BOOL IsUefiBoot ()
void GetDriverRandomSeed (unsigned char* pbRandSeed, size_t cbRandSeed)
{
LARGE_INTEGER iSeed, iSeed2;
byte digest[WHIRLPOOL_DIGESTSIZE];
uint8 digest[WHIRLPOOL_DIGESTSIZE];
WHIRLPOOL_CTX tctx;
size_t count;
@ -2070,7 +2070,7 @@ NTSTATUS ProcessMainDeviceControlIrp (PDEVICE_OBJECT DeviceObject, PEXTENSION Ex
if (opentest->bDetectTCBootLoader || opentest->DetectFilesystem || opentest->bComputeVolumeIDs)
{
byte *readBuffer = TCalloc (TC_MAX_VOLUME_SECTOR_SIZE);
uint8 *readBuffer = TCalloc (TC_MAX_VOLUME_SECTOR_SIZE);
if (!readBuffer)
{
ntStatus = STATUS_INSUFFICIENT_RESOURCES;
@ -2233,7 +2233,7 @@ NTSTATUS ProcessMainDeviceControlIrp (PDEVICE_OBJECT DeviceObject, PEXTENSION Ex
if (NT_SUCCESS (ntStatus))
{
byte *readBuffer = TCalloc (TC_MAX_VOLUME_SECTOR_SIZE);
uint8 *readBuffer = TCalloc (TC_MAX_VOLUME_SECTOR_SIZE);
if (!readBuffer)
{
Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
@ -3717,7 +3717,7 @@ NTSTATUS ProbeRealDriveSize (PDEVICE_OBJECT driveDeviceObject, LARGE_INTEGER *dr
NTSTATUS status;
LARGE_INTEGER sysLength;
LARGE_INTEGER offset;
byte *sectorBuffer;
uint8 *sectorBuffer;
ULONGLONG startTime;
ULONG sectorSize;
@ -4919,7 +4919,7 @@ NTSTATUS ZeroUnreadableSectors (PDEVICE_OBJECT deviceObject, LARGE_INTEGER start
NTSTATUS status;
ULONG sectorSize;
ULONG sectorCount;
byte *sectorBuffer = NULL;
uint8 *sectorBuffer = NULL;
*zeroedSectorCount = 0;
@ -4957,7 +4957,7 @@ NTSTATUS ZeroUnreadableSectors (PDEVICE_OBJECT deviceObject, LARGE_INTEGER start
}
NTSTATUS ReadDeviceSkipUnreadableSectors (PDEVICE_OBJECT deviceObject, byte *buffer, LARGE_INTEGER startOffset, ULONG size, uint64 *badSectorCount)
NTSTATUS ReadDeviceSkipUnreadableSectors (PDEVICE_OBJECT deviceObject, uint8 *buffer, LARGE_INTEGER startOffset, ULONG size, uint64 *badSectorCount)
{
NTSTATUS status;
ULONG sectorSize;

2
src/Driver/Ntdriver.h
View File

@ -191,7 +191,7 @@ NTSTATUS WriteRegistryConfigFlags (uint32 flags);
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);
NTSTATUS ReadDeviceSkipUnreadableSectors (PDEVICE_OBJECT deviceObject, byte *buffer, LARGE_INTEGER startOffset, ULONG size, uint64 *badSectorCount);
NTSTATUS ReadDeviceSkipUnreadableSectors (PDEVICE_OBJECT deviceObject, uint8 *buffer, LARGE_INTEGER startOffset, ULONG size, uint64 *badSectorCount);
BOOL IsVolumeAccessibleByCurrentUser (PEXTENSION volumeDeviceExtension);
void GetElapsedTimeInit (LARGE_INTEGER *lastPerfCounter);
int64 GetElapsedTime (LARGE_INTEGER *lastPerfCounter);

2
src/Driver/Ntvol.c
View File

@ -98,7 +98,7 @@ NTSTATUS TCOpenVolume (PDEVICE_OBJECT DeviceObject,
LARGE_INTEGER diskLengthInfo;
DISK_GEOMETRY_EX dg;
STORAGE_PROPERTY_QUERY storagePropertyQuery = {0};
byte* dgBuffer;
uint8* dgBuffer;
STORAGE_DEVICE_NUMBER storageDeviceNumber;
ntStatus = IoGetDeviceObjectPointer (&FullFileName,

10
src/ExpandVolume/ExpandVolume.c
View File

@ -518,7 +518,7 @@ static int ExpandVolume (HWND hwndDlg, wchar_t *lpszVolume, Password *pVolumePas
BOOL bTimeStampValid = FALSE;
LARGE_INTEGER headerOffset;
BOOL backupHeader;
byte *wipeBuffer = NULL;
uint8 *wipeBuffer = NULL;
uint32 workChunkSize = TC_VOLUME_HEADER_GROUP_SIZE;
#ifdef _WIN64
CRYPTO_INFO tmpCI;
@ -1023,9 +1023,9 @@ static int ExpandVolume (HWND hwndDlg, wchar_t *lpszVolume, Password *pVolumePas
/* wipe old backup header */
if ( !cryptoInfo->LegacyVolume )
{
byte wipeRandChars [TC_WIPE_RAND_CHAR_COUNT];
byte wipeRandCharsUpdate [TC_WIPE_RAND_CHAR_COUNT];
byte wipePass;
uint8 wipeRandChars [TC_WIPE_RAND_CHAR_COUNT];
uint8 wipeRandCharsUpdate [TC_WIPE_RAND_CHAR_COUNT];
uint8 wipePass;
UINT64_STRUCT unitNo;
LARGE_INTEGER offset;
WipeAlgorithmId wipeAlgorithm = TC_WIPE_35_GUTMANN;
@ -1040,7 +1040,7 @@ static int ExpandVolume (HWND hwndDlg, wchar_t *lpszVolume, Password *pVolumePas
DebugAddProgressDlgStatus(hwndDlg, GetString("EXPANDER_WIPING_OLD_HEADER"));
wipeBuffer = (byte *) TCalloc (workChunkSize);
wipeBuffer = (uint8 *) TCalloc (workChunkSize);
if (!wipeBuffer)
{
nStatus = ERR_OUTOFMEMORY;

2
src/ExpandVolume/InitDataArea.c
View File

@ -216,7 +216,7 @@ static volatile BOOL WriteThreadRunning;
static volatile BOOL WriteThreadExitRequested;
static HANDLE WriteThreadHandle;
static byte *WriteThreadBuffer;
static uint8 *WriteThreadBuffer;
static HANDLE WriteBufferEmptyEvent;
static HANDLE WriteBufferFullEvent;

50
src/Format/InPlace.c
View File

@ -600,7 +600,7 @@ int EncryptPartitionInPlaceBegin (volatile FORMAT_VOL_PARAMETERS *volParams, vol
}
// Write the backup header to the partition
if (!WriteEffectiveVolumeHeader (TRUE, dev, (byte *) header))
if (!WriteEffectiveVolumeHeader (TRUE, dev, (uint8 *) header))
{
nStatus = ERR_OS_ERROR;
goto closing_seq;
@ -646,7 +646,7 @@ int EncryptPartitionInPlaceBegin (volatile FORMAT_VOL_PARAMETERS *volParams, vol
}
// Write the fake hidden backup header to the partition
if (!WriteEffectiveVolumeHeader (TRUE, dev, (byte *) header))
if (!WriteEffectiveVolumeHeader (TRUE, dev, (uint8 *) header))
{
nStatus = ERR_OS_ERROR;
goto closing_seq;
@ -754,9 +754,9 @@ int EncryptPartitionInPlaceResume (HANDLE dev,
PCRYPTO_INFO masterCryptoInfo = NULL, headerCryptoInfo = NULL, tmpCryptoInfo = NULL;
UINT64_STRUCT unitNo;
char *buf = NULL, *header = NULL;
byte *wipeBuffer = NULL;
byte wipeRandChars [TC_WIPE_RAND_CHAR_COUNT];
byte wipeRandCharsUpdate [TC_WIPE_RAND_CHAR_COUNT];
uint8 *wipeBuffer = NULL;
uint8 wipeRandChars [TC_WIPE_RAND_CHAR_COUNT];
uint8 wipeRandCharsUpdate [TC_WIPE_RAND_CHAR_COUNT];
WCHAR dosDev[TC_MAX_PATH] = {0};
WCHAR devName[MAX_PATH] = {0};
WCHAR deviceName[MAX_PATH];
@ -801,7 +801,7 @@ int EncryptPartitionInPlaceResume (HANDLE dev,
if (wipeAlgorithm != TC_WIPE_NONE)
{
wipeBuffer = (byte *) TCalloc (TC_MAX_NONSYS_INPLACE_ENC_WORK_CHUNK_SIZE);
wipeBuffer = (uint8 *) TCalloc (TC_MAX_NONSYS_INPLACE_ENC_WORK_CHUNK_SIZE);
if (!wipeBuffer)
{
nStatus = ERR_OUTOFMEMORY;
@ -974,14 +974,14 @@ int EncryptPartitionInPlaceResume (HANDLE dev,
// Encrypt the plaintext in RAM
EncryptDataUnits ((byte *) buf, &unitNo, workChunkSize / ENCRYPTION_DATA_UNIT_SIZE, masterCryptoInfo);
EncryptDataUnits ((uint8 *) buf, &unitNo, workChunkSize / ENCRYPTION_DATA_UNIT_SIZE, masterCryptoInfo);
// If enabled, wipe the area to which we will write the ciphertext
if (wipeAlgorithm != TC_WIPE_NONE)
{
byte wipePass;
uint8 wipePass;
int wipePassCount = GetWipePassCount (wipeAlgorithm);
if (wipePassCount <= 0)
@ -1016,7 +1016,7 @@ int EncryptPartitionInPlaceResume (HANDLE dev,
// Undo failed write operation
if (workChunkSize > TC_VOLUME_DATA_OFFSET && MoveFilePointer (dev, offset))
{
DecryptDataUnits ((byte *) buf, &unitNo, workChunkSize / ENCRYPTION_DATA_UNIT_SIZE, masterCryptoInfo);
DecryptDataUnits ((uint8 *) buf, &unitNo, workChunkSize / ENCRYPTION_DATA_UNIT_SIZE, masterCryptoInfo);
WriteFile (dev, buf + TC_VOLUME_DATA_OFFSET, workChunkSize - TC_VOLUME_DATA_OFFSET, &n, NULL);
}
@ -1048,7 +1048,7 @@ int EncryptPartitionInPlaceResume (HANDLE dev,
// Undo failed write operation
if (workChunkSize > TC_VOLUME_DATA_OFFSET && MoveFilePointer (dev, offset))
{
DecryptDataUnits ((byte *) buf, &unitNo, workChunkSize / ENCRYPTION_DATA_UNIT_SIZE, masterCryptoInfo);
DecryptDataUnits ((uint8 *) buf, &unitNo, workChunkSize / ENCRYPTION_DATA_UNIT_SIZE, masterCryptoInfo);
WriteFile (dev, buf + TC_VOLUME_DATA_OFFSET, workChunkSize - TC_VOLUME_DATA_OFFSET, &n, NULL);
}
@ -1149,7 +1149,7 @@ int EncryptPartitionInPlaceResume (HANDLE dev,
offset.QuadPart = TC_VOLUME_HEADER_OFFSET;
if (MoveFilePointer (dev, offset) == 0
|| !WriteEffectiveVolumeHeader (TRUE, dev, (byte *) header))
|| !WriteEffectiveVolumeHeader (TRUE, dev, (uint8 *) header))
{
nStatus = ERR_OS_ERROR;
goto closing_seq;
@ -1208,7 +1208,7 @@ int EncryptPartitionInPlaceResume (HANDLE dev,
offset.QuadPart += TC_HIDDEN_VOLUME_HEADER_OFFSET;
if (MoveFilePointer (dev, offset) == 0
|| !WriteEffectiveVolumeHeader (TRUE, dev, (byte *) header))
|| !WriteEffectiveVolumeHeader (TRUE, dev, (uint8 *) header))
{
nStatus = ERR_OS_ERROR;
goto closing_seq;
@ -1316,7 +1316,7 @@ int DecryptPartitionInPlace (volatile FORMAT_VOL_PARAMETERS *volParams, volatile
PCRYPTO_INFO masterCryptoInfo = NULL, headerCryptoInfo = NULL;
UINT64_STRUCT unitNo;
char *buf = NULL;
byte *tmpSectorBuf = NULL;
uint8 *tmpSectorBuf = NULL;
WCHAR dosDev[TC_MAX_PATH] = {0};
WCHAR devName[MAX_PATH] = {0};
WCHAR deviceName[MAX_PATH];
@ -1432,7 +1432,7 @@ int DecryptPartitionInPlace (volatile FORMAT_VOL_PARAMETERS *volParams, volatile
sectorSize = driveGeometry.BytesPerSector;
tmpSectorBuf = (byte *) TCalloc (sectorSize);
tmpSectorBuf = (uint8 *) TCalloc (sectorSize);
if (!tmpSectorBuf)
{
nStatus = ERR_OUTOFMEMORY;
@ -1620,7 +1620,7 @@ int DecryptPartitionInPlace (volatile FORMAT_VOL_PARAMETERS *volParams, volatile
// Decrypt the ciphertext in RAM
DecryptDataUnits ((byte *) buf, &unitNo, workChunkSize / ENCRYPTION_DATA_UNIT_SIZE, masterCryptoInfo);
DecryptDataUnits ((uint8 *) buf, &unitNo, workChunkSize / ENCRYPTION_DATA_UNIT_SIZE, masterCryptoInfo);
@ -1843,16 +1843,16 @@ int FastVolumeHeaderUpdate (HANDLE dev, CRYPTO_INFO *headerCryptoInfo, CRYPTO_IN
LARGE_INTEGER offset;
DWORD n;
int nStatus = ERR_SUCCESS;
byte *header;
uint8 *header;
DWORD dwError;
uint32 headerCrc32;
byte *fieldPos;
uint8 *fieldPos;
PCRYPTO_INFO pCryptoInfo = headerCryptoInfo;
#ifdef _WIN64
BOOL bIsRamEncryptionEnabled = IsRamEncryptionEnabled();
#endif
header = (byte *) TCalloc (TC_VOLUME_HEADER_EFFECTIVE_SIZE);
header = (uint8 *) TCalloc (TC_VOLUME_HEADER_EFFECTIVE_SIZE);
if (!header)
return ERR_OUTOFMEMORY;
@ -1860,7 +1860,7 @@ int FastVolumeHeaderUpdate (HANDLE dev, CRYPTO_INFO *headerCryptoInfo, CRYPTO_IN
VirtualLock (header, TC_VOLUME_HEADER_EFFECTIVE_SIZE);
fieldPos = (byte *) header + TC_HEADER_OFFSET_ENCRYPTED_AREA_START;
fieldPos = (uint8 *) header + TC_HEADER_OFFSET_ENCRYPTED_AREA_START;
offset.QuadPart = deviceSize - TC_VOLUME_HEADER_GROUP_SIZE;
@ -1902,12 +1902,12 @@ int FastVolumeHeaderUpdate (HANDLE dev, CRYPTO_INFO *headerCryptoInfo, CRYPTO_IN
// 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;
fieldPos = (byte *) header + TC_HEADER_OFFSET_FLAGS;
fieldPos = (uint8 *) header + TC_HEADER_OFFSET_FLAGS;
mputLong (fieldPos, (masterCryptoInfo->HeaderFlags));
headerCrc32 = GetCrc32 (header + TC_HEADER_OFFSET_MAGIC, TC_HEADER_OFFSET_HEADER_CRC - TC_HEADER_OFFSET_MAGIC);
fieldPos = (byte *) header + TC_HEADER_OFFSET_HEADER_CRC;
fieldPos = (uint8 *) header + TC_HEADER_OFFSET_HEADER_CRC;
mputLong (fieldPos, headerCrc32);
EncryptBuffer (header + HEADER_ENCRYPTED_DATA_OFFSET, HEADER_ENCRYPTED_DATA_SIZE, pCryptoInfo);
@ -2239,12 +2239,12 @@ int ZeroUnreadableSectors (HANDLE dev, LARGE_INTEGER startOffset, int64 size, in
DWORD n;
int64 sectorCount;
LARGE_INTEGER workOffset;
byte *sectorBuffer = NULL;
uint8 *sectorBuffer = NULL;
DWORD dwError;
workOffset.QuadPart = startOffset.QuadPart;
sectorBuffer = (byte *) TCalloc (sectorSize);
sectorBuffer = (uint8 *) TCalloc (sectorSize);
if (!sectorBuffer)
return ERR_OUTOFMEMORY;
@ -2315,7 +2315,7 @@ static int OpenBackupHeader (HANDLE dev, const wchar_t *devicePath, Password *pa
offset.QuadPart = deviceSize - TC_VOLUME_HEADER_GROUP_SIZE;
if (MoveFilePointer (dev, offset) == 0
|| !ReadEffectiveVolumeHeader (TRUE, dev, (byte *) header, &n) || n < TC_VOLUME_HEADER_EFFECTIVE_SIZE)
|| !ReadEffectiveVolumeHeader (TRUE, dev, (uint8 *) header, &n) || n < TC_VOLUME_HEADER_EFFECTIVE_SIZE)
{
nStatus = ERR_OS_ERROR;
goto closing_seq;
@ -2347,7 +2347,7 @@ static int OpenBackupHeader (HANDLE dev, const wchar_t *devicePath, Password *pa
static BOOL GetFreeClusterBeforeThreshold (HANDLE volumeHandle, int64 *freeCluster, int64 clusterThreshold)
{
const int bitmapSize = 65536;
byte bitmapBuffer[bitmapSize + sizeof (VOLUME_BITMAP_BUFFER)];
uint8 bitmapBuffer[bitmapSize + sizeof (VOLUME_BITMAP_BUFFER)];
VOLUME_BITMAP_BUFFER *bitmap = (VOLUME_BITMAP_BUFFER *) bitmapBuffer;
STARTING_LCN_INPUT_BUFFER startLcn;
startLcn.StartingLcn.QuadPart = 0;

4
src/Main/CommandLineInterface.cpp
View File

@ -834,7 +834,7 @@ namespace VeraCrypt
if (wxCONV_FAILED == ulen)
throw PasswordUTF8Invalid (SRC_POS);
SecureBuffer passwordBuf(ulen);
ulen = utf8.FromWChar ((char*) (byte*) passwordBuf, ulen, str, charCount);
ulen = utf8.FromWChar ((char*) (uint8*) passwordBuf, ulen, str, charCount);
if (wxCONV_FAILED == ulen)
throw PasswordUTF8Invalid (SRC_POS);
if (ulen > maxUtf8Len)
@ -845,7 +845,7 @@ namespace VeraCrypt
throw PasswordUTF8TooLong (SRC_POS);
}
ConstBufferPtr utf8Buffer ((byte*) passwordBuf, ulen);
ConstBufferPtr utf8Buffer ((uint8*) passwordBuf, ulen);
return shared_ptr<SecureBuffer>(new SecureBuffer (utf8Buffer));
}
else

2
src/Main/Forms/BenchmarkDialog.cpp
View File

@ -281,7 +281,7 @@ namespace VeraCrypt
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 ();
VolumePassword password ((const byte*) "passphrase-1234567890", 21);
VolumePassword password ((const uint8*) "passphrase-1234567890", 21);
memcpy (&pim, buffer.Ptr (), sizeof (unsigned long));
memcpy (salt.Ptr(), tmp_salt, 64);

4
src/Main/Forms/EncryptionTestDialog.cpp
View File

@ -141,7 +141,7 @@ namespace VeraCrypt
void EncryptionTestDialog::GetTextCtrlData (wxTextCtrl *textCtrl, Buffer &buffer) const
{
vector <byte> data;
vector <uint8> data;
string dataStr = StringConverter::ToSingle (wstring (textCtrl->GetValue()));
for (size_t i = 0; i < dataStr.size() / 2; ++i)
@ -153,7 +153,7 @@ namespace VeraCrypt
throw StringConversionFailed (SRC_POS);
}
data.push_back ((byte) dataByte);
data.push_back ((uint8) dataByte);
}
if (data.empty())

6
src/Main/Forms/KeyfileGeneratorDialog.cpp
View File

@ -164,12 +164,12 @@ namespace VeraCrypt
{
event.Skip();
RandomNumberGenerator::AddToPool (ConstBufferPtr (reinterpret_cast <byte *> (&event), sizeof (event)));
RandomNumberGenerator::AddToPool (ConstBufferPtr (reinterpret_cast <uint8 *> (&event), sizeof (event)));
long coord = event.GetX();
RandomNumberGenerator::AddToPool (ConstBufferPtr (reinterpret_cast <byte *> (&coord), sizeof (coord)));
RandomNumberGenerator::AddToPool (ConstBufferPtr (reinterpret_cast <uint8 *> (&coord), sizeof (coord)));
coord = event.GetY();
RandomNumberGenerator::AddToPool (ConstBufferPtr (reinterpret_cast <byte *> (&coord), sizeof (coord)));
RandomNumberGenerator::AddToPool (ConstBufferPtr (reinterpret_cast <uint8 *> (&coord), sizeof (coord)));
if (ShowRandomPoolCheckBox->IsChecked())
ShowBytes (RandomPoolStaticText, RandomNumberGenerator::PeekPool().GetRange (0, 24));

2
src/Main/Forms/MainFrame.cpp
View File

@ -1437,7 +1437,7 @@ namespace VeraCrypt
#if defined(TC_UNIX) && !defined(TC_MACOSX)
try
{
byte buf[128];
uint8 buf[128];
if (read (ShowRequestFifo, buf, sizeof (buf)) > 0 && Gui->IsInBackgroundMode())
Gui->SetBackgroundMode (false);
}

6
src/Main/Forms/RandomPoolEnrichmentDialog.cpp
View File

@ -63,12 +63,12 @@ namespace VeraCrypt
{
event.Skip();
RandomNumberGenerator::AddToPool (ConstBufferPtr (reinterpret_cast <byte *> (&event), sizeof (event)));
RandomNumberGenerator::AddToPool (ConstBufferPtr (reinterpret_cast <uint8 *> (&event), sizeof (event)));
long coord = event.GetX();
RandomNumberGenerator::AddToPool (ConstBufferPtr (reinterpret_cast <byte *> (&coord), sizeof (coord)));
RandomNumberGenerator::AddToPool (ConstBufferPtr (reinterpret_cast <uint8 *> (&coord), sizeof (coord)));
coord = event.GetY();
RandomNumberGenerator::AddToPool (ConstBufferPtr (reinterpret_cast <byte *> (&coord), sizeof (coord)));
RandomNumberGenerator::AddToPool (ConstBufferPtr (reinterpret_cast <uint8 *> (&coord), sizeof (coord)));
if (ShowRandomPoolCheckBox->IsChecked())
ShowBytes (RandomPoolStaticText, RandomNumberGenerator::PeekPool().GetRange (0, 24));

4
src/Main/Forms/SecurityTokenKeyfilesDialog.cpp
View File

@ -103,7 +103,7 @@ namespace VeraCrypt
{
wxBusyCursor busy;
vector <byte> keyfileData;
vector <uint8> keyfileData;
keyfile->GetKeyfileData (keyfileData);
BufferPtr keyfileDataBuf (&keyfileData.front(), keyfileData.size());
@ -141,7 +141,7 @@ namespace VeraCrypt
if (keyfile.Length() > 0)
{
vector <byte> keyfileData (keyfile.Length());
vector <uint8> keyfileData (keyfile.Length());
BufferPtr keyfileDataBuf (&keyfileData.front(), keyfileData.size());
keyfile.ReadCompleteBuffer (keyfileDataBuf);

8
src/Main/Forms/VolumeCreationWizard.cpp
View File

@ -390,12 +390,12 @@ namespace VeraCrypt
event.Skip();
if (!IsWorkInProgress() && RandomNumberGenerator::IsRunning())
{
RandomNumberGenerator::AddToPool (ConstBufferPtr (reinterpret_cast <byte *> (&event), sizeof (event)));
RandomNumberGenerator::AddToPool (ConstBufferPtr (reinterpret_cast <uint8 *> (&event), sizeof (event)));
long coord = event.GetX();
RandomNumberGenerator::AddToPool (ConstBufferPtr (reinterpret_cast <byte *> (&coord), sizeof (coord)));
RandomNumberGenerator::AddToPool (ConstBufferPtr (reinterpret_cast <uint8 *> (&coord), sizeof (coord)));
coord = event.GetY();
RandomNumberGenerator::AddToPool (ConstBufferPtr (reinterpret_cast <byte *> (&coord), sizeof (coord)));
RandomNumberGenerator::AddToPool (ConstBufferPtr (reinterpret_cast <uint8 *> (&coord), sizeof (coord)));
VolumeCreationProgressWizardPage *page = dynamic_cast <VolumeCreationProgressWizardPage *> (GetCurrentPage());
if (page)
@ -442,7 +442,7 @@ namespace VeraCrypt
if (!IsWorkInProgress())
{
wxLongLong time = wxGetLocalTimeMillis();
RandomNumberGenerator::AddToPool (ConstBufferPtr (reinterpret_cast <byte *> (&time), sizeof (time)));
RandomNumberGenerator::AddToPool (ConstBufferPtr (reinterpret_cast <uint8 *> (&time), sizeof (time)));
}
}

2
src/Main/Forms/VolumePasswordPanel.cpp
View File

@ -214,7 +214,7 @@ namespace VeraCrypt
shared_ptr <VolumePassword> password;
wchar_t passwordBuf[VolumePassword::MaxSize + 1];
size_t maxPasswordLength = (bLegacyPassword || CmdLine->ArgUseLegacyPassword)? VolumePassword::MaxLegacySize: VolumePassword::MaxSize;
finally_do_arg (BufferPtr, BufferPtr (reinterpret_cast <byte *> (passwordBuf), sizeof (passwordBuf)), { finally_arg.Erase(); });
finally_do_arg (BufferPtr, BufferPtr (reinterpret_cast <uint8 *> (passwordBuf), sizeof (passwordBuf)), { finally_arg.Erase(); });
#ifdef TC_WINDOWS
int len = GetWindowText (static_cast <HWND> (textCtrl->GetHandle()), passwordBuf, VolumePassword::MaxSize + 1);

2
src/Main/GraphicUserInterface.cpp
View File

@ -992,7 +992,7 @@ namespace VeraCrypt
int showFifo = open (string (MainFrame::GetShowRequestFifoPath()).c_str(), O_WRONLY | O_NONBLOCK);
throw_sys_if (showFifo == -1);
byte buf[1] = { 1 };
uint8 buf[1] = { 1 };
if (write (showFifo, buf, 1) == 1)
{
close (showFifo);

2
src/Main/LanguageStrings.cpp
View File

@ -43,7 +43,7 @@ namespace VeraCrypt
void LanguageStrings::Init ()
{
static byte LanguageXml[] =
static uint8 LanguageXml[] =
{
# include "Common/Language.xml.h"
, 0

18
src/Main/Resources.cpp
View File

@ -40,7 +40,7 @@ namespace VeraCrypt
hResL = LoadResource (NULL, hRes);
throw_sys_if (!hResL);
const byte *resPtr = (const byte *) LockResource (hResL);
const uint8 *resPtr = (const uint8 *) LockResource (hResL);
throw_sys_if (!resPtr);
return ConstBufferPtr (resPtr, SizeofResource (NULL, hRes));
@ -132,14 +132,14 @@ namespace VeraCrypt
if ( xml.IsFile() ){
File file;
file.Open (xml, File::OpenRead, File::ShareRead);
vector <byte> keyfileData (file.Length());
vector <uint8> keyfileData (file.Length());
BufferPtr keyfileDataBuf (&keyfileData.front(), keyfileData.size());
file.ReadCompleteBuffer (keyfileDataBuf);
file.Close();
string langxml(keyfileData.begin(), keyfileData.end());
return langxml;
}
static byte LanguageXml[] =
static uint8 LanguageXml[] =
{
# include "Common/Language.xml.h"
, 0
@ -158,7 +158,7 @@ namespace VeraCrypt
strBuf.CopyFrom (res);
return string (reinterpret_cast <char *> (strBuf.Ptr()));
#else
static byte License[] =
static uint8 License[] =
{
# include "License.txt.h"
, 0
@ -176,7 +176,7 @@ namespace VeraCrypt
#ifdef TC_WINDOWS
return wxBitmap (L"IDB_DRIVE_ICON", wxBITMAP_TYPE_BMP_RESOURCE).ConvertToImage().Resize (wxSize (16, 12), wxPoint (0, 0));
#else
static const byte DriveIcon[] =
static const uint8 DriveIcon[] =
{
# include "Mount/Drive_icon_96dpi.bmp.h"
};
@ -192,7 +192,7 @@ namespace VeraCrypt
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
static const byte DriveIconMask[] =
static const uint8 DriveIconMask[] =
{
# include "Mount/Drive_icon_mask_96dpi.bmp.h"
};
@ -215,7 +215,7 @@ namespace VeraCrypt
#ifdef TC_WINDOWS
return wxBitmap (L"IDB_LOGO", wxBITMAP_TYPE_BMP_RESOURCE);
#else
static const byte Logo[] =
static const uint8 Logo[] =
{
# include "Mount/Logo_96dpi.bmp.h"
};
@ -230,7 +230,7 @@ namespace VeraCrypt
#ifdef TC_WINDOWS
return wxBitmap (L"IDB_TEXTUAL_LOGO", wxBITMAP_TYPE_BMP_RESOURCE);
#else
static const byte Logo[] =
static const uint8 Logo[] =
{
# include "Common/Textual_logo_96dpi.bmp.h"
};
@ -255,7 +255,7 @@ namespace VeraCrypt
#ifdef TC_WINDOWS
return wxBitmap (L"IDB_VOLUME_WIZARD_BITMAP", wxBITMAP_TYPE_BMP_RESOURCE);
#else
static const byte VolumeWizardIcon[] =
static const uint8 VolumeWizardIcon[] =
{
# include "Format/VeraCrypt_Wizard.bmp.h"
};

8
src/Main/TextUserInterface.cpp
View File

@ -100,7 +100,7 @@ namespace VeraCrypt
finally_do ({ TextUserInterface::SetTerminalEcho (true); });
wchar_t passwordBuf[4096];
finally_do_arg (BufferPtr, BufferPtr (reinterpret_cast <byte *> (passwordBuf), sizeof (passwordBuf)), { finally_arg.Erase(); });
finally_do_arg (BufferPtr, BufferPtr (reinterpret_cast <uint8 *> (passwordBuf), sizeof (passwordBuf)), { finally_arg.Erase(); });
shared_ptr<VolumePassword> password;
@ -1077,7 +1077,7 @@ namespace VeraCrypt
shared_ptr<TokenKeyfile> tokenKeyfile = Token::getTokenKeyfile(keyfilePath);
vector <byte> keyfileData;
vector <uint8> keyfileData;
tokenKeyfile->GetKeyfileData (keyfileData);
BufferPtr keyfileDataBuf (&keyfileData.front(), keyfileData.size());
@ -1164,7 +1164,7 @@ namespace VeraCrypt
if (keyfile.Length() > 0)
{
vector <byte> keyfileData (keyfile.Length());
vector <uint8> keyfileData (keyfile.Length());
BufferPtr keyfileDataBuf (&keyfileData.front(), keyfileData.size());
keyfile.ReadCompleteBuffer (keyfileDataBuf);
@ -1784,7 +1784,7 @@ namespace VeraCrypt
while (randCharsRequired > 0)
{
wstring randStr = AskString();
RandomNumberGenerator::AddToPool (ConstBufferPtr ((byte *) randStr.c_str(), randStr.size() * sizeof (wchar_t)));
RandomNumberGenerator::AddToPool (ConstBufferPtr ((uint8 *) randStr.c_str(), randStr.size() * sizeof (wchar_t)));
randCharsRequired -= randStr.size();

2
src/Main/Xml.cpp
View File

@ -108,7 +108,7 @@ namespace VeraCrypt
*TextOutStream << L"</VeraCrypt>" << endl;
wxStreamBuffer *buf = MemOutStream->GetOutputStreamBuffer();
OutFile.Write (ConstBufferPtr (reinterpret_cast <byte *> (buf->GetBufferStart()), buf->GetBufferSize()));
OutFile.Write (ConstBufferPtr (reinterpret_cast <uint8 *> (buf->GetBufferStart()), buf->GetBufferSize()));
OutFile.Close();
TextOutStream.reset();

2
src/Mount/Favorites.cpp
View File

@ -617,7 +617,7 @@ namespace VeraCrypt
XmlGetAttributeText (xml, "ID", label, sizeof (label));
if (strlen (label) == (2*VOLUME_ID_SIZE))
{
std::vector<byte> arr;
std::vector<uint8> arr;
if (HexWideStringToArray (Utf8StringToWide (label).c_str(), arr) && arr.size() == VOLUME_ID_SIZE)
{
memcpy (favorite.VolumeID, &arr[0], VOLUME_ID_SIZE);

Some files were not shown because too many files have changed in this diff Show More