--- truecrypt/common/crypto.c	2018/04/24 16:40:48	1.1.1.4
+++ truecrypt/common/crypto.c	2018/04/24 16:42:13	1.1.1.6
@@ -1,13 +1,366 @@
 /* The source code contained in this file has been derived from the source code
    of Encryption for the Masses 2.02a by Paul Le Roux. Modifications and
-   additions to that source code contained in this file are Copyright (c) 2004
-   TrueCrypt Team and Copyright (c) 2004 TrueCrypt Foundation. Unmodified
+   additions to that source code contained in this file are Copyright (c) 2004-2005
+   TrueCrypt Foundation and Copyright (c) 2004 TrueCrypt Team. Unmodified
    parts are Copyright (c) 1998-99 Paul Le Roux. This is a TrueCrypt Foundation
    release. Please see the file license.txt for full license details. */
 
 #include "TCdefs.h"
 #include "crypto.h"
 #include "random.h"
+#include "crc.h"
+
+/* Update the following when adding a new cipher or EA:
+
+   Crypto.h:
+     ID #define
+     MAX_EXPANDED_KEY #define
+
+   Crypto.c:
+     Ciphers[]
+     EncryptionAlgorithms[]
+     CipherInit()
+     EncipherBlock()
+     DecipherBlock()
+*/
+
+// Cipher configuration
+static Cipher Ciphers[] =
+{
+//	  ID		Name			Block size	Key size	Key schedule size
+	{ AES,		"AES",			16,			32,			sizeof(aes_encrypt_ctx)+sizeof(aes_decrypt_ctx)	},
+	{ BLOWFISH,	"Blowfish",		8,			56,			4168											},
+	{ CAST,		"CAST5",		8,			16,			128												},
+	{ DES56,	"DES",			8,			7,			128												},
+	{ SERPENT,	"Serpent",		16,			32,			140*4											},
+	{ TRIPLEDES,"Triple DES",	8,			7*3,		128*3											},
+	{ TWOFISH,	"Twofish",		16,			32,			TWOFISH_KS										},
+	{ 0,		0,				0,			0,			0												}
+};
+
+// Encryption algorithm configuration
+static EncryptionAlgorithm EncryptionAlgorithms[] =
+{
+	//  Cipher(s)                     Mode
+	{ { 0,						0 } , 0			},	// (must be null)
+	{ { AES,					0 } , CBC		},	// AES
+	{ { BLOWFISH,				0 } , CBC		},	// Blowfish
+	{ { CAST,					0 } , CBC		},	// CAST5
+	{ { SERPENT,				0 } , CBC		},	// Serpent
+	{ { TRIPLEDES,				0 } , CBC		},	// Triple DES
+	{ { TWOFISH,				0 } , CBC		},	// Twofish
+	{ { BLOWFISH, AES,			0 } , INNER_CBC },	// AES-Blowfish
+	{ { SERPENT, BLOWFISH, AES,	0 } , INNER_CBC },	// AES-Blowfish-Serpent
+	{ { TWOFISH, AES,			0 } , OUTER_CBC },	// AES-Twofish
+	{ { SERPENT, TWOFISH, AES,	0 } , OUTER_CBC },	// AES-Twofish-Serpent
+	{ { AES, SERPENT,			0 } , OUTER_CBC },	// Serpent-AES
+	{ { AES, TWOFISH, SERPENT,	0 } , OUTER_CBC },	// Serpent-Twofish-AES
+	{ { SERPENT, TWOFISH,		0 } , OUTER_CBC },	// Twofish-Serpent
+	{ { 0,						0 } , 0			}	// (must be null)
+};
+
+
+void CipherInit (int cipher, unsigned char *key, unsigned char *ks)
+{
+	switch (cipher)
+	{
+	case BLOWFISH:
+		BF_set_key ((BF_KEY *)ks, CipherGetKeySize(BLOWFISH), key);
+		break;
+
+	case AES:
+		aes_encrypt_key(key, CipherGetKeySize(AES), (aes_encrypt_ctx *) ks);
+		aes_decrypt_key(key, CipherGetKeySize(AES), (aes_decrypt_ctx *) (ks + sizeof(aes_encrypt_ctx)));
+		break;
+
+	case DES56:
+		des_key_sched ((des_cblock *) key, (struct des_ks_struct *) ks);
+		break;
+
+	case CAST:
+		CAST_set_key((CAST_KEY *) ks, CipherGetKeySize(CAST), key);
+		break;
+
+	case SERPENT:
+		serpent_set_key (key, CipherGetKeySize(SERPENT) * 8, ks);
+		break;
+
+	case TRIPLEDES:
+		des_key_sched ((des_cblock *) key, (struct des_ks_struct *) ks);
+		des_key_sched ((des_cblock *) ((char*)(key)+8), (struct des_ks_struct *) (ks + CipherGetKeyScheduleSize (DES56)));
+		des_key_sched ((des_cblock *) ((char*)(key)+16), (struct des_ks_struct *) (ks + CipherGetKeyScheduleSize (DES56) * 2));
+		break;
+
+	case TWOFISH:
+		twofish_set_key ((TwofishInstance *)ks, (const u4byte *)key, CipherGetKeySize(TWOFISH) * 8);
+		break;
+
+	}
+}
+
+void EncipherBlock(int cipher, void *data, void *ks)
+{
+	switch (cipher)
+	{
+	case BLOWFISH:		BF_encrypt (data, ks); break;
+	case AES:			aes_encrypt (data, data, ks); break;
+	case DES56:			des_encrypt (data, ks, 1); break;
+	case CAST:			CAST_ecb_encrypt (data, data, ks, 1); break;
+	case SERPENT:		serpent_encrypt (data, data, ks); break;
+	case TRIPLEDES:		des_ecb3_encrypt (data, data, ks,
+						(void*)((char*) ks + CipherGetKeyScheduleSize (DES56)), (void*)((char*) ks + CipherGetKeyScheduleSize (DES56) * 2), 1); break;
+	case TWOFISH:		twofish_encrypt (ks, data, data); break;
+	}
+}
+
+void DecipherBlock(int cipher, void *data, void *ks)
+{
+	switch (cipher)
+	{
+	case BLOWFISH:	BF_decrypt (data, ks); break;
+	case AES:		aes_decrypt (data, data, (void *) ((char *) ks + sizeof(aes_encrypt_ctx))); break;
+	case DES56:		des_encrypt (data, ks, 0); break;
+	case CAST:		CAST_ecb_encrypt (data, data, ks,0); break;
+	case SERPENT:	serpent_decrypt (data, data, ks); break;
+	case TRIPLEDES:	des_ecb3_encrypt (data, data, ks,
+					(void*)((char*) ks + CipherGetKeyScheduleSize (DES56)),
+					(void*)((char*) ks + CipherGetKeyScheduleSize (DES56) * 2), 0); break;
+	case TWOFISH:	twofish_decrypt (ks, data, data); break;
+	}
+}
+
+// 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 0;
+}
+
+char *CipherGetName (int cipherId)
+{
+	return CipherGet (cipherId) -> Name;
+}
+
+int CipherGetBlockSize (int cipherId)
+{
+	return CipherGet (cipherId) -> BlockSize;
+}
+
+int CipherGetKeySize (int cipherId)
+{
+	return CipherGet (cipherId) -> KeySize;
+}
+
+int CipherGetKeyScheduleSize (int cipherId)
+{
+	return CipherGet (cipherId) -> KeyScheduleSize;
+}
+
+
+// Encryption algorithms support
+
+int EAGetFirst ()
+{
+	return 1;
+}
+
+// Returns number of EAs
+int EAGetCount (void)
+{
+	int ea, count = 0;
+
+	for (ea = EAGetFirst (); ea != 0; ea = EAGetNext (ea))
+	{
+		count++;
+	}
+	return count;
+}
+
+int EAGetNext (int previousEA)
+{
+	int id = previousEA + 1;
+	if (EncryptionAlgorithms[id].Ciphers[0] != 0) return id;
+	return 0;
+}
+
+void EAInit (int ea, unsigned char *key, unsigned char *ks)
+{
+	int i = 0, c;
+
+	for (c = EAGetFirstCipher (ea); c != 0; c = EAGetNextCipher (ea, c))
+	{
+		CipherInit (c, key, ks);
+
+		key += CipherGetKeySize (c);
+		ks += CipherGetKeyScheduleSize (c);
+	}
+}
+
+// Returns name of EA, cascaded cipher names are separated by hyphens
+char *EAGetName (char *buf, int ea)
+{
+	int i = EAGetLastCipher(ea);
+	strcpy (buf, CipherGetName (i));
+
+	while (i = EAGetPreviousCipher(ea, i))
+	{
+		strcat (buf, "-");
+		strcat (buf, CipherGetName (i));
+	}
+
+	return buf;
+}
+
+// Returns sum of key sizes of all EA ciphers
+int EAGetKeySize (int ea)
+{
+	int i = EAGetFirstCipher(ea);
+	int size = CipherGetKeySize (i);
+
+	while (i = EAGetNextCipher(ea, i))
+	{
+		size += CipherGetKeySize (i);
+	}
+
+	return size;
+}
+
+// Returns the mode of operation of the whole EA
+int EAGetMode (int ea)
+{
+	return (EncryptionAlgorithms[ea].Mode);
+}
+
+// Returns the name of the mode of operation of the whole EA
+char *EAGetModeName (char *name, int ea, BOOL capitalLetters)
+{
+	char eaName[100];
+
+	switch (EncryptionAlgorithms[ea].Mode)
+	{
+	case CBC:
+		EAGetName (eaName, ea);
+
+		if (strcmp (eaName, "Triple DES") == 0)
+			sprintf (name, "%s", capitalLetters ? "Outer-CBC" : "outer-CBC");
+		else
+			sprintf (name, "%s", "CBC");
+
+		break;
+
+	case OUTER_CBC:
+		strcpy (name, capitalLetters ? "Outer-CBC" : "outer-CBC");
+		break;
+
+	case INNER_CBC:
+		strcpy (name, capitalLetters ? "Inner-CBC" : "inner-CBC");
+		break;
+
+	default:
+		strcpy (name, "[unknown]");
+		break;
+	}
+	return name;
+}
+
+// Returns sum of key schedule sizes of all EA ciphers
+int EAGetKeyScheduleSize (int ea)
+{
+	int i = EAGetFirstCipher(ea);
+	int size = CipherGetKeyScheduleSize (i);
+
+	while (i = EAGetNextCipher(ea, i))
+	{
+		size += CipherGetKeyScheduleSize (i);
+	}
+
+	return size;
+}
+
+// Returns largest key needed by all EAs
+int EAGetLargestKey ()
+{
+	int ea, key = 0;
+
+	for (ea = EAGetFirst (); ea != 0 ; ea = EAGetNext (ea))
+	{
+		if (EAGetKeySize (ea) >= key)
+			key = EAGetKeySize (ea);
+	}
+
+	return key;
+}
+
+// Returns number of ciphers in EA
+int EAGetCipherCount (int ea)
+{
+	int i = 0;
+	while (EncryptionAlgorithms[ea].Ciphers[i++]);
+
+	return i - 1;
+}
+
+
+int EAGetFirstCipher (int ea)
+{
+	return EncryptionAlgorithms[ea].Ciphers[0];
+}
+
+int EAGetLastCipher (int ea)
+{
+	int c, i = 0;
+	while (c = EncryptionAlgorithms[ea].Ciphers[i++]);
+
+	return EncryptionAlgorithms[ea].Ciphers[i - 2];
+}
+
+int EAGetNextCipher (int ea, int previousCipherId)
+{
+	int c, i = 0;
+	while (c = EncryptionAlgorithms[ea].Ciphers[i++])
+	{
+		if (c == previousCipherId) 
+			return EncryptionAlgorithms[ea].Ciphers[i];
+	}
+
+	return 0;
+}
+
+int EAGetPreviousCipher (int ea, int previousCipherId)
+{
+	int c, i = 0;
+
+	if (EncryptionAlgorithms[ea].Ciphers[i++] == previousCipherId)
+		return 0;
+
+	while (c = EncryptionAlgorithms[ea].Ciphers[i++])
+	{
+		if (c == previousCipherId) 
+			return EncryptionAlgorithms[ea].Ciphers[i - 2];
+	}
+
+	return 0;
+}
+
+
+// Hash support functions
+
+char * get_hash_name (int pkcs5)
+{
+	switch (pkcs5)
+	{
+	case SHA1:		return "HMAC-SHA-1";
+	case RIPEMD160:	return "HMAC-RIPEMD-160";
+	default:		return "Unknown";
+	}
+}
+
+
 
 PCRYPTO_INFO
 crypto_open ()
