/*

Legal Notice: Some portions of the source code contained in this file were

governed by the TrueCrypt License 3.0, also from the source code of

Encryption for the Masses 2.02a, which is Copyright (c) 1998-2000 Paul Le Roux

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

SelfTestsPassed = AutoTestAlgorithms();

// Enable device class filters and load boot arguments if the driver is set to start at system boot

if (NT_SUCCESS (TCReadRegistryKey (RegistryPath, L"Start", &startKeyValue)))

{

if (startKeyValue->Type == REG_DWORD && *((uint32 *) startKeyValue->Data) == SERVICE_BOOT_START)

for (j = 0; j < size / 8; j++)

{

memset (str,0,sizeof str);

{

if (m[i] > ' ' && m[i] <= '~')

str[i]=m[i];

return TCCompleteIrp (Irp, ntStatus, 0);

IoMarkIrpPending (Irp);

ExInterlockedInsertTailList (&Extension->ListEntry, &Irp->Tail.Overlay.ListEntry, &Extension->ListSpinLock);

KeReleaseSemaphore (&Extension->RequestSemaphore, IO_DISK_INCREMENT, 1, FALSE);

return STATUS_PENDING;

case IRP_MJ_FLUSH_BUFFERS:

RtlInitUnicodeString (&Win32NameString, dosname);

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

ntStatus = IoCreateDevice (

DriverObject,

sizeof (BOOL),

UCHAR volId[128], tmp[] = { 0,0 };

PMOUNTDEV_UNIQUE_ID outputBuffer = (PMOUNTDEV_UNIQUE_ID) Irp->AssociatedIrp.SystemBuffer;

tmp[0] = 'A' + (UCHAR) Extension->nDosDriveNo;

RtlStringCbCatA (volId, sizeof(volId),tmp);

outputBuffer->UniqueIdLength = (USHORT) strlen (volId);

outLength = (ULONG) (strlen (volId) + sizeof (USHORT));

{

Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;

Irp->IoStatus.Information = 0;

}

TCGetDosNameFromNumber (ntName, sizeof(ntName),Extension->nDosDriveNo, DeviceNamespaceDefault);

}

RtlCopyMemory ((PCHAR)outputBuffer->Name,ntUnicodeString.Buffer, ntUnicodeString.Length);

Irp->IoStatus.Status = STATUS_SUCCESS;

Irp->IoStatus.Information = outLength;

if (EnableExtendedIoctlSupport)

{

if (ValidateIOBufferSize (Irp, sizeof (STORAGE_PROPERTY_QUERY), ValidateInput))

PSTORAGE_PROPERTY_QUERY pStoragePropQuery = (PSTORAGE_PROPERTY_QUERY) Irp->AssociatedIrp.SystemBuffer;

STORAGE_QUERY_TYPE type = pStoragePropQuery->QueryType;

}

else

return TCCompleteIrp (Irp, STATUS_INVALID_DEVICE_REQUEST, 0);

break;

case IOCTL_DISK_GET_PARTITION_INFO:

if (ValidateIOBufferSize (Irp, sizeof (VERIFY_INFORMATION), ValidateInput))

{

HRESULT hResult;

PVERIFY_INFORMATION pVerifyInformation;

pVerifyInformation = (PVERIFY_INFORMATION) Irp->AssociatedIrp.SystemBuffer;

ullStartingOffset = (ULONGLONG) pVerifyInformation->StartingOffset.QuadPart;

&ullNewOffset);

if (hResult != S_OK)

Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;

{

IO_STATUS_BLOCK ioStatus;

PVOID buffer = TCalloc (max (pVerifyInformation->Length, PAGE_SIZE));

if (!buffer)

{

Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;

}

break;

case IOCTL_VOLUME_ONLINE:

Irp->IoStatus.Status = STATUS_SUCCESS;

Irp->IoStatus.Information = 0;

// Go through all volume types (e.g., normal, hidden)

for (volumeType = TC_VOLUME_TYPE_NORMAL;

volumeType < TC_VOLUME_TYPE_COUNT;

{

/* Read the volume header */

switch (volumeType)

IO_STATUS_BLOCK IoStatus;

LARGE_INTEGER offset;

byte readBuffer [TC_SECTOR_SIZE_BIOS];

if (!ValidateIOBufferSize (Irp, sizeof (GetSystemDriveConfigurationRequest), ValidateInputOutput))

break;

for (drive = MIN_MOUNTED_VOLUME_DRIVE_NUMBER; drive <= MAX_MOUNTED_VOLUME_DRIVE_NUMBER; ++drive)

