/* Derived from source code of TrueCrypt 7.1a, which is Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed by the TrueCrypt License 3.0. Modifications and additions to the original source code (contained in this file) and all other portions of this file are Copyright (c) 2013-2017 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. */ #include "TCdefs.h" #include "Apidrvr.h" #include "Ntdriver.h" #include "DriveFilter.h" #include "EncryptedIoQueue.h" #include "EncryptionThreadPool.h" #include "Volumes.h" #include static void AcquireBufferPoolMutex (EncryptedIoQueue *queue) { NTSTATUS status; status = KeWaitForMutexObject (&queue->BufferPoolMutex, Executive, KernelMode, FALSE, NULL); if (!NT_SUCCESS (status)) TC_BUG_CHECK (status); } static void ReleaseBufferPoolMutex (EncryptedIoQueue *queue) { KeReleaseMutex (&queue->BufferPoolMutex, FALSE); } static void *GetPoolBuffer (EncryptedIoQueue *queue, ULONG requestedSize) { EncryptedIoQueueBuffer *buffer; void *bufferAddress = NULL; BOOL requestedSizePresentInPool = FALSE; while (TRUE) { AcquireBufferPoolMutex (queue); for (buffer = queue->FirstPoolBuffer; ; buffer = buffer->NextBuffer) { if (buffer && buffer->Size == requestedSize) { requestedSizePresentInPool = TRUE; if (!buffer->InUse) { // Reuse a free buffer buffer->InUse = TRUE; bufferAddress = buffer->Address; break; } } if (!buffer || !buffer->NextBuffer) { EncryptedIoQueueBuffer *newBuffer; if (requestedSizePresentInPool && !queue->StartPending) break; // Allocate a new buffer newBuffer = TCalloc (sizeof (EncryptedIoQueueBuffer)); if (!newBuffer) { bufferAddress = NULL; break; } bufferAddress = TCalloc (requestedSize); if (bufferAddress) { newBuffer->NextBuffer = NULL; newBuffer->Address = bufferAddress; newBuffer->Size = requestedSize; newBuffer->InUse = TRUE; if (!buffer) queue->FirstPoolBuffer = newBuffer; else buffer->NextBuffer = newBuffer; } else TCfree (newBuffer); break; } } ReleaseBufferPoolMutex (queue); if (bufferAddress || !requestedSizePresentInPool || queue->StartPending) break; KeWaitForSingleObject (&queue->PoolBufferFreeEvent, Executive, KernelMode, FALSE, NULL); } return bufferAddress; } static void ReleasePoolBuffer (EncryptedIoQueue *queue, void *address) { EncryptedIoQueueBuffer *buffer; AcquireBufferPoolMutex (queue); for (buffer = queue->FirstPoolBuffer; buffer != NULL; buffer = buffer->NextBuffer) { if (buffer->Address == address) { ASSERT (buffer->InUse); buffer->InUse = FALSE; break; } } ReleaseBufferPoolMutex (queue); KeSetEvent (&queue->PoolBufferFreeEvent, IO_DISK_INCREMENT, FALSE); } static void FreePoolBuffers (EncryptedIoQueue *queue) { EncryptedIoQueueBuffer *buffer; AcquireBufferPoolMutex (queue); for (buffer = queue->FirstPoolBuffer; buffer != NULL; ) { EncryptedIoQueueBuffer *nextBuffer = buffer->NextBuffer; ASSERT (!buffer->InUse || queue->StartPending); TCfree (buffer->Address); TCfree (buffer); buffer = nextBuffer; } queue->FirstPoolBuffer = NULL; ReleaseBufferPoolMutex (queue); } static void DecrementOutstandingIoCount (EncryptedIoQueue *queue) { if (InterlockedDecrement (&queue->OutstandingIoCount) == 0 && (queue->SuspendPending || queue->StopPending)) KeSetEvent (&queue->NoOutstandingIoEvent, IO_DISK_INCREMENT, FALSE); } static void OnItemCompleted (EncryptedIoQueueItem *item, BOOL freeItem) { DecrementOutstandingIoCount (item->Queue); IoReleaseRemoveLock (&item->Queue->RemoveLock, item->OriginalIrp); if (NT_SUCCESS (item->Status)) { if (item->Write) item->Queue->TotalBytesWritten += item->OriginalLength; else item->Queue->TotalBytesRead += item->OriginalLength; } if (freeItem) ReleasePoolBuffer (item->Queue, item); } static NTSTATUS CompleteOriginalIrp (EncryptedIoQueueItem *item, NTSTATUS status, ULONG_PTR information) { #ifdef TC_TRACE_IO_QUEUE Dump ("< %I64d [%I64d] %c status=%x info=%I64d\n", item->OriginalIrpOffset, GetElapsedTime (&item->Queue->LastPerformanceCounter), item->Write ? 'W' : 'R', status, (int64) information); #endif TCCompleteDiskIrp (item->OriginalIrp, status, information); item->Status = status; OnItemCompleted (item, TRUE); return status; } static void AcquireFragmentBuffer (EncryptedIoQueue *queue, uint8 *buffer) { NTSTATUS status = STATUS_INVALID_PARAMETER; if (buffer == queue->FragmentBufferA) { status = KeWaitForSingleObject (&queue->FragmentBufferAFreeEvent, Executive, KernelMode, FALSE, NULL); } else if (buffer == queue->FragmentBufferB) { status = KeWaitForSingleObject (&queue->FragmentBufferBFreeEvent, Executive, KernelMode, FALSE, NULL); } if (!NT_SUCCESS (status)) TC_BUG_CHECK (status); } static void ReleaseFragmentBuffer (EncryptedIoQueue *queue, uint8 *buffer) { if (buffer == queue->FragmentBufferA) { KeSetEvent (&queue->FragmentBufferAFreeEvent, IO_DISK_INCREMENT, FALSE); } else if (buffer == queue->FragmentBufferB) { KeSetEvent (&queue->FragmentBufferBFreeEvent, IO_DISK_INCREMENT, FALSE); } else { TC_BUG_CHECK (STATUS_INVALID_PARAMETER); } } BOOL UpdateBuffer( uint8* buffer, uint8* secRegion, uint64 bufferDiskOffset, uint32 bufferLength, BOOL doUpadte ) { uint64 intersectStart; uint32 intersectLength; uint32 i; DCS_DISK_ENTRY_LIST *DeList = (DCS_DISK_ENTRY_LIST*)(secRegion + 512); BOOL updated = FALSE; if (secRegion == NULL) return FALSE; for (i = 0; i < DeList->Count; ++i) { if (DeList->DE[i].Type == DE_Sectors) { GetIntersection( bufferDiskOffset, bufferLength, DeList->DE[i].Sectors.Start, DeList->DE[i].Sectors.Start + DeList->DE[i].Sectors.Length - 1, &intersectStart, &intersectLength ); if (intersectLength != 0) { updated = TRUE; if(doUpadte && buffer != NULL) { // Dump("Subst data\n"); memcpy( buffer + (intersectStart - bufferDiskOffset), secRegion + DeList->DE[i].Sectors.Offset + (intersectStart - DeList->DE[i].Sectors.Start), intersectLength ); } else { return TRUE; } } } } return updated; } static VOID CompletionThreadProc (PVOID threadArg) { EncryptedIoQueue *queue = (EncryptedIoQueue *) threadArg; PLIST_ENTRY listEntry; EncryptedIoRequest *request; UINT64_STRUCT dataUnit; if (IsEncryptionThreadPoolRunning()) KeSetPriorityThread (KeGetCurrentThread(), LOW_REALTIME_PRIORITY); while (!queue->ThreadExitRequested) { if (!NT_SUCCESS (KeWaitForSingleObject (&queue->CompletionThreadQueueNotEmptyEvent, Executive, KernelMode, FALSE, NULL))) continue; if (queue->ThreadExitRequested) break; while ((listEntry = ExInterlockedRemoveHeadList (&queue->CompletionThreadQueue, &queue->CompletionThreadQueueLock))) { request = CONTAINING_RECORD (listEntry, EncryptedIoRequest, CompletionListEntry); if (request->EncryptedLength > 0 && NT_SUCCESS (request->Item->Status)) { ASSERT (request->EncryptedOffset + request->EncryptedLength <= request->Offset.QuadPart + request->Length); dataUnit.Value = (request->Offset.QuadPart + request->EncryptedOffset) / ENCRYPTION_DATA_UNIT_SIZE; if (queue->CryptoInfo->bPartitionInInactiveSysEncScope) dataUnit.Value += queue->CryptoInfo->FirstDataUnitNo.Value; else if (queue->RemapEncryptedArea) dataUnit.Value += queue->Rem
/*
 Legal Notice: Some portions of the source code contained in this file were
 derived from the source code of Encryption for the Masses 2.02a, which is
 Copyright (c) 1998-2000 Paul Le Roux and which is governed by the 'License
 Agreement for Encryption for the Masses'. Modifications and additions to
 the original source code (contained in this file) and all other portions
 of this file are Copyright (c) 2003-2008 TrueCrypt Developers Association
 and are 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 "Tcdefs.h"
#include "Crc.h"
#include "Common/Endian.h"

#ifndef TC_MINIMIZE_CODE_SIZE

/* CRC polynomial 0x04c11db7 */
unsigned __int32 crc_32_tab[]=
{				
	0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
	0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
	0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
	0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
	0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
	0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
	0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
	0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
	0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
	0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
	0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
	0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
	0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
	0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
	0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
	0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
	0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
	0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
	0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
	0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
	0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
	0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
	0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
	0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
	0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
	0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
	0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
	0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
	0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
	0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
	0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
	0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
};

