/*

Copyright (c) 2008-2010 TrueCrypt Developers Association. All rights reserved.

Governed by the TrueCrypt License 3.0 the full text of which is contained in

the file License.txt included in TrueCrypt binary and source code distribution

packages.

*/

#include "Platform/Platform.h"

#include "Cipher.h"

#include "Crypto/Aes.h"

#include "Crypto/Serpent.h"

#include "Crypto/Twofish.h"

#ifdef TC_AES_HW_CPU

# include "Crypto/Aes_hw_cpu.h"

#endif

namespace VeraCrypt

{

Cipher::Cipher () : Initialized (false)

{

}

Cipher::~Cipher ()

{

}

void Cipher::DecryptBlock (byte *data) const

{

if (!Initialized)

void Cipher::EncryptBlocks (byte *data, size_t blockCount) const

{

if (!Initialized)

throw NotInitialized (SRC_POS);

while (blockCount-- > 0)

{

Encrypt (data);

data += GetBlockSize();

}

}

CipherList Cipher::GetAvailableCiphers ()

{

CipherList l;

l.push_back (shared_ptr <Cipher> (new CipherAES ()));

l.push_back (shared_ptr <Cipher> (new CipherSerpent ()));

l.push_back (shared_ptr <Cipher> (new CipherTwofish ()));

return l;

}

void Cipher::SetKey (const ConstBufferPtr &key)

{

if (key.Size() != GetKeySize ())

throw ParameterIncorrect (SRC_POS);

if (!Initialized)

ScheduledKey.Allocate (GetScheduledKeySize ());

SetCipherKey (key);

Key.CopyFrom (key);

Initialized = true;

}

#define TC_EXCEPTION(TYPE) TC_SERIALIZER_FACTORY_ADD(TYPE)

#undef TC_EXCEPTION_NODECL

#define TC_EXCEPTION_NODECL(TYPE) TC_SERIALIZER_FACTORY_ADD(TYPE)

if (!stateValid)

{

state = is_aes_hw_cpu_supported() ? true : false;

stateValid = true;

}

return state && HwSupportEnabled;

#else

return false;

#endif

}

void CipherAES::SetCipherKey (const byte *key)

{

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

throw CipherInitError (SRC_POS);

if (aes_decrypt_key256 (key, (aes_decrypt_ctx *) (ScheduledKey.Ptr() + sizeof (aes_encrypt_ctx))) != EXIT_SUCCESS)

throw CipherInitError (SRC_POS);

}

// Serpent

void CipherSerpent::Decrypt (byte *data) const

{

serpent_decrypt (data, data, ScheduledKey);

}

void CipherSerpent::Encrypt (byte *data) const

{

serpent_encrypt (data, data, ScheduledKey);

}

size_t CipherSerpent::GetScheduledKeySize () const

{

return 140*4;

}

void CipherSerpent::SetCipherKey (const byte *key)

{

serpent_set_key (key, static_cast<int> (GetKeySize ()), ScheduledKey);

}

// Twofish

void CipherTwofish::Decrypt (byte *data) const

{

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

}

void CipherTwofish::Encrypt (byte *data) const

{

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

}

size_t CipherTwofish::GetScheduledKeySize () const

{

return TWOFISH_KS;

}

void CipherTwofish::SetCipherKey (const byte *key)

{

twofish_set_key ((TwofishInstance *) ScheduledKey.Ptr(), (unsigned int *) key, static_cast<int> (GetKeySize ()) * 8);

}

virtual void Decrypt (byte *data) const; \

virtual void Encrypt (byte *data) const; \

virtual size_t GetScheduledKeySize () const; \

virtual void SetCipherKey (const byte *key); \

\

private: \

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

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

}

#define TC_CIPHER_ADD_METHODS \

virtual void DecryptBlocks (byte *data, size_t blockCount) const; \

virtual void EncryptBlocks (byte *data, size_t blockCount) const; \

virtual bool IsHwSupportAvailable () const;

TC_CIPHER (AES, 16, 32);

#undef TC_CIPHER_ADD_METHODS

#define TC_CIPHER_ADD_METHODS

