Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

code distribution packages.

*/

For big-endian platforms define BYTE_ORDER as BIG_ENDIAN. */

// ks2: the secondary key schedule

// startDataUnitNo: The sequential number of the data unit with which the buffer starts.

// startCipherBlockNo: The sequential number of the first plaintext block to encrypt inside the data unit startDataUnitNo.

// The startCipherBlockNo value applies only to the first data unit in the buffer; each successive

// data unit is encrypted from its first block. The start of the buffer does not have to be

// aligned with the start of a data unit. If it is aligned, startCipherBlockNo must be 0; if it

the shift of the highest byte results in a carry, 135 is XORed into the lowest byte. The value 135 is

derived from the modulus of the Galois Field (x^128+x^7+x^2+x+1). */

// Note that as we are converting a 64-bit number into a 16-byte array we can always zero the last 8 bytes.

dataUnitNo = startDataUnitNo->Value;

*((unsigned __int64 *) byteBufUnitNo) = LE64 (dataUnitNo);

whiteningValuesPtr64 = finalInt64WhiteningValuesPtr;

whiteningValuePtr64 = (unsigned __int64 *) whiteningValue;

// whitening value for this data unit)

*whiteningValuePtr64 = *((unsigned __int64 *) byteBufUnitNo);

*(whiteningValuePtr64 + 1) = 0;

// Little-endian platforms

(*whiteningValuePtr64 & 0x8000000000000000) ?

135 : 0;

*whiteningValuePtr64-- <<= 1;

if (*whiteningValuePtr64 & 0x8000000000000000)

*whiteningValuePtr64 <<= 1;

#else

// Big-endian platforms

(*whiteningValuePtr64 & 0x80) ?

135 : 0;

whiteningValuePtr64--;

if (*whiteningValuePtr64 & 0x80)

*whiteningValuePtr64 = LE64 (LE64 (*whiteningValuePtr64) << 1);

#endif

// Actual encryption

EncipherBlocks (cipher, dataUnitBufPtr, ks, endBlock - startBlock);

bufPtr = dataUnitBufPtr;

whiteningValuesPtr64 = finalInt64WhiteningValuesPtr;

the shift of the highest byte results in a carry, 135 is XORed into the lowest byte. The value 135 is

derived from the modulus of the Galois Field (x^128+x^7+x^2+x+1). */

// Note that as we are converting a 64-bit number into a 16-byte array we can always zero the last 8 bytes.

dataUnitNo = startDataUnitNo->Value;

*((unsigned __int64 *) byteBufUnitNo) = LE64 (dataUnitNo);

whiteningValuePtr64 = (unsigned __int64 *) whiteningValue;

// whitening value for this data unit)

*whiteningValuePtr64 = *((unsigned __int64 *) byteBufUnitNo);

*(whiteningValuePtr64 + 1) = 0;

// Little-endian platforms

(*whiteningValuePtr64 & 0x8000000000000000) ?

135 : 0;

*whiteningValuePtr64-- <<= 1;

if (*whiteningValuePtr64 & 0x8000000000000000)

*whiteningValuePtr64 <<= 1;

#else

// Big-endian platforms

(*whiteningValuePtr64 & 0x80) ?

135 : 0;

whiteningValuePtr64--;

if (*whiteningValuePtr64 & 0x80)

*whiteningValuePtr64 = LE64 (LE64 (*whiteningValuePtr64) << 1);

#endif

unsigned __int64 *const finalInt64WhiteningValuesPtr = whiteningValuesPtr64 + sizeof (whiteningValues) / sizeof (*whiteningValuesPtr64) - 1;

TC_LARGEST_COMPILER_UINT blockCount, dataUnitNo;

// Note that as we are converting a 64-bit number into a 16-byte array we can always zero the last 8 bytes.

dataUnitNo = startDataUnitNo->Value;

*((unsigned __int64 *) byteBufUnitNo) = LE64 (dataUnitNo);

whiteningValuesPtr64 = finalInt64WhiteningValuesPtr;

whiteningValuePtr64 = (unsigned __int64 *) whiteningValue;

// whitening value for this data unit)

*whiteningValuePtr64 = *((unsigned __int64 *) byteBufUnitNo);

*(whiteningValuePtr64 + 1) = 0;

// Little-endian platforms

(*whiteningValuePtr64 & 0x8000000000000000) ?

135 : 0;

*whiteningValuePtr64-- <<= 1;

if (*whiteningValuePtr64 & 0x8000000000000000)

*whiteningValuePtr64 <<= 1;

#else

// Big-endian platforms

(*whiteningValuePtr64 & 0x80) ?

135 : 0;

whiteningValuePtr64--;

if (*whiteningValuePtr64 & 0x80)

*whiteningValuePtr64 = LE64 (LE64 (*whiteningValuePtr64) << 1);

#endif

unsigned int startBlock = startCipherBlockNo, endBlock, block;

TC_LARGEST_COMPILER_UINT blockCount, dataUnitNo;

// Note that as we are converting a 64-bit number into a 16-byte array we can always zero the last 8 bytes.

dataUnitNo = startDataUnitNo->Value;

*((unsigned __int64 *) byteBufUnitNo) = LE64 (dataUnitNo);

whiteningValuePtr64 = (unsigned __int64 *) whiteningValue;

// whitening value for this data unit)

*whiteningValuePtr64 = *((unsigned __int64 *) byteBufUnitNo);

*(whiteningValuePtr64 + 1) = 0;

// Little-endian platforms

(*whiteningValuePtr64 & 0x8000000000000000) ?

135 : 0;

*whiteningValuePtr64-- <<= 1;

if (*whiteningValuePtr64 & 0x8000000000000000)

*whiteningValuePtr64 <<= 1;

#else

// Big-endian platforms

(*whiteningValuePtr64 & 0x80) ?

135 : 0;

whiteningValuePtr64--;

if (*whiteningValuePtr64 & 0x80)

*whiteningValuePtr64 = LE64 (LE64 (*whiteningValuePtr64) << 1);

#endif

#if BYTE_ORDER == BIG_ENDIAN

#error The TC_NO_COMPILER_INT64 version of the XTS code is not compatible with big-endian platforms

// Converts a 64-bit unsigned integer (passed as two 32-bit integers for compatibility with non-64-bit

blockCount = length / BYTES_PER_XTS_BLOCK;

// (Passed as two 32-bit integers for compatibility with non-64-bit environments/platforms.)

Uint64ToLE16ByteArray (byteBufUnitNo, dataUnitNo.HighPart, dataUnitNo.LowPart);

else

endBlock = BLOCKS_PER_XTS_DATA_UNIT;

// whitening value for this data unit)

memcpy (whiteningValue, byteBufUnitNo, BYTES_PER_XTS_BLOCK);

EncipherBlock (cipher, whiteningValue, ks2);

// A regular carry

*(whiteningValuePtr32 + 1) |= 1;

}

{

// The highest byte shift will result in a carry

finalCarry = 135;

dataUnitNo.HighPart++;

}

Uint64ToLE16ByteArray (byteBufUnitNo, dataUnitNo.HighPart, dataUnitNo.LowPart);

}