+#ifdef TC_WINDOWS_DRIVER

+#include <ntstrsafe.h>

+#define StringCchCatW RtlStringCchCatW

+#define StringCchCopyW RtlStringCchCopyW

+#else

+#include <strsafe.h>

+#endif

+#ifndef WOLFCRYPT_BACKEND

+ { SERPENT, "Serpent", 16, 32, 140*4 },

+#endif

+#ifndef WOLFCRYPT_BACKEND

+#endif

+#ifndef WOLFCRYPT_BACKEND

+ { { KUZNYECHIK, CAMELLIA, 0 }, { XTS, 0 }, 0, 1 },

+ { { TWOFISH, KUZNYECHIK, 0 }, { XTS, 0 }, 0, 1 },

+ { { SERPENT, CAMELLIA, 0 }, { XTS, 0 }, 0, 1 },

+ { { AES, KUZNYECHIK, 0 }, { XTS, 0 }, 0, 1 },

+ { { CAMELLIA, SERPENT, KUZNYECHIK, 0 }, { XTS, 0 }, 0, 1 },

+#endif

+#ifndef WOLFCRYPT_BACKEND

+#endif

+ #ifndef WOLFCRYPT_BACKEND

+ { BLAKE2S, L"BLAKE2s-256", FALSE, TRUE },

+ { WHIRLPOOL, L"Whirlpool", FALSE, FALSE },

+ #endif

+ { 0, 0, 0 }

+#ifndef WOLFCRYPT_BACKEND

+#endif

+#ifndef WOLFCRYPT_BACKEND

+#endif

+#ifndef WOLFCRYPT_BACKEND

+#if CRYPTOPP_BOOL_X64 && !defined(CRYPTOPP_DISABLE_ASM)

+#endif

+#ifndef WOLFCRYPT_BACKEND

+#endif

+#ifndef WOLFCRYPT_BACKEND

+#if CRYPTOPP_BOOL_X64 && !defined(CRYPTOPP_DISABLE_ASM)

+#endif

+#if CRYPTOPP_BOOL_X64 && !defined(CRYPTOPP_DISABLE_ASM)

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

+ if (EAInit (ci->ea, key2, ci->ks2) != ERR_SUCCESS)

+

+ #ifdef WOLFCRYPT_BACKEND

+ if (xts_encrypt_key256 (key2, (aes_encrypt_ctx *) ci->ks) != EXIT_SUCCESS)

+ return ERR_CIPHER_INIT_FAILURE;

+

+ if (xts_decrypt_key256 (key2, (aes_decrypt_ctx *) (ci->ks + sizeof(aes_encrypt_ctx))) != EXIT_SUCCESS)

+ return ERR_CIPHER_INIT_FAILURE;

+ #endif