TC_CIPHER (Serpent, 16, 32);

TC_CIPHER (Twofish, 16, 32);

#undef TC_CIPHER

#define TC_EXCEPTION(NAME) TC_EXCEPTION_DECL(NAME,CipherException)

#undef TC_EXCEPTION_SET

#define TC_EXCEPTION_SET \

TC_EXCEPTION (CipherInitError); \

TC_EXCEPTION (WeakKeyDetected);

TC_EXCEPTION_SET;

#undef TC_EXCEPTION

#if (defined (TC_ARCH_X86) || defined (TC_ARCH_X64)) && !defined (__ppc__)

# define TC_AES_HW_CPU

#endif

/*

Copyright (c) 2008 TrueCrypt Developers Association. All rights reserved.

Governed by the TrueCrypt License 3.0 the full text of which is contained in

the file License.txt included in TrueCrypt binary and source code distribution

packages.

*/

#include "EncryptionAlgorithm.h"

#include "EncryptionModeXTS.h"

namespace VeraCrypt

{

EncryptionAlgorithm::EncryptionAlgorithm () : Deprecated (false)

{

}

EncryptionAlgorithm::~EncryptionAlgorithm ()

{

}

void EncryptionAlgorithm::Decrypt (byte *data, uint64 length) const

{

if_debug (ValidateState ());

Mode->Decrypt (data, length);

}

void EncryptionAlgorithm::Decrypt (const BufferPtr &data) const

{

void EncryptionAlgorithm::EncryptSectors (byte *data, uint64 sectorIndex, uint64 sectorCount, size_t sectorSize) const

{

if_debug (ValidateState ());

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

}

EncryptionAlgorithmList EncryptionAlgorithm::GetAvailableAlgorithms ()

{

EncryptionAlgorithmList l;

l.push_back (shared_ptr <EncryptionAlgorithm> (new AES ()));

l.push_back (shared_ptr <EncryptionAlgorithm> (new Serpent ()));

l.push_back (shared_ptr <EncryptionAlgorithm> (new Twofish ()));

l.push_back (shared_ptr <EncryptionAlgorithm> (new AESTwofish ()));

l.push_back (shared_ptr <EncryptionAlgorithm> (new AESTwofishSerpent ()));

l.push_back (shared_ptr <EncryptionAlgorithm> (new SerpentAES ()));

l.push_back (shared_ptr <EncryptionAlgorithm> (new SerpentTwofishAES ()));

l.push_back (shared_ptr <EncryptionAlgorithm> (new TwofishSerpent ()));

return l;

}

size_t EncryptionAlgorithm::GetLargestKeySize (const EncryptionAlgorithmList &algorithms)

{

size_t largestKeySize = 0;

foreach_ref (const EncryptionAlgorithm &ea, algorithms)

{

if (ea.GetKeySize() > largestKeySize)

largestKeySize = ea.GetKeySize();

}

return largestKeySize;

}

size_t EncryptionAlgorithm::GetKeySize () const

{

if (Ciphers.size() < 1)

throw NotInitialized (SRC_POS);

size_t keyOffset = 0;

foreach_ref (Cipher &c, Ciphers)

{

c.SetKey (key.GetRange (keyOffset, c.GetKeySize()));

keyOffset += c.GetKeySize();

}

}

void EncryptionAlgorithm::ValidateState () const

{

if (Ciphers.size() < 1 || Mode.get() == nullptr)

throw NotInitialized (SRC_POS);

}

// AES

AES::AES ()

{

Ciphers.push_back (shared_ptr <Cipher> (new CipherAES()));

SupportedModes.push_back (shared_ptr <EncryptionMode> (new EncryptionModeXTS ()));

}

// AES-Twofish

AESTwofish::AESTwofish ()

{

Ciphers.push_back (shared_ptr <Cipher> (new CipherTwofish ()));

Ciphers.push_back (shared_ptr <Cipher> (new CipherAES ()));

SupportedModes.push_back (shared_ptr <EncryptionMode> (new EncryptionModeXTS ()));

}

// AES-Twofish-Serpent

AESTwofishSerpent::AESTwofishSerpent ()

{

Ciphers.push_back (shared_ptr <Cipher> (new CipherSerpent ()));

Ciphers.push_back (shared_ptr <Cipher> (new CipherTwofish ()));

Ciphers.push_back (shared_ptr <Cipher> (new CipherAES ()));

SupportedModes.push_back (shared_ptr <EncryptionMode> (new EncryptionModeXTS ()));

}

// Serpent

Serpent::Serpent ()

{

Ciphers.push_back (shared_ptr <Cipher> (new CipherSerpent()));

SupportedModes.push_back (shared_ptr <EncryptionMode> (new EncryptionModeXTS ()));

}

// Serpent-AES

SerpentAES::SerpentAES ()

{

Ciphers.push_back (shared_ptr <Cipher> (new CipherAES ()));

Ciphers.push_back (shared_ptr <Cipher> (new CipherSerpent ()));

SupportedModes.push_back (shared_ptr <EncryptionMode> (new EncryptionModeXTS ()));

}

// Twofish

Twofish::Twofish ()

{

Ciphers.push_back (shared_ptr <Cipher> (new CipherTwofish()));

SupportedModes.push_back (shared_ptr <EncryptionMode> (new EncryptionModeXTS ()));

}

// Twofish-Serpent

TwofishSerpent::TwofishSerpent ()

{

Ciphers.push_back (shared_ptr <Cipher> (new CipherSerpent ()));

Ciphers.push_back (shared_ptr <Cipher> (new CipherTwofish ()));

SupportedModes.push_back (shared_ptr <EncryptionMode> (new EncryptionModeXTS ()));

}

// Serpent-Twofish-AES

SerpentTwofishAES::SerpentTwofishAES ()

{

Ciphers.push_back (shared_ptr <Cipher> (new CipherAES ()));

Ciphers.push_back (shared_ptr <Cipher> (new CipherTwofish ()));

Ciphers.push_back (shared_ptr <Cipher> (new CipherSerpent ()));

SupportedModes.push_back (shared_ptr <EncryptionMode> (new EncryptionModeXTS ()));

}

}

private:

EncryptionAlgorithm (const EncryptionAlgorithm &);

EncryptionAlgorithm &operator= (const EncryptionAlgorithm &);

};

