#endif // !_MSC_VER

#define TC_INT_TYPES_DEFINED

// Integer types required by Cryptolib

typedef unsigned __int8 uint_8t;

typedef unsigned __int16 uint_16t;

typedef unsigned __int32 uint_32t;

#ifndef TC_NO_COMPILER_INT64

typedef uint64 uint_64t;

#endif

typedef union

{

struct

{

unsigned __int32 LowPart;

unsigned __int32 HighPart;

};

#ifndef TC_NO_COMPILER_INT64

uint64 Value;

#endif

} UINT64_STRUCT;

#ifdef TC_WINDOWS_BOOT

# ifdef __cplusplus

extern "C"

# endif

void ThrowFatalException (int line);

# define TC_THROW_FATAL_EXCEPTION ThrowFatalException (__LINE__)

#elif defined (TC_WINDOWS_DRIVER)

#else

# define TC_THROW_FATAL_EXCEPTION *(char *) 0 = 0

#endif

#ifdef TC_WINDOWS_DRIVER

#include <ntifs.h>

#include <ntddk.h> /* Standard header file for nt drivers */

#include <ntdddisk.h> /* Standard I/O control codes */

#define DEVICE_DRIVER

#ifndef BOOL

typedef int BOOL;

#endif

#ifndef TRUE

#define TRUE 1

#endif

#ifndef FALSE

#define FALSE !TRUE

#endif

#else /* !TC_WINDOWS_DRIVER */

#define TCalloc malloc

#define TCfree free

#ifdef _WIN32

#ifndef TC_LOCAL_WIN32_WINNT_OVERRIDE

# undef _WIN32_WINNT

# define _WIN32_WINNT 0x0501 /* Does not apply to the driver */

#endif

#include <windows.h> /* Windows header */

#include <commctrl.h> /* The common controls */

#include <process.h> /* Process control */

#include <winioctl.h>

#include <stdio.h> /* For sprintf */

#endif /* _WIN32 */

NTSTATUS DriveFilterAddDevice (PDRIVER_OBJECT driverObject, PDEVICE_OBJECT pdo)

{

DriveFilterExtension *Extension;

NTSTATUS status;

PDEVICE_OBJECT filterDeviceObject = NULL;

PDEVICE_OBJECT attachedDeviceObject;

Dump ("DriveFilterAddDevice pdo=%p\n", pdo);

attachedDeviceObject = IoGetAttachedDeviceReference (pdo);

status = IoCreateDevice (driverObject, sizeof (DriveFilterExtension), NULL, attachedDeviceObject->DeviceType, 0, FALSE, &filterDeviceObject);

ObDereferenceObject (attachedDeviceObject);

if (!NT_SUCCESS (status))

{

filterDeviceObject = NULL;

goto err;

}

Extension = (DriveFilterExtension *) filterDeviceObject->DeviceExtension;

memset (Extension, 0, sizeof (DriveFilterExtension));

Extension->LowerDeviceObject = IoAttachDeviceToDeviceStack (filterDeviceObject, pdo); // IoAttachDeviceToDeviceStackSafe() is not required in AddDevice routine and is also unavailable on Windows 2000 SP4

if (!Extension->LowerDeviceObject)

{

status = STATUS_DEVICE_REMOVED;

goto err;

}

Extension->IsDriveFilterDevice = Extension->Queue.IsFilterDevice = TRUE;

Extension->DeviceObject = Extension->Queue.DeviceObject = filterDeviceObject;

Extension->Pdo = pdo;

Extension->Queue.LowerDeviceObject = Extension->LowerDeviceObject;

Extension->ConfiguredEncryptedAreaStart = -1;

Extension->ConfiguredEncryptedAreaEnd = -1;

Extension->Queue.EncryptedAreaStart = -1;

Extension->Queue.EncryptedAreaEnd = -1;

Extension->Queue.EncryptedAreaEndUpdatePending = FALSE;

filterDeviceObject->Flags |= Extension->LowerDeviceObject->Flags & (DO_DIRECT_IO | DO_BUFFERED_IO | DO_POWER_PAGABLE);

filterDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;

DeviceFilterActive = TRUE;

return status;

err:

if (filterDeviceObject)

{

if (Extension->LowerDeviceObject)

IoDetachDevice (Extension->LowerDeviceObject);

IoDeleteDevice (filterDeviceObject);

}

return status;

}

static void DismountDrive (DriveFilterExtension *Extension, BOOL stopIoQueue)

