{

}

{

if (!Initialized)

throw NotInitialized (SRC_POS);

Decrypt (data);

}

{

if (!Initialized)

throw NotInitialized (SRC_POS);

}

}

{

if (!Initialized)

throw NotInitialized (SRC_POS);

Encrypt (data);

}

{

if (!Initialized)

throw NotInitialized (SRC_POS);

Initialized = true;

}

{

if (!Initialized)

throw NotInitialized (SRC_POS);

EncryptXTS (data, length, startDataUnitNo);

}

{

if (!Initialized)

throw NotInitialized (SRC_POS);

// AES

{

#ifdef TC_AES_HW_CPU

if (IsHwSupportAvailable())

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

}

{

if (!Initialized)

throw NotInitialized (SRC_POS);

Cipher::DecryptBlocks (data, blockCount);

}

{

#ifdef TC_AES_HW_CPU

if (IsHwSupportAvailable())

aes_encrypt (data, data, (aes_encrypt_ctx *) ScheduledKey.Ptr());

}

{

if (!Initialized)

throw NotInitialized (SRC_POS);

Cipher::EncryptBlocks (data, blockCount);

}

#ifdef WOLFCRYPT_BACKEND

{

xts_encrypt (data, data, length, startDataUnitNo, (aes_encrypt_ctx *) ScheduledKey.Ptr());

}

{

xts_decrypt (data, data, length, startDataUnitNo, (aes_decrypt_ctx *) (ScheduledKey.Ptr() + sizeof (aes_encrypt_ctx)));

}

{

if (xts_encrypt_key256 (key, (aes_encrypt_ctx *) ScheduledKey.Ptr()) != EXIT_SUCCESS)

throw CipherInitError (SRC_POS);

#endif

}

{

if (aes_encrypt_key256 (key, (aes_encrypt_ctx *) ScheduledKey.Ptr()) != EXIT_SUCCESS)

throw CipherInitError (SRC_POS);

#ifndef WOLFCRYPT_BACKEND

// Serpent

{

serpent_decrypt (data, data, ScheduledKey);

}

{

serpent_encrypt (data, data, ScheduledKey);

}

return 140*4;

}

{

serpent_set_key (key, ScheduledKey);

}

{

if (!Initialized)

throw NotInitialized (SRC_POS);

Cipher::EncryptBlocks (data, blockCount);

}

{

if (!Initialized)

throw NotInitialized (SRC_POS);

// Twofish

{

twofish_decrypt ((TwofishInstance *) ScheduledKey.Ptr(), (unsigned int *)data, (unsigned int *)data);

}

{

twofish_encrypt ((TwofishInstance *) ScheduledKey.Ptr(), (unsigned int *)data, (unsigned int *)data);

}

return TWOFISH_KS;

}

{

twofish_set_key ((TwofishInstance *) ScheduledKey.Ptr(), (unsigned int *) key);

}

{

if (!Initialized)

throw NotInitialized (SRC_POS);

#endif

}

{

if (!Initialized)

throw NotInitialized (SRC_POS);

}

// Camellia

{

camellia_decrypt (data, data, ScheduledKey.Ptr());

}

{

camellia_encrypt (data, data, ScheduledKey.Ptr());

}

return CAMELLIA_KS;

}

{

camellia_set_key (key, ScheduledKey.Ptr());

}

{

if (!Initialized)

throw NotInitialized (SRC_POS);

#endif

}

{

if (!Initialized)

throw NotInitialized (SRC_POS);

}

// Kuznyechik

{

kuznyechik_decrypt_block (data, data, (kuznyechik_kds *) ScheduledKey.Ptr());

}

{

kuznyechik_encrypt_block (data, data, (kuznyechik_kds *) ScheduledKey.Ptr());

}

return KUZNYECHIK_KS;

}

{

kuznyechik_set_key (key, (kuznyechik_kds *) ScheduledKey.Ptr());

}

{

if (!Initialized)

throw NotInitialized (SRC_POS);

Cipher::EncryptBlocks (data, blockCount);

}