#define TC_ENCRYPTION_ALGORITHM(NAME) \

class NAME : public EncryptionAlgorithm \

{ \

public: \

NAME (); \

virtual ~NAME () { } \

\

virtual shared_ptr <EncryptionAlgorithm> GetNew () const { return shared_ptr <EncryptionAlgorithm> (new NAME()); } \

\

private: \

NAME (const NAME &); \

NAME &operator= (const NAME &); \

}

TC_ENCRYPTION_ALGORITHM (AES);

TC_ENCRYPTION_ALGORITHM (AESTwofish);

TC_ENCRYPTION_ALGORITHM (AESTwofishSerpent);

TC_ENCRYPTION_ALGORITHM (Serpent);

TC_ENCRYPTION_ALGORITHM (SerpentAES);

TC_ENCRYPTION_ALGORITHM (Twofish);

TC_ENCRYPTION_ALGORITHM (TwofishSerpent);

TC_ENCRYPTION_ALGORITHM (SerpentTwofishAES);

#undef TC_ENCRYPTION_ALGORITHM

}

#endif // TC_HEADER_Encryption_EncryptionAlgorithm

/*

Copyright (c) 2008 TrueCrypt Developers Association. All rights reserved.

Governed by the TrueCrypt License 3.0 the full text of which is contained in

the file License.txt included in TrueCrypt binary and source code distribution

packages.

*/

#include "EncryptionMode.h"

#include "EncryptionModeXTS.h"

#include "EncryptionThreadPool.h"

namespace VeraCrypt