{

PEXTENSION ListExtension;

ListDevice = GetVirtualVolumeDeviceObject (drive);

if (!ListDevice)

continue;

MOUNT_STRUCT *mount = (MOUNT_STRUCT *) Irp->AssociatedIrp.SystemBuffer;

if (mount->VolumePassword.Length > MAX_PASSWORD || mount->ProtectedHidVolPassword.Length > MAX_PASSWORD

|| mount->VolumePim < -1 || mount->VolumePim == INT_MAX

|| (mount->bTrueCryptMode != FALSE && mount->bTrueCryptMode != TRUE)

)

{

return TCCompleteIrp (Irp, STATUS_INVALID_DEVICE_REQUEST, 0);

}

#ifdef DEBUG

if (!NT_SUCCESS (Irp->IoStatus.Status))

{

}

InitializeObjectAttributes (&threadObjAttributes, NULL, OBJ_KERNEL_HANDLE, NULL, NULL);

status = PsCreateSystemThread (&threadHandle, THREAD_ALL_ACCESS, &threadObjAttributes, processHandle, NULL, threadProc, threadArg);

if (!NT_SUCCESS (status))

return status;

PsDereferenceImpersonationTokenD = MmGetSystemRoutineAddress (&name);

if (!PsDereferenceImpersonationTokenD)

TC_BUG_CHECK (STATUS_NOT_IMPLEMENTED);

# define PsDereferencePrimaryToken

# define PsDereferenceImpersonationToken PsDereferenceImpersonationTokenD

args.outputBufferSize = outputBufferSize;

KeInitializeEvent (&args.WorkItemCompletedEvent, SynchronizationEvent, FALSE);

KeWaitForSingleObject (&args.WorkItemCompletedEvent, Executive, KernelMode, FALSE, NULL);

IoFreeWorkItem (workItem);

return args.Status;

}

for (offset.QuadPart = sysLength.QuadPart; ; offset.QuadPart += TC_SECTOR_SIZE_BIOS)

{

status = TCReadDevice (driveDeviceObject, sectorBuffer, offset, TC_SECTOR_SIZE_BIOS);

if (NT_SUCCESS (status))

status = TCWriteDevice (driveDeviceObject, sectorBuffer, offset, TC_SECTOR_SIZE_BIOS);

return STATUS_INSUFFICIENT_RESOURCES;

stack = IoGetNextIrpStackLocation(irp);

stack->MajorFunction = IRP_MJ_FILE_SYSTEM_CONTROL;

stack->MinorFunction = IRP_MN_USER_FS_REQUEST;

stack->FileObject = fileObject;

NTSTATUS MountManagerMount (MOUNT_STRUCT *mount)

{

WCHAR arrVolume[256];

char buf[200];

PMOUNTMGR_TARGET_NAME in = (PMOUNTMGR_TARGET_NAME) buf;

NTSTATUS MountManagerUnmount (int nDosDriveNo)

{

char buf[256], out[300];

PMOUNTMGR_MOUNT_POINT in = (PMOUNTMGR_MOUNT_POINT) buf;

NTSTATUS MountDevice (PDEVICE_OBJECT DeviceObject, MOUNT_STRUCT *mount)

{

PDEVICE_OBJECT NewDeviceObject;

// Make sure the user is asking for a reasonable nDosDriveNo

&& IsDriveLetterAvailable (mount->nDosDriveNo, DeviceNamespaceDefault) // drive letter must not exist both locally and globally

&& IsDriveLetterAvailable (mount->nDosDriveNo, DeviceNamespaceGlobal)

)

FILE_FS_LABEL_INFORMATION* labelInfo = (FILE_FS_LABEL_INFORMATION*) TCalloc (labelInfoSize);

labelInfo->VolumeLabelLength = labelEffectiveLen * sizeof(WCHAR);

memcpy (labelInfo->VolumeLabel, mount->wszLabel, labelInfo->VolumeLabelLength);

if (STATUS_SUCCESS == ZwSetVolumeInformationFile (volumeHandle, &ioblock, labelInfo, labelInfoSize, FileFsLabelInformation))

{

mount->bDriverSetLabel = TRUE;

Dump ("Mount FAILURE TC code = 0x%08x\n", mount->nReturnCode);

TCDeleteDeviceObject (NewDeviceObject, NewExtension);

}

return STATUS_SUCCESS;

}

}

TCSleep (100);

}

}

{

// Volume cannot be opened => force dismount if allowed

if (!ignoreOpenFiles)

{

uint64 end1 = start1 + length1 - 1;

uint64 intersectEnd = (end1 <= end2) ? end1 : end2;

*intersectStart = (start1 >= start2) ? start1 : start2;

*intersectLength = (uint32) ((*intersectStart > intersectEnd) ? 0 : intersectEnd + 1 - *intersectStart);

if (*intersectLength == 0)

*intersectStart = start1;

}

ASSERT (!IoIsSystemThread (PsGetCurrentThread()));

InitializeObjectAttributes (&fileObjAttributes, objectFileName, OBJ_CASE_INSENSITIVE | OBJ_FORCE_ACCESS_CHECK | OBJ_KERNEL_HANDLE, NULL, NULL);

status = ZwCreateFile (&fileHandle,

readOnly ? GENERIC_READ : GENERIC_READ | GENERIC_WRITE,

&fileObjAttributes,

RtlInitUnicodeString (&valName, keyValueName);

status = ZwQueryValueKey (regKeyHandle, &valName, KeyValuePartialInformation, NULL, 0, &size);

if (!NT_SUCCESS (status) && status != STATUS_BUFFER_OVERFLOW && status != STATUS_BUFFER_TOO_SMALL)

{

ZwClose (regKeyHandle);

}

EnableHwEncryption ((flags & TC_DRIVER_CONFIG_DISABLE_HARDWARE_ENCRYPTION) ? FALSE : TRUE);

EnableExtendedIoctlSupport = (flags & TC_DRIVER_CONFIG_ENABLE_EXTENDED_IOCTL)? TRUE : FALSE;

}

else

if (!accessToken)

goto ret;

if (SeTokenIsAdmin (accessToken))

{

result = TRUE;