BOOL readOnly;

BOOL removable;

BOOL partitionInInactiveSysEncScope;

uint32 volumeHeaderFlags;

unsigned __int64 totalBytesRead;

unsigned __int64 totalBytesWritten;

{ AES, "AES", 16, 32, AES_KS },

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

{ TWOFISH, "Twofish", 16, 32, TWOFISH_KS },

{ 0, 0, 0, 0, 0 }

};

// Encryption algorithm configuration

static EncryptionAlgorithm EncryptionAlgorithms[] =

{

// Cipher(s) Modes FormatEnabled

#ifndef TC_WINDOWS_BOOT

#else // TC_WINDOWS_BOOT

#ifndef TC_WINDOWS_BOOT

{ SHA512, "SHA-512", FALSE, FALSE },

{ WHIRLPOOL, "Whirlpool", FALSE, FALSE },

#endif

{ 0, 0, 0 }

};

twofish_set_key ((TwofishInstance *)ks, (const u4byte *)key, CipherGetKeySize(TWOFISH) * 8);

break;

default:

// Unknown/wrong cipher ID

return ERR_CIPHER_INIT_FAILURE;

case TWOFISH: twofish_encrypt (ks, data, data); break;

case SERPENT: serpent_encrypt (data, data, ks); break;

default: TC_THROW_FATAL_EXCEPTION; // Unknown/wrong ID

}

}

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

break;

#else

case AES: aes_decrypt (data, data, ks); break;

#endif

that the size of each of the volumes is 1024 terabytes). */

break;

default:

// Unknown/wrong ID

TC_THROW_FATAL_EXCEPTION;

return "XTS";

}

return "[unknown]";

}

#ifndef TC_WINDOWS_BOOT_SINGLE_CIPHER_MODE

// EncryptBuffer

//

}

break;

default:

// Unknown/wrong ID

TC_THROW_FATAL_EXCEPTION;

}

}

// buf: data to be encrypted

// unitNo: sequential number of the data unit with which the buffer starts

unsigned __int8 *ks2 = ci->ks2;

int cipher;

switch (ci->mode)

{

case XTS:

}

break;

default:

// Unknown/wrong ID

TC_THROW_FATAL_EXCEPTION;

}

break;

default:

// Unknown/wrong ID

TC_THROW_FATAL_EXCEPTION;

unsigned __int8 *ks2 = ci->ks2;

int cipher;

switch (ci->mode)

{

}

break;

default:

// Unknown/wrong ID

TC_THROW_FATAL_EXCEPTION;

size = max (size, EAGetLargestKeyForMode (XTS) * 2); // Sizes of primary + secondary keys

return size;

}

// Size of the volume header area containing concatenated master key(s) and secondary key(s) (XTS mode)

#define MASTER_KEYDATA_SIZE 256

// The first PRF to try when mounting

#define FIRST_PRF_ID 1

#ifndef TC_WINDOWS_BOOT

SHA512,

WHIRLPOOL,

#endif

HASH_ENUM_END_ID

};

/* If you add/remove a mode, update the following: GetMaxPkcs5OutSize(), EAInitMode() */

XTS = FIRST_MODE_OF_OPERATION_ID,

MODE_ENUM_END_ID

};

NONE = 0,

AES,

SERPENT,

};

typedef struct

#endif

#include "Aes_hw_cpu.h"

#include "Serpent.h"

#include "Twofish.h"

#include "Rmd160.h"

#ifndef TC_WINDOWS_BOOT

# include "Sha2.h"

# include "Whirlpool.h"

#endif

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

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

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

BOOL IsAesHwCpuSupported ();

void EnableHwEncryption (BOOL enable);

}

else

{

CipherInit2(idTestCipher, key, ks_tmp, ks);

DecipherBlock(idTestCipher, tmp, ks_tmp);

}

}

*szTmp = 0;

SetWindowText(GetDlgItem(hwndDlg, IDC_SECONDARY_KEY), "0000000000000000000000000000000000000000000000000000000000000000");

SetWindowText(GetDlgItem(hwndDlg, IDC_TEST_DATA_UNIT_NUMBER), "0");

SetWindowText(GetDlgItem(hwndDlg, IDC_PLAINTEXT), "0000000000000000");

SetWindowText(GetDlgItem(hwndDlg, IDC_CIPHERTEXT), "0000000000000000");

workItem->KeyDerivation.IterationCount, workItem->KeyDerivation.DerivedKey, GetMaxPkcs5OutSize());

break;

default:

TC_THROW_FATAL_EXCEPTION;

}

return TRUE;

}

#define xor_8kt64(i) \

xor_block_aligned(r, ctx->gf_t128[i + i][a[i] & 15]); \

move_block_aligned(p, r);

}

/* Basic algorithms for testing of optimized algorithms */

}

}

BOOL GfMulSelfTest ()

{

if (!gfCtx)

return FALSE;

/* GF(2^128) */

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

void GfMul128Tab(unsigned char a[16], GfCtx8k *ctx);

int Gf128Tab64Init (unsigned __int8 *a, GfCtx *ctx);

void Gf128MulBy64Tab (unsigned __int8 a[8], unsigned __int8 p[16], GfCtx *ctx);

void MirrorBits128 (unsigned __int8 *a);

void MirrorBits64 (unsigned __int8 *a);

BOOL GfMulSelfTest ();

#include <memory.h>

#include "Rmd160.h"

#ifndef TC_WINDOWS_BOOT

#include "Sha2.h"

#include "Whirlpool.h"

#endif

burn (u, sizeof(u));

}

#endif // TC_WINDOWS_BOOT

void hmac_ripemd160 (char *key, int keylen, char *input, int len, char *digest)

case SHA512:

return "HMAC-SHA-512";

case RIPEMD160:

return "HMAC-RIPEMD-160";

#ifndef TC_WINDOWS_BOOT

case SHA512:

case WHIRLPOOL:

return 500000;

return TRUE;

}

// AES ECB test vectors FIPS-197

"\xe3\x7b\x6a\x77\x5d\xc8\x7d\xba\xa4\xdf\xa9\xf9\x6e\x5e\x3f\xfd\xde\xbd\x71\xf8\x86\x72\x89\x86\x5d\xf5\xa3\x2d\x20\xcd\xc9\x44\xb6\x02\x2c\xac\x3c\x49\x82\xb1\x0d\x5e\xeb\x55\xc3\xe4\xde\x15\x13\x46\x76\xfb\x6d\xe0\x44\x60\x65\xc9\x74\x40\xfa\x8c\x6a\x58",

};

char *hmac_ripemd160_test_keys[] =

{

"\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xaa\xbb\xcc\xdd\xee\xff\x01\x23\x45\x67",

{

switch (cipher)

{

case AES:

CipherInit(cipher,key,ks);

break;

case SERPENT:

CipherInit(cipher,key,ks);

break;

case TWOFISH:

CipherInit(cipher,key,ks);

break;

}

BOOL TestSectorBufEncryption (PCRYPTO_INFO ci)

{

unsigned char buf [ENCRYPTION_DATA_UNIT_SIZE * 4];

0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13

};

/* Encryption/decryption of data units (typically, volume data sectors) */

nbrUnits = sizeof (buf) / ENCRYPTION_DATA_UNIT_SIZE;

/* The buffer can accommodate 4 data units and we'll test 4 cases by "scrolling". The data unit 0xFFFFFFFFFF

will "move" from the start of the buffer to its end. For a 512-byte data unit, the byte offset 562949953420800

return (nTestsPerformed == 80);

}

static BOOL DoAutoTestAlgorithms (void)

{

PCRYPTO_INFO ci;

memset (ci, 0, sizeof (*ci));

/* AES */

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

if (!XTSAesTest (ci))

bFailed = TRUE;

/* Sector and buffer related algorithms */

if (!TestSectorBufEncryption (ci))

bFailed = TRUE;

return (nTestsPerformed == 6);

}

BOOL test_hmac_ripemd160 ()

{

int nTestsPerformed = 0;

if (!test_hmac_sha512())

return FALSE;

/* HMAC-RIPEMD-160 tests */

if (test_hmac_ripemd160() == FALSE)

return FALSE;

if (memcmp (dk, "\x13\x64\xae\xf8\x0d\xf5\x57\x6c\x30\xd5\x71\x4c\xa7\x75\x3f\xfd\x00\xe5\x25\x8b\x39\xc7\x44\x7f\xce\x23\x3d\x08\x75\xe0\x2f\x48\xd6\x30\xd7\x00\xb6\x24\xdb\xe0\x5a\xd7\x47\xef\x52\xca\xa6\x34\x83\x47\xe5\xcb\xe9\x87\xf1\x20\x59\x6a\xe6\xa9\xcf\x51\x78\xc6\xb6\x23\xa6\x74\x0d\xe8\x91\xbe\x1a\xd0\x28\xcc\xce\x16\x98\x9a\xbe\xfb\xdc\x78\xc9\xe1\x7d\x72\x67\xce\xe1\x61\x56\x5f\x96\x68\xe6\xe1\xdd\xf4\xbf\x1b\x80\xe0\x19\x1c\xf4\xc4\xd3\xdd\xd5\xd5\x57\x2d\x83\xc7\xa3\x37\x87\xf4\x4e\xe0\xf6\xd8\x6d\x65\xdc\xa0\x52\xa3\x13\xbe\x81\xfc\x30\xbe\x7d\x69\x58\x34\xb6\xdd\x41\xc6", 144) != 0)

return FALSE;

/* PKCS-5 test 1 with HMAC-RIPEMD-160 used as the PRF */

derive_key_ripemd160 (FALSE, "password", 8, "\x12\x34\x56\x78", 4, 5, dk, 4);

if (memcmp (dk, "\x7a\x3d\x7c\x03", 4) != 0)

// Test all available PKCS5 PRFs

for (enqPkcs5Prf = FIRST_PRF_ID; enqPkcs5Prf <= LAST_PRF_ID || queuedWorkItems > 0; ++enqPkcs5Prf)

if (encryptionThreadCount > 1)

{

// Enqueue key derivation on thread pool

PKCS5_SALT_SIZE, keyInfo.noIterations, dk, GetMaxPkcs5OutSize());

break;

case WHIRLPOOL:

derive_key_whirlpool (keyInfo.userKey, keyInfo.keyLength, keyInfo.salt,

PKCS5_SALT_SIZE, keyInfo.noIterations, dk, GetMaxPkcs5OutSize());

{

switch (cryptoInfo->mode)

{

default:

primaryKeyOffset = 0;

goto err;

}

}

{

}

// Copy the header for decryption

switch (cryptoInfo->mode)

{

default:

// The secondary master key (if cascade, multiple concatenated)

switch (mode)

{

default:

bytesNeeded = EAGetKeySize (ea) * 2; // Size of primary + secondary key(s)

PKCS5_SALT_SIZE, keyInfo.noIterations, dk, GetMaxPkcs5OutSize());

break;

case RIPEMD160:

derive_key_ripemd160 (TRUE, keyInfo.userKey, keyInfo.keyLength, keyInfo.salt,

PKCS5_SALT_SIZE, keyInfo.noIterations, dk, GetMaxPkcs5OutSize());

switch (mode)

{

default:

// The secondary key (if cascade, multiple concatenated)

switch (cryptoInfo->mode)

{

default:

// The secondary master key (if cascade, multiple concatenated)