{

if (!Initialized)

throw NotInitialized (SRC_POS);

public:

virtual ~Cipher ();

#ifndef WOLFCRYPT_BACKEND

static void EnableHwSupport (bool enable) { HwSupportEnabled = enable; }

#else

static void EnableHwSupport (bool enable) { HwSupportEnabled = false; }

virtual void SetKeyXTS (const ConstBufferPtr &key);

#endif

static CipherList GetAvailableCiphers ();

virtual size_t GetBlockSize () const = 0;

virtual const SecureBuffer &GetKey () const { return Key; }

protected:

Cipher ();

virtual size_t GetScheduledKeySize () const = 0;

#ifdef WOLFCRYPT_BACKEND

#endif

static bool HwSupportEnabled;

TC_CIPHER_ADD_METHODS \

\

protected: \

virtual size_t GetScheduledKeySize () const; \

\

private: \

TC_JOIN (Cipher,NAME) (const TC_JOIN (Cipher,NAME) &); \

TC_CIPHER_ADD_METHODS \

\

protected: \

virtual size_t GetScheduledKeySize () const; \

\

private: \

TC_JOIN (Cipher,NAME) (const TC_JOIN (Cipher,NAME) &); \

#endif

#define TC_CIPHER_ADD_METHODS \

virtual bool IsHwSupportAvailable () const;

TC_CIPHER (AES, 16, 32);

uint32 Get () const { return CrcValue ^ 0xffffFFFF; }

{

}

static uint32 ProcessBuffer (const ConstBufferPtr &buffer)

{

}

protected:

{

}

{

if_debug (ValidateState ());

Mode->Decrypt (data, length);

Decrypt (data, data.Size());

}

{

if_debug (ValidateState());

Mode->DecryptSectors (data, sectorIndex, sectorCount, sectorSize);

}

{

if_debug (ValidateState());

Mode->Encrypt (data, length);

Encrypt (data, data.Size());

}

{

if_debug (ValidateState ());

Mode->EncryptSectors (data, sectorIndex, sectorCount, sectorSize);

public:

virtual ~EncryptionAlgorithm ();

virtual void Decrypt (const BufferPtr &data) const;

virtual void Encrypt (const BufferPtr &data) const;

static EncryptionAlgorithmList GetAvailableAlgorithms ();

virtual const CipherList &GetCiphers () const { return Ciphers; }

virtual shared_ptr <EncryptionAlgorithm> GetNew () const = 0;

{

}

{

EncryptionThreadPool::DoWork (EncryptionThreadPool::WorkType::DecryptDataUnits, this, data, sectorIndex, sectorCount, sectorSize);

}

{

EncryptionThreadPool::DoWork (EncryptionThreadPool::WorkType::EncryptDataUnits, this, data, sectorIndex, sectorCount, sectorSize);

}

throw NotInitialized (SRC_POS);

}

{

if ((Ciphers.size() > 0 && (length % Ciphers.front()->GetBlockSize()) != 0))

throw ParameterIncorrect (SRC_POS);

}

{

if (sectorCount == 0 || sectorSize == 0 || (sectorSize % EncryptionDataUnitSize) != 0)

throw ParameterIncorrect (SRC_POS);

public:

virtual ~EncryptionMode ();

static EncryptionModeList GetAvailableModes ();

virtual const SecureBuffer &GetKey () const { throw NotApplicable (SRC_POS); }

virtual size_t GetKeySize () const = 0;

EncryptionMode ();

virtual void ValidateState () const;

static const size_t EncryptionDataUnitSize = ENCRYPTION_DATA_UNIT_SIZE;

namespace VeraCrypt

{

{

EncryptBuffer (data, length, 0);

}

{

if_debug (ValidateState());

assert (iSecondaryCipher == SecondaryCiphers.end());

}

{

cipher.EncryptBlockXTS(buffer, length, startDataUnitNo);

}

{

EncryptBuffer (data, sectorCount * sectorSize, sectorIndex * sectorSize / ENCRYPTION_DATA_UNIT_SIZE);

}

return keySize;

}

{

DecryptBuffer (data, length, 0);

}

{

if_debug (ValidateState());

assert (iSecondaryCipher == SecondaryCiphers.begin());

}

{

cipher.DecryptBlockXTS(buffer, length, startDataUnitNo);

}

{

DecryptBuffer (data, sectorCount * sectorSize, sectorIndex * sectorSize / ENCRYPTION_DATA_UNIT_SIZE);

}

EncryptionModeWolfCryptXTS () { }

virtual ~EncryptionModeWolfCryptXTS () { }

virtual const SecureBuffer &GetKey () const { return SecondaryKey; }

virtual size_t GetKeySize () const;

virtual wstring GetName () const { return L"XTS"; };

virtual void SetKey (const ConstBufferPtr &key);

protected:

void SetSecondaryCipherKeys ();

SecureBuffer SecondaryKey;

namespace VeraCrypt

{

{

EncryptBuffer (data, length, 0);

}

{

if_debug (ValidateState());

assert (iSecondaryCipher == SecondaryCiphers.end());

}

{

uint64 *whiteningValuesPtr64 = (uint64 *) whiteningValues;

uint64 *whiteningValuePtr64 = (uint64 *) whiteningValue;

uint64 *bufPtr = (uint64 *) buffer;

}

#endif

// Actual encryption

bufPtr = dataUnitBufPtr;

whiteningValuesPtr64 = (uint64 *) whiteningValues;

FAST_ERASE64 (whiteningValues, sizeof (whiteningValues));

}

{

EncryptBuffer (data, sectorCount * sectorSize, sectorIndex * sectorSize / ENCRYPTION_DATA_UNIT_SIZE);

}

return keySize;

}

{

DecryptBuffer (data, length, 0);

}

{

if_debug (ValidateState());

assert (iSecondaryCipher == SecondaryCiphers.begin());

}

{

uint64 *whiteningValuesPtr64 = (uint64 *) whiteningValues;

uint64 *whiteningValuePtr64 = (uint64 *) whiteningValue;

uint64 *bufPtr = (uint64 *) buffer;

*bufPtr++ ^= *whiteningValuesPtr64++;

}

#endif

bufPtr = dataUnitBufPtr;

whiteningValuesPtr64 = (uint64 *) whiteningValues;

FAST_ERASE64 (whiteningValues, sizeof (whiteningValues));

}