+ /* Note: XTS mode could potentially be initialized with a weak key causing all blocks in one data unit

+static void EAGetDisplayName(wchar_t *buf, size_t bufLen, int ea, int i)

+ StringCchCopyW (buf, bufLen, CipherGetName (i));

+ size_t curLen;

+ StringCchCatW (buf, bufLen, L"(");

+ curLen = wcslen(buf);

+ EAGetDisplayName (&buf[curLen], bufLen - curLen, ea, i);

+ StringCchCatW (buf, bufLen, L")");

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

+ EAGetDisplayName (buf, bufLen, ea, EAGetLastCipher(ea));

+ StringCchCopyW (buf, bufLen, (i != 0) ? CipherGetName (i) : L"?");

+ StringCchCatW (buf, bufLen, L"-");

+ StringCchCatW (buf, bufLen, CipherGetName (i));

+ EAGetName(n, 128, ea, 1);

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

+ StringCchCopyW (buf, bufLen, pHash -> Name);

+

+void crypto_eraseKeys (PCRYPTO_INFO cryptoInfo)

+{

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

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

+#ifdef TC_WINDOWS_DRIVER

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

+#else

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

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

+#endif

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

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

+}

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

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

+#elif defined (TC_WINDOWS_BOOT_CAMELLIA) && !defined (WOLFCRYPT_BACKEND)

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

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

+#elif defined (TC_WINDOWS_BOOT_CAMELLIA) && !defined (WOLFCRYPT_BACKEND)

+#elif defined (_M_ARM64) || defined(__arm__) || defined (__arm64__) || defined (__aarch64__)

+ return 0;

+

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

+

+static BOOL CpuRngDisabled = TRUE;

+static BOOL RamEncryptionEnabled = FALSE;

+

+BOOL IsCpuRngSupported ()

+{

+ if (HasRDSEED() || HasRDRAND())

+ return TRUE;

+ else

+ return FALSE;

+}

+

+void EnableCpuRng (BOOL enable)

+{

+ CpuRngDisabled = !enable;

+}

+

+BOOL IsCpuRngEnabled ()

+{

+ return !CpuRngDisabled;

+}

+

+BOOL IsRamEncryptionSupported ()

+{

+#ifdef _WIN64

+ if (t1ha_selfcheck__t1ha2() == 0)

+ return TRUE;

+ else

+ return FALSE;

+#else

+ return FALSE;

+#endif

+}

+

+void EnableRamEncryption (BOOL enable)

+{

+ RamEncryptionEnabled = enable;

+}

+

+BOOL IsRamEncryptionEnabled ()

+{

+ return RamEncryptionEnabled;

+}

+

+/* masking for random index to remove bias */

+byte GetRngMask (byte count)

+{

+ if (count >= 128)

+ return 0xFF;

+ if (count >= 64)

+ return 0x7F;

+ if (count >= 32)

+ return 0x3F;

+ if (count >= 16)

+ return 0x1F;

+ if (count >= 8)

+ return 0x0F;

+ if (count >= 4)

+ return 0x07;

+ if (count >= 2)

+ return 0x03;

+ return 1;

+}

+

+byte GetRandomIndex (ChaCha20RngCtx* pCtx, byte elementsCount)

+{

+ byte index = 0;

+ byte mask = GetRngMask (elementsCount);

+

+ while (TRUE)

+ {

+ ChaCha20RngGetBytes (pCtx, &index, 1);

+ index &= mask;

+ if (index < elementsCount)

+ break;

+ }

+

+ return index;

+}

+

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

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

+static byte* pbKeyDerivationArea = NULL;

+static ULONG cbKeyDerivationArea = 0;

+

+static uint64 HashSeedMask = 0;

+static uint64 CipherIVMask = 0;

+#ifdef TC_WINDOWS_DRIVER

+ULONG AllocTag = 'MMCV';

+#endif

+

+#if !defined(PAGE_SIZE)

+#define PAGE_SIZE 4096

+#endif

+

+BOOL InitializeSecurityParameters(GetRandSeedFn rngCallback)