{

EncryptionMode::EncryptionMode () : KeySet (false), SectorOffset (0)

{

}

EncryptionMode::~EncryptionMode ()

{

}

void EncryptionMode::DecryptSectors (byte *data, uint64 sectorIndex, uint64 sectorCount, size_t sectorSize) const

{

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

}

void EncryptionMode::EncryptSectors (byte *data, uint64 sectorIndex, uint64 sectorCount, size_t sectorSize) const

{

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

}

EncryptionModeList EncryptionMode::GetAvailableModes ()

{

EncryptionModeList l;

l.push_back (shared_ptr <EncryptionMode> (new EncryptionModeXTS ()));

return l;

}

void EncryptionMode::ValidateState () const

{

if (!KeySet || Ciphers.size() < 1)

throw NotInitialized (SRC_POS);

}

void EncryptionMode::ValidateParameters (byte *data, uint64 length) const

{

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

throw ParameterIncorrect (SRC_POS);

}

void EncryptionMode::ValidateParameters (byte *data, uint64 sectorCount, size_t sectorSize) const

{

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

throw ParameterIncorrect (SRC_POS);

/*

Copyright (c) 2008-2010 TrueCrypt Developers Association. All rights reserved.

Governed by the TrueCrypt License 3.0 the full text of which is contained in

the file License.txt included in TrueCrypt binary and source code distribution

packages.

*/

#include "Cipher.h"

#include "Common/Crc.h"

#include "Crc32.h"

#include "EncryptionAlgorithm.h"

#include "EncryptionMode.h"

#include "EncryptionModeXTS.h"

#include "EncryptionTest.h"

#include "Pkcs5Kdf.h"

namespace VeraCrypt

{

void EncryptionTest::TestAll ()

{

TestAll (false);

TestAll (true);

}

void EncryptionTest::TestAll (bool enableCpuEncryptionSupport)

{

bool hwSupportEnabled = Cipher::IsHwSupportEnabled();

finally_do_arg (bool, hwSupportEnabled, { Cipher::EnableHwSupport (finally_arg); });

Cipher::EnableHwSupport (enableCpuEncryptionSupport);

TestCiphers();

TestXtsAES();

TestXts();

TestPkcs5();

}

struct CipherTestVector

{

byte Key[32];

byte Plaintext[16];

byte Ciphertext[16];

};

static const CipherTestVector AESTestVectors[] =

{

{

{

0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,

0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,

},

{

0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff

},

{

0x8e, 0xa2, 0xb7, 0xca, 0x51, 0x67, 0x45, 0xbf, 0xea, 0xfc, 0x49, 0x90, 0x4b, 0x49, 0x60, 0x89

nTestsPerformed++;

}

if (nTestsPerformed != 80)

throw TestFailed (SRC_POS);

}

void EncryptionTest::TestPkcs5 ()

{

VolumePassword password ("password", 8);

static const byte saltData[] = { 0x12, 0x34, 0x56, 0x78 };

ConstBufferPtr salt (saltData, sizeof (saltData));

Buffer derivedKey (4);

Pkcs5HmacRipemd160 pkcs5HmacRipemd160;

pkcs5HmacRipemd160.DeriveKey (derivedKey, password, salt, 5, FALSE);

if (memcmp (derivedKey.Ptr(), "\x7a\x3d\x7c\x03", 4) != 0)

throw TestFailed (SRC_POS);

Pkcs5HmacSha512 pkcs5HmacSha512;

pkcs5HmacSha512.DeriveKey (derivedKey, password, salt, 5, FALSE);

if (memcmp (derivedKey.Ptr(), "\x13\x64\xae\xf8", 4) != 0)

throw TestFailed (SRC_POS);

Pkcs5HmacWhirlpool pkcs5HmacWhirlpool;

pkcs5HmacWhirlpool.DeriveKey (derivedKey, password, salt, 5, FALSE);

if (memcmp (derivedKey.Ptr(), "\x50\x7c\x36\x6f", 4) != 0)

throw TestFailed (SRC_POS);

}

}

/*

Copyright (c) 2008 TrueCrypt Developers Association. All rights reserved.

Governed by the TrueCrypt License 3.0 the full text of which is contained in

the file License.txt included in TrueCrypt binary and source code distribution

packages.

*/

#include "Hash.h"

#include "Crypto/Rmd160.h"

#include "Crypto/Sha2.h"

#include "Crypto/Whirlpool.h"

namespace VeraCrypt

{

HashList Hash::GetAvailableAlgorithms ()

{

HashList l;

l.push_back (shared_ptr <Hash> (new Ripemd160 ()));

l.push_back (shared_ptr <Hash> (new Sha512 ()));

l.push_back (shared_ptr <Hash> (new Whirlpool ()));

return l;

}

void Hash::ValidateDataParameters (const ConstBufferPtr &data) const

{

if (data.Size() < 1)

throw ParameterIncorrect (SRC_POS);

}

void Hash::ValidateDigestParameters (const BufferPtr &buffer) const

{

if (buffer.Size() != GetDigestSize ())

throw ParameterIncorrect (SRC_POS);

}

// RIPEMD-160

Ripemd160::Ripemd160 ()

{

Context.Allocate (sizeof (RMD160_CTX));

Init();

}

void Ripemd160::GetDigest (const BufferPtr &buffer)

{

if_debug (ValidateDigestParameters (buffer));

RMD160Final (buffer, (RMD160_CTX *) Context.Ptr());

}

void Ripemd160::Init ()

{

RMD160Init ((RMD160_CTX *) Context.Ptr());

}

void Ripemd160::ProcessData (const ConstBufferPtr &data)

{

if_debug (ValidateDataParameters (data));

RMD160Update ((RMD160_CTX *) Context.Ptr(), data.Get(), (int) data.Size());

}

// SHA-512

Sha512::Sha512 ()

{

Context.Allocate (sizeof (sha512_ctx));

Init();

}

void Sha512::GetDigest (const BufferPtr &buffer)

{

if_debug (ValidateDigestParameters (buffer));

sha512_end (buffer, (sha512_ctx *) Context.Ptr());

}

void Sha512::Init ()

{

sha512_begin ((sha512_ctx *) Context.Ptr());

}

void Sha512::ProcessData (const ConstBufferPtr &data)

{

public:

Ripemd160 ();

virtual ~Ripemd160 () { }

virtual void GetDigest (const BufferPtr &buffer);

virtual size_t GetBlockSize () const { return 64; }

virtual size_t GetDigestSize () const { return 160 / 8; }

virtual wstring GetName () const { return L"RIPEMD-160"; }

virtual shared_ptr <Hash> GetNew () const { return shared_ptr <Hash> (new Ripemd160); }

virtual void Init ();

virtual void ProcessData (const ConstBufferPtr &data);

protected:

private:

Ripemd160 (const Ripemd160 &);

Ripemd160 &operator= (const Ripemd160 &);

};

// SHA-512

class Sha512 : public Hash

{

public:

Sha512 ();

virtual ~Sha512 () { }

virtual void GetDigest (const BufferPtr &buffer);

virtual size_t GetBlockSize () const { return 128; }

virtual size_t GetDigestSize () const { return 512 / 8; }

virtual wstring GetName () const { return L"SHA-512"; }

virtual shared_ptr <Hash> GetNew () const { return shared_ptr <Hash> (new Sha512); }

virtual void Init ();

virtual void ProcessData (const ConstBufferPtr &data);

protected:

private:

Sha512 (const Sha512 &);

Sha512 &operator= (const Sha512 &);

}

shared_ptr <Pkcs5Kdf> Pkcs5Kdf::GetAlgorithm (const Hash &hash)

{

foreach (shared_ptr <Pkcs5Kdf> kdf, GetAvailableAlgorithms())

{

if (typeid (*kdf->GetHash()) == typeid (hash))

return kdf;

}

throw ParameterIncorrect (SRC_POS);

}

Pkcs5KdfList Pkcs5Kdf::GetAvailableAlgorithms ()

{

Pkcs5KdfList l;

l.push_back (shared_ptr <Pkcs5Kdf> (new Pkcs5HmacRipemd160 ()));

l.push_back (shared_ptr <Pkcs5Kdf> (new Pkcs5HmacSha512 ()));

l.push_back (shared_ptr <Pkcs5Kdf> (new Pkcs5HmacWhirlpool ()));

return l;

}

void Pkcs5Kdf::ValidateParameters (const BufferPtr &key, const VolumePassword &password, const ConstBufferPtr &salt, int iterationCount) const

{

if (key.Size() < 1 || password.Size() < 1 || salt.Size() < 1 || iterationCount < 1)

throw ParameterIncorrect (SRC_POS);

}

void Pkcs5HmacRipemd160::DeriveKey (const BufferPtr &key, const VolumePassword &password, const ConstBufferPtr &salt, int iterationCount, BOOL bNotTest) const

{

ValidateParameters (key, password, salt, iterationCount);

derive_key_ripemd160 (bNotTest, (char *) password.DataPtr(), (int) password.Size(), (char *) salt.Get(), (int) salt.Size(), iterationCount, (char *) key.Get(), (int) key.Size());

}

void Pkcs5HmacRipemd160_1000::DeriveKey (const BufferPtr &key, const VolumePassword &password, const ConstBufferPtr &salt, int iterationCount, BOOL bNotTest) const

{

ValidateParameters (key, password, salt, iterationCount);

derive_key_ripemd160 (bNotTest, (char *) password.DataPtr(), (int) password.Size(), (char *) salt.Get(), (int) salt.Size(), iterationCount, (char *) key.Get(), (int) key.Size());

}

void Pkcs5HmacSha512::DeriveKey (const BufferPtr &key, const VolumePassword &password, const ConstBufferPtr &salt, int iterationCount, BOOL bNotTest) const

{

ValidateParameters (key, password, salt, iterationCount);

derive_key_sha512 ((char *) password.DataPtr(), (int) password.Size(), (char *) salt.Get(), (int) salt.Size(), iterationCount, (char *) key.Get(), (int) key.Size());

}

void Pkcs5HmacWhirlpool::DeriveKey (const BufferPtr &key, const VolumePassword &password, const ConstBufferPtr &salt, int iterationCount, BOOL bNotTest) const

{

ValidateParameters (key, password, salt, iterationCount);

derive_key_whirlpool ((char *) password.DataPtr(), (int) password.Size(), (char *) salt.Get(), (int) salt.Size(), iterationCount, (char *) key.Get(), (int) key.Size());

}

}

Pkcs5HmacRipemd160 (const Pkcs5HmacRipemd160 &);

Pkcs5HmacRipemd160 &operator= (const Pkcs5HmacRipemd160 &);

};

class Pkcs5HmacRipemd160_1000 : public Pkcs5Kdf

{

public:

Pkcs5HmacRipemd160_1000 () { }

virtual ~Pkcs5HmacRipemd160_1000 () { }

virtual void DeriveKey (const BufferPtr &key, const VolumePassword &password, const ConstBufferPtr &salt, int iterationCount, BOOL bNotTest = TRUE) const;

virtual shared_ptr <Hash> GetHash () const { return shared_ptr <Hash> (new Ripemd160); }

virtual int GetIterationCount () const { return 16384; }

virtual wstring GetName () const { return L"HMAC-RIPEMD-160"; }

private:

Pkcs5HmacRipemd160_1000 (const Pkcs5HmacRipemd160_1000 &);

Pkcs5HmacRipemd160_1000 &operator= (const Pkcs5HmacRipemd160_1000 &);

};

class Pkcs5HmacSha512 : public Pkcs5Kdf

{

public:

Pkcs5HmacSha512 () { }

virtual ~Pkcs5HmacSha512 () { }

virtual void DeriveKey (const BufferPtr &key, const VolumePassword &password, const ConstBufferPtr &salt, int iterationCount, BOOL bNotTest = TRUE) const;

virtual shared_ptr <Hash> GetHash () const { return shared_ptr <Hash> (new Sha512); }

virtual int GetIterationCount () const { return 500000; }

virtual wstring GetName () const { return L"HMAC-SHA-512"; }

private:

Pkcs5HmacSha512 (const Pkcs5HmacSha512 &);

Pkcs5HmacSha512 &operator= (const Pkcs5HmacSha512 &);

};

class Pkcs5HmacWhirlpool : public Pkcs5Kdf

{

public:

/*

Copyright (c) 2008-2010 TrueCrypt Developers Association. All rights reserved.

Governed by the TrueCrypt License 3.0 the full text of which is contained in

the file License.txt included in TrueCrypt binary and source code distribution

packages.

*/

#ifndef TC_WINDOWS

#include <errno.h>

#endif

#include "EncryptionModeXTS.h"

#include "Volume.h"

#include "VolumeHeader.h"

#include "VolumeLayout.h"

#include "Common/Crypto.h"

namespace VeraCrypt

{

Volume::Volume ()

: HiddenVolumeProtectionTriggered (false),

SystemEncryption (false),

VolumeDataSize (0),

TopWriteOffset (0),

TotalDataRead (0),

TotalDataWritten (0)

{

}

Volume::~Volume ()

{

VolumeDataSize = layout->GetDataSize (VolumeHostSize);

Header = header;

Layout = layout;

EA = header->GetEncryptionAlgorithm();

EncryptionMode &mode = *EA->GetMode();

if (layout->HasDriveHeader())

{

if (header->GetEncryptedAreaLength() != header->GetVolumeDataSize())

throw VolumeEncryptionNotCompleted (SRC_POS);

uint64 partitionStartOffset = VolumeFile->GetPartitionDeviceStartOffset();

if (partitionStartOffset < header->GetEncryptedAreaStart()

|| partitionStartOffset >= header->GetEncryptedAreaStart() + header->GetEncryptedAreaLength())

throw PasswordIncorrect (SRC_POS);

mode.SetSectorOffset (partitionStartOffset / ENCRYPTION_DATA_UNIT_SIZE);

}

// Volume protection

if (Protection == VolumeProtection::HiddenVolumeReadOnly)

{

if (Type == VolumeType::Hidden)

throw PasswordIncorrect (SRC_POS);

else

{

try

{

Volume protectedVolume;

protectedVolume.Open (VolumeFile,

protectionPassword, protectionKeyfiles,

VolumeProtection::ReadOnly,

shared_ptr <VolumePassword> (), shared_ptr <KeyfileList> (),

VolumeType::Hidden,

useBackupHeaders);

if (protectedVolume.GetType() != VolumeType::Hidden)

OBJS += VolumeInfo.o

OBJS += VolumeLayout.o

OBJS += VolumePassword.o

OBJS += VolumePasswordCache.o

ifeq "$(CPU_ARCH)" "x86"

OBJS += ../Crypto/Aes_x86.o

OBJS += ../Crypto/Aes_hw_cpu.o

ifeq "$(PLATFORM)" "MacOSX"

OBJS += ../Crypto/Aescrypt.o

endif

else ifeq "$(CPU_ARCH)" "x64"

OBJS += ../Crypto/Aes_x64.o

OBJS += ../Crypto/Aes_hw_cpu.o

else

OBJS += ../Crypto/Aescrypt.o

endif

OBJS += ../Crypto/Aeskey.o

OBJS += ../Crypto/Aestab.o

OBJS += ../Crypto/Rmd160.o

OBJS += ../Crypto/Serpent.o

OBJS += ../Crypto/Sha2.o

OBJS += ../Crypto/Twofish.o

OBJS += ../Crypto/Whirlpool.o

OBJS += ../Common/Crc.o

OBJS += ../Common/Endian.o

OBJS += ../Common/GfMul.o

OBJS += ../Common/Pkcs5.o

OBJS += ../Common/SecurityToken.o

VolumeLibrary: Volume.a

include $(BUILD_INC)/Makefile.inc

/*

Copyright (c) 2008 TrueCrypt Developers Association. All rights reserved.

Governed by the TrueCrypt License 3.0 the full text of which is contained in

the file License.txt included in TrueCrypt binary and source code distribution

packages.

*/

#include "Volume/EncryptionMode.h"

#include "Volume/EncryptionModeXTS.h"

#include "VolumeLayout.h"

#include "Boot/Windows/BootCommon.h"

namespace VeraCrypt

{

VolumeLayout::VolumeLayout ()

{

}

VolumeLayout::~VolumeLayout ()

{

}

VolumeLayoutList VolumeLayout::GetAvailableLayouts (VolumeType::Enum type)

{

VolumeLayoutList layouts;

layouts.push_back (shared_ptr <VolumeLayout> (new VolumeLayoutV2Normal ()));

layouts.push_back (shared_ptr <VolumeLayout> (new VolumeLayoutV1Normal ()));

return Header;

}

VolumeLayoutV1Normal::VolumeLayoutV1Normal ()

{

Type = VolumeType::Normal;

HeaderOffset = TC_VOLUME_HEADER_OFFSET;

HeaderSize = TC_VOLUME_HEADER_SIZE_LEGACY;

SupportedEncryptionAlgorithms.push_back (shared_ptr <EncryptionAlgorithm> (new AES ()));

SupportedEncryptionAlgorithms.push_back (shared_ptr <EncryptionAlgorithm> (new Serpent ()));

SupportedEncryptionAlgorithms.push_back (shared_ptr <EncryptionAlgorithm> (new Twofish ()));

SupportedEncryptionAlgorithms.push_back (shared_ptr <EncryptionAlgorithm> (new AESTwofish ()));

SupportedEncryptionAlgorithms.push_back (shared_ptr <EncryptionAlgorithm> (new AESTwofishSerpent ()));

SupportedEncryptionAlgorithms.push_back (shared_ptr <EncryptionAlgorithm> (new SerpentAES ()));

SupportedEncryptionAlgorithms.push_back (shared_ptr <EncryptionAlgorithm> (new SerpentTwofishAES ()));

SupportedEncryptionAlgorithms.push_back (shared_ptr <EncryptionAlgorithm> (new TwofishSerpent ()));

SupportedEncryptionModes.push_back (shared_ptr <EncryptionMode> (new EncryptionModeXTS ()));

}

uint64 VolumeLayoutV1Normal::GetDataOffset (uint64 volumeHostSize) const

{

return HeaderSize;

}

uint64 VolumeLayoutV1Normal::GetDataSize (uint64 volumeHostSize) const

{

return volumeHostSize - GetHeaderSize();

}

VolumeLayoutV1Hidden::VolumeLayoutV1Hidden ()

{

Type = VolumeType::Hidden;

HeaderOffset = -TC_HIDDEN_VOLUME_HEADER_OFFSET_LEGACY;

HeaderSize = TC_VOLUME_HEADER_SIZE_LEGACY;

SupportedEncryptionAlgorithms.push_back (shared_ptr <EncryptionAlgorithm> (new AES ()));

SupportedEncryptionAlgorithms.push_back (shared_ptr <EncryptionAlgorithm> (new Serpent ()));

SupportedEncryptionAlgorithms.push_back (shared_ptr <EncryptionAlgorithm> (new Twofish ()));

SupportedEncryptionAlgorithms.push_back (shared_ptr <EncryptionAlgorithm> (new AESTwofish ()));

SupportedEncryptionAlgorithms.push_back (shared_ptr <EncryptionAlgorithm> (new AESTwofishSerpent ()));

SupportedEncryptionAlgorithms.push_back (shared_ptr <EncryptionAlgorithm> (new SerpentAES ()));

SupportedEncryptionAlgorithms.push_back (shared_ptr <EncryptionAlgorithm> (new SerpentTwofishAES ()));

SupportedEncryptionAlgorithms.push_back (shared_ptr <EncryptionAlgorithm> (new TwofishSerpent ()));

SupportedEncryptionModes.push_back (shared_ptr <EncryptionMode> (new EncryptionModeXTS ()));

}

uint64 VolumeLayoutV1Hidden::GetDataOffset (uint64 volumeHostSize) const

{

return volumeHostSize - GetDataSize (volumeHostSize) + HeaderOffset;

}

uint64 VolumeLayoutV1Hidden::GetDataSize (uint64 volumeHostSize) const

{

return Header->GetHiddenVolumeDataSize ();

}

VolumeLayoutV2Normal::VolumeLayoutV2Normal ()

{

Type = VolumeType::Normal;

HeaderOffset = TC_VOLUME_HEADER_OFFSET;

HeaderSize = TC_VOLUME_HEADER_SIZE;

BackupHeaderOffset = -TC_VOLUME_HEADER_GROUP_SIZE;