:: Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

:: by the TrueCrypt License 3.0.

::

:: 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

set BUILD_ALT_DIR=%TC_BUILD_ALT_DIR%

build %TC_BUILD_OPTS% -w -nmake /S -nmake /C 2>build_errors.log 1>&2

if errorlevel 1 (

type build_errors.log

type build_errors_asm.log 2>NUL:

)

shift

goto build_dirs

:done

popd

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

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

Extension = (DriveFilterExtension *) filterDeviceObject->DeviceExtension;

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

if (!NT_SUCCESS (status))

{

goto err;

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

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

Extension->Pdo = pdo;

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

IoInitializeRemoveLock (&Extension->Queue.RemoveLock, 'LRCV', 0, 0);

{

Dump ("Dismounting drive\n");

ASSERT (Extension->DriveMounted);

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

EncryptedIoQueueStop (&Extension->Queue);

// TC_BOOT_SECTOR_USER_CONFIG_OFFSET = 438

//

// we have: TC_BOOT_SECTOR_USER_MESSAGE_OFFSET = TC_BOOT_SECTOR_OUTER_VOLUME_BAK_HEADER_CRC_OFFSET + TC_BOOT_SECTOR_OUTER_VOLUME_BAK_HEADER_CRC_SIZE

WHIRLPOOL_init (&whirlpool);

sha512_begin (&sha2);

// read the first 512 bytes

if (BootArgs.CryptoInfoLength > 0)

{

cryptoInfoAddress.QuadPart = (BootLoaderSegment << 4) + BootArgs.CryptoInfoOffset;

#ifdef DEBUG

Dump ("Wiping memory %x %d\n", cryptoInfoAddress.LowPart, BootArgs.CryptoInfoLength);

// calculate Fingerprint

ComputeBootLoaderFingerprint (Extension->LowerDeviceObject, header);

if (Extension->Queue.CryptoInfo->hiddenVolume)

{

int64 hiddenPartitionOffset = BootArgs.HiddenSystemPartitionStart;

Dump ("Hidden volume start offset = %I64d\n", Extension->Queue.CryptoInfo->EncryptedAreaStart.Value + hiddenPartitionOffset);

Extension->HiddenSystem = TRUE;

Extension->Queue.RemapEncryptedArea = TRUE;

Extension->Queue.RemappedAreaOffset = hiddenPartitionOffset + Extension->Queue.CryptoInfo->EncryptedAreaStart.Value - BootArgs.DecoySystemPartitionStart;

Extension->Queue.RemappedAreaDataUnitOffset = Extension->Queue.CryptoInfo->EncryptedAreaStart.Value / ENCRYPTION_DATA_UNIT_SIZE - BootArgs.DecoySystemPartitionStart / ENCRYPTION_DATA_UNIT_SIZE;

Extension->Queue.CryptoInfo->EncryptedAreaStart.Value = BootArgs.DecoySystemPartitionStart;

if (Extension->Queue.CryptoInfo->VolumeSize.Value > hiddenPartitionOffset - BootArgs.DecoySystemPartitionStart)

TC_THROW_FATAL_EXCEPTION;

}

status = SendDeviceIoControlRequest (Extension->LowerDeviceObject, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, &BootDriveLength, sizeof (BootDriveLength));

if (!NT_SUCCESS (status))

{

Dump ("Failed to get drive length - error %x\n", status);

}

else

Extension->Queue.MaxReadAheadOffset = BootDriveLength;

status = EncryptedIoQueueStart (&Extension->Queue);

if (!NT_SUCCESS (status))

TC_BUG_CHECK (status);

Dump ("Saving: ConfiguredEncryptedAreaStart=%I64d (%I64d) ConfiguredEncryptedAreaEnd=%I64d (%I64d)\n", Extension->ConfiguredEncryptedAreaStart / 1024 / 1024, Extension->ConfiguredEncryptedAreaStart, Extension->ConfiguredEncryptedAreaEnd / 1024 / 1024, Extension->ConfiguredEncryptedAreaEnd);

Dump ("Saving: EncryptedAreaStart=%I64d (%I64d) EncryptedAreaEnd=%I64d (%I64d)\n", Extension->Queue.EncryptedAreaStart / 1024 / 1024, Extension->Queue.EncryptedAreaStart, Extension->Queue.EncryptedAreaEnd / 1024 / 1024, Extension->Queue.EncryptedAreaEnd);

if (Extension->Queue.EncryptedAreaStart == -1 || Extension->Queue.EncryptedAreaEnd == -1

|| Extension->Queue.EncryptedAreaEnd <= Extension->Queue.EncryptedAreaStart)

{

}

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

KeWaitForSingleObject (&Extension->MountWorkItemCompletedEvent, Executive, KernelMode, FALSE, NULL);

IoFreeWorkItem (workItem);

if (Extension->BootDrive)

{

status = EncryptedIoQueueAddIrp (&Extension->Queue, Irp);

if (status != STATUS_PENDING)

TCCompleteDiskIrp (Irp, status, 0);

{

Dump ("Header reopened\n");

ComputeBootLoaderFingerprint (BootDriveFilterExtension->LowerDeviceObject, header);

BootDriveFilterExtension->Queue.CryptoInfo->header_creation_time = BootDriveFilterExtension->HeaderCryptoInfo->header_creation_time;

BootDriveFilterExtension->Queue.CryptoInfo->pkcs5 = BootDriveFilterExtension->HeaderCryptoInfo->pkcs5;

BootDriveFilterExtension->Queue.CryptoInfo->noIterations = BootDriveFilterExtension->HeaderCryptoInfo->noIterations;

if (writeB)

return (*OriginalHiberDriverWriteFunctionsB[filterNumber]) (writeOffset, encryptedDataMdl);

return (*OriginalHiberDriverWriteFunctionsA[filterNumber]) (arg0WriteA, writeOffset, encryptedDataMdl, arg3WriteA);

}

byte *wipeBuffer = NULL;

byte wipeRandChars[TC_WIPE_RAND_CHAR_COUNT];

byte wipeRandCharsUpdate[TC_WIPE_RAND_CHAR_COUNT];

KIRQL irql;

NTSTATUS status;

// wipeRandCharsUpdate instead of relying on uninitialized stack memory

LARGE_INTEGER iSeed;

KeQuerySystemTime( &iSeed );

burn (digest, SHA512_DIGESTSIZE);

burn (&tctx, sizeof (tctx));

}

burn (&iSeed, sizeof(iSeed));

SetupResult = STATUS_UNSUCCESSFUL;

}

EncryptedIoQueueResumeFromHold (&Extension->Queue);

Dump ("EncryptedAreaStart=%I64d\n", Extension->Queue.EncryptedAreaStart);

Dump ("EncryptedAreaEnd=%I64d\n", Extension->Queue.EncryptedAreaEnd);

Dump ("ConfiguredEncryptedAreaStart=%I64d\n", Extension->ConfiguredEncryptedAreaStart);

}

EncryptDataUnits (wipeBuffer, &dataUnit, setupBlockSize / ENCRYPTION_DATA_UNIT_SIZE, Extension->Queue.CryptoInfo);

}