@@ -21,7 +374,7 @@ crypto_open ()
 	if (cryptoInfo == NULL)
 		return NULL;
 
-	cryptoInfo->cipher = -1;
+	cryptoInfo->ea = -1;
 	return cryptoInfo;
 }
 
@@ -43,59 +396,470 @@ crypto_close (PCRYPTO_INFO cryptoInfo)
 	TCfree (cryptoInfo);
 }
 
-int
-get_block_size (int cipher)
+
+// Initializes IV and whitening values for sector encryption/decryption
+static void 
+InitSectorIVAndWhitening (unsigned __int64 secNo,
+	int blockSize,
+	unsigned long *iv,
+	unsigned __int64 *ivSeed,
+	unsigned long *whitening)
 {
-	if (cipher == AES)
-		return 16;
-	else
-		return 8;
-}
-
-int
-get_key_size (int cipher)
-{
-	if (cipher == DES56)
-		return 7;
-	else if (cipher == BLOWFISH)
-		return 56;
-	else if (cipher == AES)
-		return 32;
-	else if (cipher == TRIPLEDES)
-		return 21;
-	else if (cipher == CAST)
-		return 16;
-	else
+	unsigned __int64 iv64[4];
+	unsigned long *iv32 = (unsigned long *) iv64;
+
+	iv64[0] = ivSeed[0] ^ secNo;
+	iv64[1] = ivSeed[1] ^ secNo;
+	iv64[2] = ivSeed[2] ^ secNo;
+	if (blockSize == 16)
 	{
-		return 0;
+		iv64[3] = ivSeed[3] ^ secNo;
+	}
+
+	iv[0] = iv32[0];
+	iv[1] = iv32[1];
+
+	switch (blockSize)
+	{
+	case 16:
+
+		// 128-bit block
+
+		iv[2] = iv32[2];
+		iv[3] = iv32[3];
+
+		whitening[0] = crc32long ( &iv32[4] ) ^ crc32long ( &iv32[7] );
+		whitening[1] = crc32long ( &iv32[5] ) ^ crc32long ( &iv32[6] );
+		break;
+
+	case 8:
+
+		// 64-bit block
+
+		whitening[0] = crc32long ( &iv32[2] ) ^ crc32long ( &iv32[5] );
+		whitening[1] = crc32long ( &iv32[3] ) ^ crc32long ( &iv32[4] );
+		break;
 	}
 }
 