unsigned __int32 GetCrc32 (unsigned char *data, int length)
{
	unsigned __int32 CRC = 0xffffffff;

	while (length--)
	{
		CRC = (CRC >> 8) ^ crc_32_tab[ (CRC ^ *data++) & 0xFF ];
	}

	return CRC ^ 0xffffffff;
}

unsigned __int32 crc32int (unsigned __int32 *data)
{
	unsigned char *d = (unsigned char *) data;
	unsigned __int32 CRC = 0xffffffff;

	CRC = (CRC >> 8) ^ crc_32_tab[ (CRC ^ *d++) & 0xFF ];
	CRC = (CRC >> 8) ^ crc_32_tab[ (CRC ^ *d++) & 0xFF ];
	CRC = (CRC >> 8) ^ crc_32_tab[ (CRC ^ *d++) & 0xFF ];
	return (CRC >> 8) ^ crc_32_tab[ (CRC ^ *d) & 0xFF ] ^ 0xffffffff;
}

#if BYTE_ORDER == LITTLE_ENDIAN
#	define CRC_SELFTEST 0x6fcf9e13
#else
#	define CRC_SELFTEST 0xca87914d
#endif

BOOL crc32_selftests (void)
{
	int i;
	unsigned __int32 crc  = 0xffffffff;
	BOOL bSuccess = FALSE;

	for (i = 0; i < (int)sizeof(crc_32_tab); i++)
		crc = UPDC32 (((unsigned char *) crc_32_tab)[i], crc);

	bSuccess = CRC_SELFTEST == (crc ^ 0xffffffff);

	bSuccess &= GetCrc32 ((unsigned char *)crc_32_tab, sizeof crc_32_tab) == CRC_SELFTEST;

	return bSuccess;
}

#else // TC_MINIMIZE_CODE_SIZE

unsigned __int32 GetCrc32 (unsigned char *data, int length)
{
    unsigned __int32 r = 0xFFFFFFFFUL;
	int i, b;

    for (i = 0; i < length; ++i)
    {
        r ^= data[i];
        for (b = 0; b < 8; ++b)
        {
            if ((unsigned __int8) r & 1)
                r = (r >> 1) ^ 0xEDB88320UL;
            else
                r >>= 1;
        }
    }

	return r ^ 0xFFFFFFFFUL;
}

BOOL crc32_selftests ()
{
	unsigned __int8 testData[32];
	unsigned __int8 i;

	for (i = 0; i < sizeof (testData); ++i)
		testData[i] = i;

	return GetCrc32 (testData, sizeof (testData)) == 0x91267E8AUL;
}

#endif // TC_MINIMIZE_CODE_SIZE