status = TCWriteDevice (BootDriveFilterExtension->LowerDeviceObject, wipeBuffer, offset, setupBlockSize);

}

}

}

}

else

SetupInProgress = TRUE;

status = TCStartThread (SetupThreadProc, DeviceObject, &EncryptionSetupThread);

if (!NT_SUCCESS (status))

SetupInProgress = FALSE;

bootEncStatus->HiddenSysLeakProtectionCount = HiddenSysLeakProtectionCount;

bootEncStatus->HiddenSystem = Extension->HiddenSystem;

if (Extension->HiddenSystem)

bootEncStatus->HiddenSystemPartitionStart = BootArgs.HiddenSystemPartitionStart;

}

irp->IoStatus.Information = 0;

if (BootArgsValid && BootDriveFound && BootDriveFilterExtension && BootDriveFilterExtension->DriveMounted && BootDriveFilterExtension->HeaderCryptoInfo)

{

/* compute the fingerprint again and check if it is the same as the one retrieved during boot */

char *header = TCalloc (TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE);

}

else

{

}

}

}

DecoySystemWipeResult = STATUS_INSUFFICIENT_RESOURCES;

goto ret;

}

wipeRandBuffer = TCalloc (TC_ENCRYPTION_SETUP_IO_BLOCK_SIZE);