-char *
-get_cipher_name (int cipher)
+
+// EncryptBufferCBC
+//
+// data:		data to be encrypted
+// len:			number of bytes to encrypt (must be divisible by the largest cipher block size)
+// ks:			scheduled key
+// iv:			IV
+// whitening:	whitening constants
+// ea:			outer-CBC cascade ID (0 = CBC/inner-CBC)
+// cipher:		CBC/inner-CBC cipher ID (0 = outer-CBC)
+
+static void
+EncryptBufferCBC (unsigned long *data, 
+		 unsigned __int64 len,
+		 unsigned char *ks,
+		 unsigned long *iv,
+		 unsigned long *whitening,
+		 int ea,
+		 int cipher)
 {
-	if (cipher == BLOWFISH)
-		return "Blowfish";
-	if (cipher == AES)
-		return "AES";
-	else if (cipher == DES56)
-		return "DES";
-	else if (cipher == TRIPLEDES)
-		return "Triple-DES";
-	else if (cipher == CAST)
-		return "CAST";
-	else if (cipher == NONE)
-		return "None";
-	else
-		return "Unknown";
+	unsigned long bufIV[4];
+	unsigned __int64 i;
+	int blockSize = CipherGetBlockSize (ea != 0 ? EAGetFirstCipher (ea) : cipher);
+
+	//  IV
+	bufIV[0] = iv[0];
+	bufIV[1] = iv[1];
+	if (blockSize == 16)
+	{
+		bufIV[2] = iv[2];
+		bufIV[3] = iv[3];
+	}
+
+	// Encrypt each block
+	for (i = 0; i < len/blockSize; i++)
+	{
+		// CBC
+		data[0] ^= bufIV[0];
+		data[1] ^= bufIV[1];
+		if (blockSize == 16)
+		{
+			data[2] ^= bufIV[2];
+			data[3] ^= bufIV[3];
+		}
+
+		if (ea != 0)
+		{
+			// Outer-CBC
+			for (cipher = EAGetFirstCipher (ea); cipher != 0; cipher = EAGetNextCipher (ea, cipher))
+			{
+				EncipherBlock (cipher, data, ks);
+				ks += CipherGetKeyScheduleSize (cipher);
+			}
+			ks -= EAGetKeyScheduleSize (ea);
+		}
+		else
+		{
+			// CBC/inner-CBC
+			EncipherBlock (cipher, data, ks);
+		}
+
+		// CBC
+		bufIV[0] = data[0];
+		bufIV[1] = data[1];
+		if (blockSize == 16)
+		{
+			bufIV[2] = data[2];
+			bufIV[3] = data[3];
+		}
+
+		// Whitening
+		data[0] ^= whitening[0];
+		data[1] ^= whitening[1];
+		if (blockSize == 16)
+		{
+			data[2] ^= whitening[0];
+			data[3] ^= whitening[1];
+		}
+
+		data += blockSize / sizeof(data);
+	}
 }
 