+{

+ ChaCha20RngCtx ctx;

+ byte pbSeed[CHACHA20RNG_KEYSZ + CHACHA20RNG_IVSZ];

+#ifdef TC_WINDOWS_DRIVER

+ byte i;

+ char randomStr[4];

+ Dump ("InitializeSecurityParameters BEGIN\n");

+#endif

+

+ rngCallback (pbSeed, sizeof (pbSeed));

+

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

+

+#ifdef TC_WINDOWS_DRIVER

+

+ /* Generate random value for tag that is similar to pool tag values used by Windows kernel.

+ * Fully random tag would be too suspicious and outstanding.

+ * First character is always a capital letter.

+ * Second character is a letter, lowercase or uppercase.

+ * Third character is a letter, lowercase or uppercase.

+ * Fourth character is a letter or a digit.

+ */

+

+ /* 1. First character (Capital Letter) */

+ randomStr[0] = 'A' + GetRandomIndex(&ctx, 26);

+

+ /* 2. Second character (Letter) */

+ i = GetRandomIndex(&ctx, 52);

+ if (i < 26)

+ randomStr[1] = 'A' + i;

+ else

+ randomStr[1] = 'a' + (i - 26);

+

+ /* 3. Third character (Letter) */

+ i = GetRandomIndex(&ctx, 52);

+ if (i < 26)

+ randomStr[2] = 'A' + i;

+ else

+ randomStr[2] = 'a' + (i - 26);

+

+ /* 4. Fourth character (Letter or Digit) */

+ i = GetRandomIndex(&ctx, 62);

+ if (i < 26)

+ randomStr[3] = 'A' + i;

+ else if (i < 52)

+ randomStr[3] = 'a' + (i - 26);

+ else

+ randomStr[3] = '0' + (i - 52);

+

+ /* combine all characters in reverse order as explained in MSDN */

+ AllocTag = 0;

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

+ {

+ AllocTag = (AllocTag << 8) + randomStr[3-i];

+ }

+

+#endif

+

+ cbKeyDerivationArea = 1024 * 1024;

+ do

+ {

+ pbKeyDerivationArea = (byte*) TCalloc(cbKeyDerivationArea);

+ if (!pbKeyDerivationArea)

+ cbKeyDerivationArea >>= 1;

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

+

+ if (!pbKeyDerivationArea)

+ {

+ cbKeyDerivationArea = 0;

+ Dump ("InitializeSecurityParameters return=FALSE END\n");

+ return FALSE;

+ }

+

+ /* fill key derivation area with random bytes */

+ ChaCha20RngGetBytes (&ctx, pbKeyDerivationArea, cbKeyDerivationArea);

+

+ /* generate hash seed mask */

+ ChaCha20RngGetBytes(&ctx, (unsigned char*) &HashSeedMask, sizeof (HashSeedMask));

+

+ /* generate IV mask */

+ ChaCha20RngGetBytes(&ctx, (unsigned char*) &CipherIVMask, sizeof (CipherIVMask));

+

+ FAST_ERASE64 (pbSeed, sizeof (pbSeed));

+ burn (&ctx, sizeof (ctx));

+#ifdef TC_WINDOWS_DRIVER

+ burn (randomStr, sizeof(randomStr));

+

+ Dump ("InitializeSecurityParameters return=TRUE END\n");

+#endif

+ return TRUE;

+}

+

+void ClearSecurityParameters()

+{

+ Dump ("ClearSecurityParameters BEGIN\n");

+ if (pbKeyDerivationArea)

+ {

+ FAST_ERASE64 (pbKeyDerivationArea, cbKeyDerivationArea);

+ TCfree (pbKeyDerivationArea);

+ pbKeyDerivationArea =NULL;

+ cbKeyDerivationArea = 0;

+ }

+

+ FAST_ERASE64 (&HashSeedMask, 8);

+ FAST_ERASE64 (&CipherIVMask, 8);

+#ifdef TC_WINDOWS_DRIVER

+ burn (&AllocTag, sizeof (AllocTag));

+#endif

+ Dump ("ClearSecurityParameters END\n");

+}

+

+#ifdef TC_WINDOWS_DRIVER

+void VcProtectMemory (uint64 encID, unsigned char* pbData, size_t cbData, unsigned char* pbData2, size_t cbData2)

+#else

+void VcProtectMemory (uint64 encID, unsigned char* pbData, size_t cbData,

+ unsigned char* pbData2, size_t cbData2,

+ unsigned char* pbData3, size_t cbData3,

+ unsigned char* pbData4, size_t cbData4)

+#endif

+{

+ if (pbKeyDerivationArea)

+ {

+ uint64 hashLow, hashHigh, hashSeed, cipherIV;

+ uint64 pbKey[4];

+ ChaCha256Ctx ctx;

+

+ hashSeed = (((uint64) pbKeyDerivationArea) + encID) ^ HashSeedMask;

+ hashLow = t1ha2_atonce128(&hashHigh, pbKeyDerivationArea, cbKeyDerivationArea, hashSeed);

+

+ /* set the key to the hash result */

+ pbKey[0] = hashLow;

+ pbKey[1] = hashHigh;

+ /* we now have a 128-bit key and we will expand it to 256-bit by using ChaCha12 cipher */

+ /* first we need to generate a the other 128-bit half of the key */

+ pbKey[2] = hashLow ^ hashHigh;

+ pbKey[3] = hashLow + hashHigh;

+

+ /* Initialize ChaCha12 cipher */

+ ChaCha256Init (&ctx, (unsigned char*) pbKey, (unsigned char*) &hashSeed, 12);

+ /* encrypt the key by itself */

+ ChaCha256Encrypt (&ctx, (unsigned char*) pbKey, sizeof(pbKey), (unsigned char*) pbKey);

+

+ /* Initialize ChaCha12 cipher */

+ cipherIV = (((uint64) pbKeyDerivationArea) + encID) ^ CipherIVMask;

+ ChaCha256Init (&ctx, (unsigned char*) pbKey, (unsigned char*) &cipherIV, 12);

+

+ ChaCha256Encrypt (&ctx, pbData, cbData, pbData);

+ ChaCha256Encrypt (&ctx, pbData2, cbData2, pbData2);

+#ifndef TC_WINDOWS_DRIVER

+ ChaCha256Encrypt (&ctx, pbData3, cbData3, pbData3);

+ ChaCha256Encrypt (&ctx, pbData4, cbData4, pbData4);

+#endif

+ FAST_ERASE64 (pbKey, sizeof(pbKey));

+ FAST_ERASE64 (&hashLow, 8);

+ FAST_ERASE64 (&hashHigh, 8);

+ FAST_ERASE64 (&hashSeed, 8);

+ FAST_ERASE64 (&cipherIV, 8);

+ burn (&ctx, sizeof (ctx));

+ }

+}

+

+uint64 VcGetEncryptionID (PCRYPTO_INFO pCryptoInfo)

+{

+ return ((uint64) pCryptoInfo->ks) + ((uint64) pCryptoInfo->ks2)

+#ifndef TC_WINDOWS_DRIVER

+ + ((uint64) pCryptoInfo->master_keydata) + ((uint64) pCryptoInfo->k2)

+#endif

+ ;

+}

+

+static void VcInternalProtectKeys (PCRYPTO_INFO pCryptoInfo, uint64 encID)

+{

+#ifdef TC_WINDOWS_DRIVER

+ VcProtectMemory (encID, pCryptoInfo->ks, MAX_EXPANDED_KEY, pCryptoInfo->ks2, MAX_EXPANDED_KEY);

+#else

+ VcProtectMemory (encID, pCryptoInfo->ks, MAX_EXPANDED_KEY,

+ pCryptoInfo->ks2, MAX_EXPANDED_KEY,

+ pCryptoInfo->master_keydata, MASTER_KEYDATA_SIZE,

+ pCryptoInfo->k2, MASTER_KEYDATA_SIZE);

+#endif

+

+}

+

+void VcProtectKeys (PCRYPTO_INFO pCryptoInfo, uint64 encID)

+{

+ Dump ("VcProtectKeys BEGIN\n");

+ VcInternalProtectKeys (pCryptoInfo, encID);

+ Dump ("VcProtectKeys END\n");

+}

+

+void VcUnprotectKeys (PCRYPTO_INFO pCryptoInfo, uint64 encID)

+{

+ Dump ("VcUnprotectKeys BEGIN\n");

+ VcInternalProtectKeys (pCryptoInfo, encID);

+ Dump ("VcUnprotectKeys END\n");

+}

+#endif

+

+#endif

+

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

+{

+ ks = ks;

+ data = data;

+}

+

+void aes_hw_cpu_decrypt_32_blocks(const byte* ks, byte* data)

+{

+ ks = ks;

+ data = data;

+}

+

+void aes_hw_cpu_encrypt(const byte* ks, byte* data)

+{

+ ks = ks;

+ data = data;

+}

+

+void aes_hw_cpu_encrypt_32_blocks(const byte* ks, byte* data)

+{

+ ks = ks;

+ data = data;

+}

+#endif