{

DecryptBuffer (data, sectorCount * sectorSize, sectorIndex * sectorSize / ENCRYPTION_DATA_UNIT_SIZE);

}

EncryptionModeXTS () { }

virtual ~EncryptionModeXTS () { }

virtual const SecureBuffer &GetKey () const { return SecondaryKey; }

virtual size_t GetKeySize () const;

virtual wstring GetName () const { return L"XTS"; };

virtual void SetKey (const ConstBufferPtr &key);

protected:

void SetSecondaryCipherKeys ();

SecureBuffer SecondaryKey;

struct CipherTestVector

{

};

static const CipherTestVector AESTestVectors[] =

Buffer testData (1024);

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

{

}

uint32 origCrc = Crc32::ProcessBuffer (testData);

int testCase = 0;

int nTestsPerformed = 0;

{

0x27, 0x18, 0x28, 0x18, 0x28, 0x45, 0x90, 0x45, 0x23, 0x53, 0x60, 0x28, 0x74, 0x71, 0x35, 0x26, 0x62, 0x49, 0x77, 0x57, 0x24, 0x70, 0x93, 0x69, 0x99, 0x59, 0x57, 0x49, 0x66, 0x96, 0x76, 0x27,

0x31, 0x41, 0x59, 0x26, 0x53, 0x58, 0x97, 0x93, 0x23, 0x84, 0x62, 0x64, 0x33, 0x83, 0x27, 0x95, 0x02, 0x88, 0x41, 0x97, 0x16, 0x93, 0x99, 0x37, 0x51, 0x05, 0x82, 0x09, 0x74, 0x94, 0x45, 0x92,

Buffer modeKey (ea.GetKeySize());

for (size_t mi = 0; mi < modeKey.Size(); mi++)

modeKey.CopyFrom (ConstBufferPtr (XtsTestVectors[array_capacity (XtsTestVectors)-1].key2, sizeof (XtsTestVectors[array_capacity (XtsTestVectors)-1].key2)));

mode->SetKey (modeKey);

Buffer modeKey (ea.GetKeySize());

for (size_t mi = 0; mi < modeKey.Size(); mi++)

modeKey.CopyFrom (ConstBufferPtr (XtsTestVectors[array_capacity (XtsTestVectors)-1].key2, sizeof (XtsTestVectors[array_capacity (XtsTestVectors)-1].key2)));

mode->SetKey (modeKey);

void EncryptionTest::TestPkcs5 ()

{

ConstBufferPtr salt (saltData, sizeof (saltData));

Buffer derivedKey (4);

struct XtsTestVector

{

unsigned int blockNo;

};

static const XtsTestVector XtsTestVectors[];

namespace VeraCrypt

{

{

size_t fragmentCount;

size_t unitsPerFragment;

size_t remainder;

uint64 fragmentStartUnitNo;

WorkItem *workItem;

struct

{

const EncryptionMode *Mode;

uint64 StartUnitNo;

uint64 UnitCount;

size_t SectorSize;

};

};

static bool IsRunning () { return ThreadPoolRunning; }

static void Start ();

static void Stop ();

if (Token::IsKeyfilePathValid (Path, emvSupportEnabled))

{

// Apply keyfile generated by a security token

Token::getTokenKeyfile(wstring(Path))->GetKeyfileData(keyfileData);

if (keyfileData.size() < MinProcessedLength)

{

uint32 crc = crc32.Process(keyfileData[i]);

if (poolPos >= pool.Size())

poolPos = 0;

for (size_t i = 0; i < readLength; i++)

{

uint32 crc = crc32.Process(keyfileBuf[i]);

if (poolPos >= pool.Size())

poolPos = 0;

if (++totalLength >= MaxProcessedLength)

sr.Serialize ("WipeData", ConstBufferPtr (wipeBuffer));

}

{

AllocateBuffer ();

{

public:

VolumePassword ();

VolumePassword (const SecureBuffer &password) { Set (password.Ptr (), password.Size ()); }

VolumePassword (const VolumePassword &password) { Set (password); }

virtual ~VolumePassword ();

operator BufferPtr () const { return BufferPtr (PasswordBuffer); }

bool IsEmpty () const { return PasswordSize == 0; }

size_t Size () const { return PasswordSize; }

void Set (const VolumePassword &password);

TC_SERIALIZABLE (VolumePassword);