-char * get_hash_name (int pkcs5)
+
+// DecryptBufferCBC
+//
+// data:		data to be decrypted
+// len:			number of bytes to decrypt (must be divisible by the largest cipher block size)
+// ks:			scheduled key
+// iv:			IV
+// whitening:	whitening constants
+// ea:			outer-CBC cascade ID (0 = CBC/inner-CBC)
+// cipher:		CBC/inner-CBC cipher ID (0 = outer-CBC)
+
+static void
+DecryptBufferCBC (unsigned long *data,
+		 unsigned __int64 len,
+		 unsigned char *ks,
+		 unsigned long *iv,
+ 		 unsigned long *whitening,
+		 int ea,
+		 int cipher)
 {
-	switch (pkcs5)
+	unsigned long bufIV[4];
+	unsigned __int64 i;
+	unsigned long ct[4];
+	int blockSize = CipherGetBlockSize (ea != 0 ? EAGetFirstCipher (ea) : cipher);
+
+	//  IV
+	bufIV[0] = iv[0];
+	bufIV[1] = iv[1];
+	if (blockSize == 16)
 	{
-	case SHA1:		return "HMAC-SHA-1";
-	case RIPEMD160:	return "HMAC-RIPEMD-160";
-	default:		return "Unknown";
+		bufIV[2] = iv[2];
+		bufIV[3] = iv[3];
+	}
+
+	// Decrypt each block
+	for (i = 0; i < len/blockSize; i++)
+	{
+		// Dewhitening
+		data[0] ^= whitening[0];
+		data[1] ^= whitening[1];
+		if (blockSize == 16)
+		{
+			data[2] ^= whitening[0];
+			data[3] ^= whitening[1];
+		}
+
+		// CBC
+		ct[0] = data[0];
+		ct[1] = data[1];
+		if (blockSize == 16)
+		{
+			ct[2] = data[2];
+			ct[3] = data[3];
+		}
+
+		if (ea != 0)
+		{
+			// Outer-CBC
+			ks += EAGetKeyScheduleSize (ea);
+			for (cipher = EAGetLastCipher (ea); cipher != 0; cipher = EAGetPreviousCipher (ea, cipher))
+			{
+				ks -= CipherGetKeyScheduleSize (cipher);
+				DecipherBlock (cipher, data, ks);
+			}
+		}
+		else
+		{
+			// CBC/inner-CBC
+			DecipherBlock (cipher, data, ks);
+		}
+
+		// CBC
+		data[0] ^= bufIV[0];
+		data[1] ^= bufIV[1];
+		bufIV[0] = ct[0];
+		bufIV[1] = ct[1];
+		if (blockSize == 16)
+		{
+			data[2] ^= bufIV[2];
+			data[3] ^= bufIV[3];
+			bufIV[2] = ct[2];
+			bufIV[3] = ct[3];
+		}
+
+		data += blockSize / sizeof(data);
 	}
 }
