data += blockSize;

}

}

}

#endif // !TC_WINDOWS_BOOT

// Ciphers support

Cipher *CipherGet (int id)

{

int i;

for (i = 0; Ciphers[i].Id != 0; i++)

if (Ciphers[i].Id == id)

return &Ciphers[i];

return NULL;

}

{

}

int CipherGetBlockSize (int cipherId)

{

}

int CipherGetKeySize (int cipherId)

{

}

int CipherGetKeyScheduleSize (int cipherId)

{

}

#ifndef TC_WINDOWS_BOOT

BOOL CipherSupportsIntraDataUnitParallelization (int cipher)

{

return cipher == AES && IsAesHwCpuSupported();

}

#endif

// Encryption algorithms support

int EAGetFirst ()

{

return 1;

}

// Returns number of EAs

int i;

for (i = 0; Hashes[i].Id != 0; i++)

if (Hashes[i].Id == id)

return &Hashes[i];

return 0;

}

int HashGetIdByName (char *name)

{

int i;

for (i = 0; Hashes[i].Id != 0; i++)

if (strcmp (Hashes[i].Name, name) == 0)

return Hashes[i].Id;

return 0;

}

{

}

BOOL HashIsDeprecated (int hashId)

{

}

#endif // TC_WINDOWS_BOOT_SINGLE_CIPHER_MODE

#ifdef TC_WINDOWS_BOOT

static byte CryptoInfoBufferInUse = 0;

CRYPTO_INFO CryptoInfoBuffer;

#endif

PCRYPTO_INFO crypto_open ()

{

#ifndef TC_WINDOWS_BOOT

/* Do the crt allocation */

PCRYPTO_INFO cryptoInfo = (PCRYPTO_INFO) TCalloc (sizeof (CRYPTO_INFO));

if (cryptoInfo == NULL)

#endif // !TC_WINDOWS_BOOT

UINT64_STRUCT VolumeSize;

UINT64_STRUCT EncryptedAreaStart;

UINT64_STRUCT EncryptedAreaLength;

uint32 HeaderFlags;

} CRYPTO_INFO, *PCRYPTO_INFO;

PCRYPTO_INFO crypto_open (void);

void crypto_loadkey (PKEY_INFO keyInfo, char *lpszUserKey, int nUserKeyLen);

void crypto_close (PCRYPTO_INFO cryptoInfo);

int CipherGetBlockSize (int cipher);

int CipherGetKeySize (int cipher);

int CipherGetKeyScheduleSize (int cipher);

BOOL CipherSupportsIntraDataUnitParallelization (int cipher);

int CipherInit (int cipher, unsigned char *key, unsigned char *ks);

int EAInit (int ea, unsigned char *key, unsigned char *ks);

BOOL EAInitMode (PCRYPTO_INFO ci);

void EncipherBlock(int cipher, void *data, void *ks);

void DecipherBlock(int cipher, void *data, void *ks);

#ifndef TC_WINDOWS_BOOT

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

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

#endif

int EAGetFirst ();

int EAGetCount (void);

int EAGetNext (int previousEA);

char * EAGetName (char *buf, int ea);

int EAGetByName (char *name);

int EAGetKeySize (int ea);

int EAGetFirstMode (int ea);

int EAGetNextMode (int ea, int previousModeId);

char * EAGetModeName (int ea, int mode, BOOL capitalLetters);

int EAGetKeyScheduleSize (int ea);

int EAGetLargestKey ();

int EAGetLargestKeyForMode (int mode);

int EAGetCipherCount (int ea);

int EAGetFirstCipher (int ea);

int EAGetLastCipher (int ea);

int EAGetNextCipher (int ea, int previousCipherId);

int EAGetPreviousCipher (int ea, int previousCipherId);

int EAIsFormatEnabled (int ea);

BOOL EAIsModeSupported (int ea, int testedMode);

BOOL HashIsDeprecated (int hashId);

int GetMaxPkcs5OutSize (void);

void EncryptDataUnits (unsigned __int8 *buf, const UINT64_STRUCT *structUnitNo, uint32 nbrUnits, PCRYPTO_INFO ci);

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

void DecryptDataUnits (unsigned __int8 *buf, const UINT64_STRUCT *structUnitNo, uint32 nbrUnits, PCRYPTO_INFO ci);

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);

#ifndef TC_NO_COMPILER_INT64

void EncryptBufferLRW128 (byte *buffer, uint64 length, uint64 blockIndex, PCRYPTO_INFO cryptoInfo);

