crypto.c

一个提供档案及Partition作加解密的程式支援以下的加密演算法AESBlowfishCAST5SerpentTriple DESTwofishAES-BlowfishAES-TwofishAES-

	case 8:

		// 64-bit block

		whitening[0] = crc32long ( &iv32[2] ) ^ crc32long ( &iv32[5] );
		whitening[1] = crc32long ( &iv32[3] ) ^ crc32long ( &iv32[4] );
		break;
	}
}


// 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)
{
	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);
	}
}


// 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)
{
	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)
	{
		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;
	}
}