if (!wipeRandBuffer)

{

}

memcpy (wipeCryptoInfo->k2, WipeDecoyRequest.WipeKey + EAGetKeySize (ea), EAGetKeySize (ea));

if (!EAInitMode (wipeCryptoInfo))

{

DecoySystemWipeResult = STATUS_INVALID_PARAMETER;

burn (WipeDecoyRequest.WipeKey, sizeof (WipeDecoyRequest.WipeKey));

offset.QuadPart = Extension->ConfiguredEncryptedAreaStart;

Dump ("Wiping decoy system: start offset = %I64d\n", offset.QuadPart);

while (!DecoySystemWipeThreadAbortRequested)

DecoySystemWipeInProgress = TRUE;

status = TCStartThread (DecoySystemWipeThreadProc, DeviceObject, &DecoySystemWipeThread);

if (!NT_SUCCESS (status))

DecoySystemWipeInProgress = FALSE;

}

else

wipeStatus->WipedAreaEnd = DecoySystemWipedAreaEnd;

irp->IoStatus.Information = sizeof (DecoySystemWipeStatus);

irp->IoStatus.Status = STATUS_SUCCESS;

}

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

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

// TEXTINCLUDE

//

BEGIN

"resource.h\0"

END

BEGIN

"#include ""afxres.h""\r\n"

"\0"

END

BEGIN

"\r\n"

"\0"

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

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

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

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

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

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