void DecryptBufferLRW128 (byte *buffer, uint64 length, uint64 blockIndex, PCRYPTO_INFO cryptoInfo);

void EncryptBufferLRW64 (byte *buffer, uint64 length, uint64 blockIndex, PCRYPTO_INFO cryptoInfo);

void DecryptBufferLRW64 (byte *buffer, uint64 length, uint64 blockIndex, PCRYPTO_INFO cryptoInfo);

uint64 DataUnit2LRWIndex (uint64 dataUnit, int blockSize, PCRYPTO_INFO ci);

#endif // #ifndef TC_NO_COMPILER_INT64

BOOL IsAesHwCpuSupported ();

void EnableHwEncryption (BOOL enable);

if (szPassword != NULL)

memcpy (szPassword, szTmp1, sizeof (szTmp1));

if (szVerify != NULL)

memcpy (szVerify, szTmp2, sizeof (szTmp2));

burn (szTmp1, sizeof (szTmp1));

burn (szTmp2, sizeof (szTmp2));

EnableWindow (hButton, bEnable);

}

BOOL CheckPasswordCharEncoding (HWND hPassword, Password *ptrPw)

{

int i, len;

if (hPassword == NULL)

{

{

}

}

else

{

wchar_t s[MAX_PASSWORD + 1];

len = GetWindowTextLength (hPassword);

if (len > MAX_PASSWORD)

return FALSE;

GetWindowTextW (hPassword, s, sizeof (s) / sizeof (wchar_t));

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

{

if (s[i] >= 0x7f || s[i] < 0x20) // A non-ASCII or non-printable character?

break;

}

burn (s, sizeof(s));

if (i < len)

return FALSE;

}

return TRUE;

}

BOOL CheckPasswordLength (HWND hwndDlg, HWND hwndItem)

{

if (GetWindowTextLength (hwndItem) < PASSWORD_LEN_WARNING)

{

#ifndef _DEBUG

if (MessageBoxW (hwndDlg, GetString ("PASSWORD_LENGTH_WARNING"), lpszTitle, MB_YESNO|MB_ICONWARNING|MB_DEFBUTTON2) != IDYES)

return FALSE;

#endif

}

return TRUE;

}

{

int nDosLinkCreated = 1, nStatus = ERR_OS_ERROR;

char szDiskFile[TC_MAX_PATH], szCFDevice[TC_MAX_PATH];

char szDosDevice[TC_MAX_PATH];

char buffer[TC_VOLUME_HEADER_EFFECTIVE_SIZE];

PCRYPTO_INFO cryptoInfo = NULL, ci = NULL;

void *dev = INVALID_HANDLE_VALUE;

DWORD dwError;

DWORD bytesRead;

BOOL bDevice;

unsigned __int64 hostSize = 0;

int volumeType;

int wipePass;

FILETIME ftCreationTime;

FILETIME ftLastWriteTime;

FILETIME ftLastAccessTime;

BOOL bTimeStampValid = FALSE;

LARGE_INTEGER headerOffset;

BOOL backupHeader;

DISK_GEOMETRY driveInfo;

if (oldPassword->Length == 0 || newPassword->Length == 0) return -1;

WaitCursor ();

if (bDevice == FALSE)

{

strcpy (szCFDevice, szDiskFile);

}

else

{

if (nDosLinkCreated != 0)

goto error;

}

dev = CreateFile (szCFDevice, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);

if (dev == INVALID_HANDLE_VALUE)

goto error;

if (bDevice)

{

/* This is necessary to determine the hidden volume header offset */

if (dev == INVALID_HANDLE_VALUE)

{

goto error;

}

else

{

#define PASSWORD_LEN_WARNING 20 // Display a warning when a password is shorter than this

#ifdef __cplusplus

extern "C" {

#endif

typedef struct

{

// Modifying this structure can introduce incompatibility with previous versions

unsigned __int32 Length;

unsigned char Text[MAX_PASSWORD + 1];

char Pad[3]; // keep 64-bit alignment

} Password;

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

void VerifyPasswordAndUpdate ( HWND hwndDlg , HWND hButton , HWND hPassword , HWND hVerify , unsigned char *szPassword , char *szVerify, BOOL keyFilesEnabled );

BOOL CheckPasswordLength (HWND hwndDlg, HWND hwndItem);

BOOL CheckPasswordCharEncoding (HWND hPassword, Password *ptrPw);

#endif // defined(_WIN32) && !defined(TC_WINDOWS_DRIVER)

#ifdef __cplusplus

}

#endif

#endif // PASSWORD_H