{

Dump ("Dismounting drive\n");

ASSERT (Extension->DriveMounted);

if (stopIoQueue && EncryptedIoQueueIsRunning (&Extension->Queue))

EncryptedIoQueueStop (&Extension->Queue);

crypto_close (Extension->Queue.CryptoInfo);

Dump ("Creating device nt=%ls dos=%ls\n", ntname, dosname);

ntStatus = IoCreateDevice (

DriverObject, /* Our Driver Object */

sizeof (EXTENSION), /* Size of state information */

&ntUnicodeString, /* Device name "\Device\Name" */

FILE_DEVICE_DISK, /* Device type */

devChars, /* Device characteristics */

FALSE, /* Exclusive device */

ppDeviceObject); /* Returned ptr to Device Object */

if (!NT_SUCCESS (ntStatus))

{

Dump ("TCCreateDeviceObject NTSTATUS = 0x%08x END\n", ntStatus);

return ntStatus;/* Failed to create DeviceObject */

}

/* Initialize device object and extension. */

(*ppDeviceObject)->Flags |= DO_DIRECT_IO;

(*ppDeviceObject)->StackSize += 6; // Reduce occurrence of NO_MORE_IRP_STACK_LOCATIONS bug check caused by buggy drivers

/* Setup the device extension */

Extension = (PEXTENSION) (*ppDeviceObject)->DeviceExtension;

memset (Extension, 0, sizeof (EXTENSION));

Extension->IsVolumeDevice = TRUE;

Extension->nDosDriveNo = mount->nDosDriveNo;

Extension->bRemovable = mount->bMountRemovable;

Extension->PartitionInInactiveSysEncScope = mount->bPartitionInInactiveSysEncScope;

Extension->SystemFavorite = mount->SystemFavorite;

KeInitializeEvent (&Extension->keCreateEvent, SynchronizationEvent, FALSE);

KeInitializeSemaphore (&Extension->RequestSemaphore, 0L, MAXLONG);

KeInitializeSpinLock (&Extension->ListSpinLock);

InitializeListHead (&Extension->ListEntry);

VirtualVolumeDeviceObjects[mount->nDosDriveNo] = *ppDeviceObject;

Dump ("TCCreateDeviceObject STATUS_SUCCESS END\n");

return STATUS_SUCCESS;

}

BOOL RootDeviceControlMutexAcquireNoWait ()

{

NTSTATUS status;

LARGE_INTEGER timeout;

timeout.QuadPart = 0;

status = KeWaitForMutexObject (&RootDeviceControlMutex, Executive, KernelMode, FALSE, &timeout);

return NT_SUCCESS (status) && status != STATUS_TIMEOUT;

}

void RootDeviceControlMutexRelease ()

{

KeReleaseMutex (&RootDeviceControlMutex, FALSE);

}

NTSTATUS ProcessVolumeDeviceControlIrp (PDEVICE_OBJECT DeviceObject, PEXTENSION Extension, PIRP Irp)