+
+
+// EncryptBuffer
+//
+// buf:			data to be encrypted
+// len:			number of bytes to encrypt; must be divisible by the block size (for cascaded
+//              ciphers divisible by the largest block size used within the cascade)
+// ks:			scheduled key
+// iv:			IV
+// whitening:	whitening constants
+// ea:			encryption algorithm
+
+void 
+EncryptBuffer (unsigned long *buf,
+			   unsigned __int64 len,
+			   unsigned char *ks,
+			   void *iv,
+			   void *whitening,
+			   int ea)
+{
+	unsigned __int64 *iv64 = (unsigned __int64 *) iv;
+	int cipher;
+
+	switch (EAGetMode(ea))
+	{
+	case CBC:
+	case INNER_CBC:
+
+		for (cipher = EAGetFirstCipher (ea); cipher != 0; cipher = EAGetNextCipher (ea, cipher))
+		{
+			EncryptBufferCBC (buf,
+				len,
+				ks,
+				(unsigned long *) iv,
+				(unsigned long *) whitening,
+				0,
+				cipher);
+
+			ks += CipherGetKeyScheduleSize (cipher);
+		}
+
+		break;
+
+	case OUTER_CBC:
+
+		EncryptBufferCBC (buf,
+			len,
+			ks,
+			(unsigned long *) iv,
+			(unsigned long *) whitening,
+			ea,
+			0);
+
+		break;
+	}
+}
+
+// EncryptSectors
+//
+// buf:			data to be encrypted
+// secNo:		sector number relative to volume start
+// noSectors:	number of sectors in buffer
+// ks:			scheduled key
+// iv:			IV
+// ea:			encryption algorithm
+
+void _cdecl 
+EncryptSectors (unsigned long *buf,
+		unsigned __int64 secNo,
+		unsigned __int64 noSectors,
+		unsigned char *ks,
+		void *iv,
+		int ea)
+{
+	unsigned __int64 *iv64 = (unsigned __int64 *) iv;
+	unsigned long sectorIV[4];
+	unsigned long secWhitening[2];
+	int cipher;
+
+	switch (EAGetMode(ea))
+	{
+	case CBC:
+	case INNER_CBC:
+
+		while (noSectors--)
+		{
+			for (cipher = EAGetFirstCipher (ea); cipher != 0; cipher = EAGetNextCipher (ea, cipher))
+			{
+				InitSectorIVAndWhitening (secNo, CipherGetBlockSize (cipher), sectorIV, iv64, secWhitening);
+
+				EncryptBufferCBC (buf,
+					SECTOR_SIZE,
+					ks,
+					sectorIV,
+					secWhitening,
+					0,
+					cipher);
+
+				ks += CipherGetKeyScheduleSize (cipher);
+			}
+			ks -= EAGetKeyScheduleSize (ea);
+			buf += SECTOR_SIZE / sizeof(buf);
+			secNo++;
+		}
+		break;
+
+	case OUTER_CBC:
+
+		while (noSectors--)
+		{
+			InitSectorIVAndWhitening (secNo, CipherGetBlockSize (EAGetFirstCipher (ea)), sectorIV, iv64, secWhitening);
+
+			EncryptBufferCBC (buf,
+				SECTOR_SIZE,
+				ks,
+				sectorIV,
+				secWhitening,
+				ea,
+				0);
+
+			buf += SECTOR_SIZE / sizeof(buf);
+			secNo++;
+		}
+		break;
+	}
+}
+
+// DecryptBuffer
+//
+// buf:			data to be decrypted
+// len:			number of bytes to decrypt; must be divisible by the block size (for cascaded
+//              ciphers divisible by the largest block size used within the cascade)
+// ks:			scheduled key
+// iv:			IV
+// whitening:	whitening constants
+// ea:			encryption algorithm
+void 
+DecryptBuffer (unsigned long *buf,
+		unsigned __int64 len,
+		unsigned char *ks,
+		void *iv,
+		void *whitening,
+		int ea)
+{
+	unsigned __int64 *iv64 = (unsigned __int64 *) iv;
+	int cipher;
+
+	switch (EAGetMode(ea))
+	{
+	case CBC:
+	case INNER_CBC:
+
+		ks += EAGetKeyScheduleSize (ea);
+		for (cipher = EAGetLastCipher (ea); cipher != 0; cipher = EAGetPreviousCipher (ea, cipher))
+		{
+			ks -= CipherGetKeyScheduleSize (cipher);
+
+			DecryptBufferCBC (buf,
+				len,
+				ks,
+				(unsigned long *) iv,
+				(unsigned long *) whitening,
+				0,
+				cipher);
+		}
+		break;
+
+	case OUTER_CBC:
+
+		DecryptBufferCBC (buf,
+			len,
+			ks,
+			(unsigned long *) iv,
+			(unsigned long *) whitening,
+			ea,
+			0);
+
+		break;
+	}
+}
+
+// DecryptSectors
+//
+// buf:			data to be decrypted
+// secNo:		sector number relative to volume start
+// noSectors:	number of sectors in buffer
+// ks:			scheduled key
+// iv:			IV
+// ea:			encryption algorithm
+
+void _cdecl 
+DecryptSectors (unsigned long *buf,
+		unsigned __int64 secNo,
+		unsigned __int64 noSectors,
+		unsigned char *ks,
+		void *iv,
+		int ea)
+{
+	unsigned __int64 *iv64 = (unsigned __int64 *) iv;
+	unsigned long sectorIV[4];
+	unsigned long secWhitening[2];
+	int cipher;
+
+	switch (EAGetMode(ea))
+	{
+	case CBC:
+	case INNER_CBC:
+
+		while (noSectors--)
+		{
+			ks += EAGetKeyScheduleSize (ea);
+			for (cipher = EAGetLastCipher (ea); cipher != 0; cipher = EAGetPreviousCipher (ea, cipher))
+			{
+				InitSectorIVAndWhitening (secNo, CipherGetBlockSize (cipher), sectorIV, iv64, secWhitening);
+
+				ks -= CipherGetKeyScheduleSize (cipher);
+
+				DecryptBufferCBC (buf,
+					SECTOR_SIZE,
+					ks,
+					sectorIV,
+					secWhitening,
+					0,
+					cipher);
+			}
+			buf += SECTOR_SIZE / sizeof(buf);
+			secNo++;
+		}
+		break;
+
+	case OUTER_CBC:
+
+		while (noSectors--)
+		{
+			InitSectorIVAndWhitening (secNo, CipherGetBlockSize (EAGetFirstCipher (ea)), sectorIV, iv64, secWhitening);
+
+			DecryptBufferCBC (buf,
+				SECTOR_SIZE,
+				ks,
+				sectorIV,
+				secWhitening,
+				ea,
+				0);
+
+			buf += SECTOR_SIZE / sizeof(buf);
+			secNo++;
+		}
+		break;
+	}
+}
+