{

EncryptedIoQueueBuffer *buffer;

AcquireBufferPoolMutex (queue);

for (buffer = queue->FirstPoolBuffer; buffer != NULL; buffer = buffer->NextBuffer)

{

if (buffer->Address == address)

{

InterlockedDecrement (&queue->IoThreadPendingRequestCount);

request = CONTAINING_RECORD (listEntry, EncryptedIoRequest, ListEntry);

#ifdef TC_TRACE_IO_QUEUE

Dump ("%c %I64d [%I64d] roff=%I64d rlen=%d\n", request->Item->Write ? 'W' : 'R', request->Item->OriginalIrpOffset.QuadPart, GetElapsedTime (&queue->LastPerformanceCounter), request->Offset.QuadPart, request->Length);

#endif

{

PIRP irp = CONTAINING_RECORD (listEntry, IRP, Tail.Overlay.ListEntry);

PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation (irp);

if (queue->Suspended)

KeWaitForSingleObject (&queue->QueueResumedEvent, Executive, KernelMode, FALSE, NULL);

if (item->OriginalLength == 0

|| (item->OriginalLength & (ENCRYPTION_DATA_UNIT_SIZE - 1)) != 0

|| (item->OriginalOffset.QuadPart & (ENCRYPTION_DATA_UNIT_SIZE - 1)) != 0

( (S_OK != ULongLongAdd(item->OriginalOffset.QuadPart, item->OriginalLength, &addResult))

|| (addResult > (ULONGLONG) queue->VirtualDeviceLength)

)

if (queue->CryptoInfo->hiddenVolume)

hResult = ULongLongAdd(item->OriginalOffset.QuadPart, queue->CryptoInfo->hiddenVolumeOffset, &addResult);

else

if (hResult != S_OK)

{

{

// If there has already been a write operation denied in order to protect the

// hidden volume (since the volume mount time)

{

// Do not allow writing to this volume anymore. This is to fake a complete volume

// or system failure (otherwise certain kinds of inconsistency within the file

while (dataRemaining > 0)

{

BOOL isLastFragment = dataRemaining <= TC_ENC_IO_QUEUE_MAX_FRAGMENT_SIZE;

ULONG dataFragmentLength = isLastFragment ? dataRemaining : TC_ENC_IO_QUEUE_MAX_FRAGMENT_SIZE;

activeFragmentBuffer = (activeFragmentBuffer == queue->FragmentBufferA ? queue->FragmentBufferB : queue->FragmentBufferA);

dataUnit.Value += queue->CryptoInfo->FirstDataUnitNo.Value;

else if (queue->RemapEncryptedArea)

dataUnit.Value += queue->RemappedAreaDataUnitOffset;

EncryptDataUnits (activeFragmentBuffer + request->EncryptedOffset, &dataUnit, request->EncryptedLength / ENCRYPTION_DATA_UNIT_SIZE, queue->CryptoInfo);

}

}

ExInterlockedInsertTailList (&queue->MainThreadQueue, &irp->Tail.Overlay.ListEntry, &queue->MainThreadQueueLock);

KeSetEvent (&queue->MainThreadQueueNotEmptyEvent, IO_DISK_INCREMENT, FALSE);

return STATUS_PENDING;

err:

ASSERT (!queue->Suspended);

queue->SuspendPending = TRUE;

while (TRUE)

{

while (InterlockedExchangeAdd (&queue->OutstandingIoCount, 0) > 0)

NTSTATUS EncryptedIoQueueResumeFromHold (EncryptedIoQueue *queue)

{

ASSERT (queue->Suspended);

queue->Suspended = FALSE;

KeSetEvent (&queue->QueueResumedEvent, IO_DISK_INCREMENT, FALSE);

{

ASSERT (!queue->StopPending);

queue->StopPending = TRUE;

while (InterlockedExchangeAdd (&queue->OutstandingIoCount, 0) > 0)

{

KeWaitForSingleObject (&queue->NoOutstandingIoEvent, Executive, KernelMode, FALSE, NULL);

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

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

typedef struct

{

PDEVICE_OBJECT DeviceObject;

KMUTEX BufferPoolMutex;

EncryptedIoQueueBuffer *FirstPoolBuffer;

CRYPTO_INFO *CryptoInfo;

// File-handle-based IO

HANDLE HostFileHandle;

int64 VirtualDeviceLength;

volatile BOOL StartPending;

volatile BOOL ThreadExitRequested;

volatile BOOL Suspended;

volatile BOOL SuspendPending;

volatile BOOL StopPending;

# Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

# by the TrueCrypt License 3.0.

#

# 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

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

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

{

return fuse_get_context()->uid == 0 || fuse_get_context()->uid == UserId;

}

void FuseService::CloseMountedVolume ()

{

if (MountedVolume)

return outBuf;

}

const char *FuseService::GetVolumeImagePath ()

{

#ifdef TC_MACOSX

args.push_back ("-o");

args.push_back ("allow_other");

}

ExecFunctor execFunctor (openVolume, slotNumber);

Process::Execute ("fuse", args, -1, &execFunctor);

MountedVolume->WriteSectors (buffer, byteOffset);

}

void FuseService::OnSignal (int signal)

{

try

{

shared_ptr <VolumeInfo> volume = Core->GetMountedVolume (SlotNumber);

if (volume)

Core->DismountVolume (volume, true);

}

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

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

/*

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;

/*

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

CRYPTO_INFO *cryptoInfo; /* Cryptographic and other information for this device */

__int64 HostLength;

__int64 NumberOfCylinders; /* Partition info */

ULONG TracksPerCylinder; /* Partition info */

ULONG SectorsPerTrack; /* Partition info */

/*

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

PARTITION_INFORMATION pi;

PARTITION_INFORMATION_EX pix;

LARGE_INTEGER diskLengthInfo;

STORAGE_PROPERTY_QUERY storagePropertyQuery = {0};

STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR storageDescriptor = {0};

storagePropertyQuery.QueryType = PropertyStandardQuery;

/* IOCTL_STORAGE_QUERY_PROPERTY supported only on Vista and above */

(char *) &storageDescriptor, sizeof (storageDescriptor))))

{

Extension->HostBytesPerPhysicalSector = storageDescriptor.BytesPerPhysicalSector;

}

else

{

// accidentally quick-formats a dismounted partition-hosted TrueCrypt volume as NTFS).

PFILE_OBJECT pfoTmpDeviceFile = NULL;

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

for (volumeType = TC_VOLUME_TYPE_NORMAL;

volumeType < TC_VOLUME_TYPE_COUNT;

{

Dump ("Trying to open volume type %d\n", volumeType);

Dump ("Read didn't read enough data\n");

// If FSCTL_ALLOW_EXTENDED_DASD_IO failed and there is a live filesystem on the partition, then the

// shorter than the partition). This can happen for example after the user quick-formats a dismounted

// partition-hosted TrueCrypt volume and then tries to mount the volume using the embedded backup header.

memset (readBuffer, 0, TC_VOLUME_HEADER_EFFECTIVE_SIZE);

}

// If we are supposed to actually mount the hidden volume (not just to protect it)

{

Extension->DiskLength = cryptoInfoPtr->hiddenVolumeSize;

Extension->cryptoInfo->hiddenVolume = TRUE;

// Hidden volume protection

Extension->cryptoInfo->hiddenVolume = FALSE;

Extension->cryptoInfo->bProtectHiddenVolume = TRUE;

Extension->cryptoInfo->hiddenVolumeProtectedSize = tmpCryptoInfo->hiddenVolumeSize;

Dump ("Hidden volume protection active: %I64d-%I64d (%I64d)\n", Extension->cryptoInfo->hiddenVolumeOffset, Extension->cryptoInfo->hiddenVolumeProtectedSize + Extension->cryptoInfo->hiddenVolumeOffset - 1, Extension->cryptoInfo->hiddenVolumeProtectedSize);

// If this is a hidden volume, make sure we are supposed to actually

// mount it (i.e. not just to protect it)

{

// Validate sector size

if (bRawDevice && Extension->cryptoInfo->SectorSize != Extension->HostBytesPerSector)

Extension->PartitionType = 0;

Extension->bRawDevice = bRawDevice;

memset (Extension->wszVolume, 0, sizeof (Extension->wszVolume));

if (wcsstr (pwszMountVolume, WIDE ("\\??\\UNC\\")) == pwszMountVolume)

{

crypto_close (tmpCryptoInfo);

tmpCryptoInfo = NULL;

}

return STATUS_SUCCESS;

}

}

|| mount->nReturnCode != ERR_PASSWORD_WRONG)

{

/* If we are not supposed to protect a hidden volume, the only error that is

If we _are_ supposed to protect a hidden volume, we do not tolerate any error

(both volume headers must be successfully decrypted). */

FILE_BASIC_INFORMATION FileBasicInfo;

IO_STATUS_BLOCK IoStatusBlock;

&& Extension->bReadOnly == FALSE

&& Extension->bTimeStampValid)

{

&IoStatusBlock,

&FileBasicInfo,

sizeof (FileBasicInfo),

if (!NT_SUCCESS (ntStatus))

{

&IoStatusBlock,

&FileBasicInfo,

sizeof (FileBasicInfo),

if (!NT_SUCCESS (ntStatus))

Dump ("ZwSetInformationFile failed in RestoreTimeStamp: NTSTATUS 0x%08x\n",ntStatus);

/*

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

//

// Next default values for new objects

#ifdef APSTUDIO_INVOKED

#ifndef APSTUDIO_READONLY_SYMBOLS

#define _APS_NO_MFC 1

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

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

status = STATUS_DEVICE_REMOVED;

goto err;

}

Extension->IsVolumeFilterDevice = TRUE;

Extension->DeviceObject = filterDeviceObject;

Extension->Pdo = pdo;

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

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