{

PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation (Irp);

switch (irpSp->Parameters.DeviceIoControl.IoControlCode)

{

case IOCTL_MOUNTDEV_QUERY_DEVICE_NAME:

if (!ValidateIOBufferSize (Irp, sizeof (MOUNTDEV_NAME), ValidateOutput))

NTSTATUS TCFsctlCall (PFILE_OBJECT fileObject, LONG IoControlCode, void *InputBuffer, int InputBufferSize, void *OutputBuffer, int OutputBufferSize);

NTSTATUS CreateDriveLink (int nDosDriveNo);

NTSTATUS RemoveDriveLink (int nDosDriveNo);

NTSTATUS MountManagerMount (MOUNT_STRUCT *mount);

NTSTATUS MountManagerUnmount (int nDosDriveNo);

NTSTATUS MountDevice (PDEVICE_OBJECT deviceObject, MOUNT_STRUCT *mount);

NTSTATUS UnmountDevice (UNMOUNT_STRUCT *unmountRequest, PDEVICE_OBJECT deviceObject, BOOL ignoreOpenFiles);

NTSTATUS UnmountAllDevices (UNMOUNT_STRUCT *unmountRequest, BOOL ignoreOpenFiles);

NTSTATUS SymbolicLinkToTarget (PWSTR symlinkName, PWSTR targetName, USHORT maxTargetNameLength);

BOOL RootDeviceControlMutexAcquireNoWait ();

void RootDeviceControlMutexRelease ();

BOOL RegionsOverlap (unsigned __int64 start1, unsigned __int64 end1, unsigned __int64 start2, unsigned __int64 end2);

void GetIntersection (uint64 start1, uint32 length1, uint64 start2, uint64 end2, uint64 *intersectStart, uint32 *intersectLength);

NTSTATUS TCCompleteIrp (PIRP irp, NTSTATUS status, ULONG_PTR information);

NTSTATUS TCCompleteDiskIrp (PIRP irp, NTSTATUS status, ULONG_PTR information);

NTSTATUS ProbeRealDriveSize (PDEVICE_OBJECT driveDeviceObject, LARGE_INTEGER *driveSize);

BOOL UserCanAccessDriveDevice ();

size_t GetCpuCount ();

void EnsureNullTerminatedString (wchar_t *str, size_t maxSizeInBytes);

void *AllocateMemoryWithTimeout (size_t size, int retryDelay, int timeout);

BOOL IsDriveLetterAvailable (int nDosDriveNo);

NTSTATUS TCReadRegistryKey (PUNICODE_STRING keyPath, wchar_t *keyValueName, PKEY_VALUE_PARTIAL_INFORMATION *keyData);

NTSTATUS TCWriteRegistryKey (PUNICODE_STRING keyPath, wchar_t *keyValueName, ULONG keyValueType, void *valueData, ULONG valueSize);

BOOL IsVolumeClassFilterRegistered ();

NTSTATUS ReadRegistryConfigFlags (BOOL driverEntry);

NTSTATUS WriteRegistryConfigFlags (uint32 flags);

BOOL ValidateIOBufferSize (PIRP irp, size_t requiredBufferSize, ValidateIOBufferSizeType type);

NTSTATUS GetDeviceSectorSize (PDEVICE_OBJECT deviceObject, ULONG *bytesPerSector);

NTSTATUS ZeroUnreadableSectors (PDEVICE_OBJECT deviceObject, LARGE_INTEGER startOffset, ULONG size, uint64 *zeroedSectorCount);

NTSTATUS ReadDeviceSkipUnreadableSectors (PDEVICE_OBJECT deviceObject, byte *buffer, LARGE_INTEGER startOffset, ULONG size, uint64 *badSectorCount);

BOOL IsVolumeAccessibleByCurrentUser (PEXTENSION volumeDeviceExtension);

void GetElapsedTimeInit (LARGE_INTEGER *lastPerfCounter);

int64 GetElapsedTime (LARGE_INTEGER *lastPerfCounter);

BOOL IsOSAtLeast (OSVersionEnum reqMinOS);

#endif // TC_HEADER_NTDRIVER

NTSTATUS VolumeFilterAddDevice (PDRIVER_OBJECT driverObject, PDEVICE_OBJECT pdo)

{

VolumeFilterExtension *Extension;

NTSTATUS status;

PDEVICE_OBJECT filterDeviceObject = NULL;

PDEVICE_OBJECT attachedDeviceObject;

Dump ("VolumeFilterAddDevice pdo=%p\n", pdo);

attachedDeviceObject = IoGetAttachedDeviceReference (pdo);

status = IoCreateDevice (driverObject, sizeof (VolumeFilterExtension), NULL, attachedDeviceObject->DeviceType, 0, FALSE, &filterDeviceObject);

ObDereferenceObject (attachedDeviceObject);

if (!NT_SUCCESS (status))

{

filterDeviceObject = NULL;

goto err;

}

Extension = (VolumeFilterExtension *) filterDeviceObject->DeviceExtension;

memset (Extension, 0, sizeof (VolumeFilterExtension));

Extension->LowerDeviceObject = IoAttachDeviceToDeviceStack (filterDeviceObject, pdo); // IoAttachDeviceToDeviceStackSafe() is not required in AddDevice routine and is also unavailable on Windows 2000 SP4

if (!Extension->LowerDeviceObject)

{

status = STATUS_DEVICE_REMOVED;

goto err;

}

Extension->IsVolumeFilterDevice = TRUE;

Extension->DeviceObject = filterDeviceObject;

Extension->Pdo = pdo;

filterDeviceObject->Flags |= Extension->LowerDeviceObject->Flags & (DO_DIRECT_IO | DO_BUFFERED_IO | DO_POWER_PAGABLE);

filterDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;

return status;

err:

if (filterDeviceObject)

{

if (Extension->LowerDeviceObject)

IoDetachDevice (Extension->LowerDeviceObject);

IoDeleteDevice (filterDeviceObject);

}

return status;

}

static NTSTATUS PassIrp (PDEVICE_OBJECT deviceObject, PIRP irp)

{

IoSkipCurrentIrpStackLocation (irp);

return IoCallDriver (deviceObject, irp);

}

static NTSTATUS PassFilteredIrp (PDEVICE_OBJECT deviceObject, PIRP irp, PIO_COMPLETION_ROUTINE completionRoutine, PVOID completionRoutineArg)

{

IoCopyCurrentIrpStackLocationToNext (irp);

if (completionRoutine)

IoSetCompletionRoutine (irp, completionRoutine, completionRoutineArg, TRUE, TRUE, TRUE);

return IoCallDriver (deviceObject, irp);

}