Минифильтр файловой системы

Data->IoStatus.Status = STATUS_REPARSE;

Data->IoStatus.Status = STATUS_ACCESS_DENIED;

#include "Common.h"
#include "Helper.h"
#include "Config.h"
 
#define DWORD unsigned long
#define WORD unsigned short
#define BOOL unsigned long
 
#define CURRENT_PROCESS_TAG 'cpnt'
#define FULL_PATH_TAG 'fpnt'
#define VOLUME_TAG 'vnt'
 
FLT_POSTOP_CALLBACK_STATUS PostFileOperationCallback ( IN OUT PFLT_CALLBACK_DATA Data, 
                IN PCFLT_RELATED_OBJECTS FltObjects, 
                IN PVOID CompletionContext, 
                IN FLT_POST_OPERATION_FLAGS Flags);
                
FLT_PREOP_CALLBACK_STATUS
PreFileOperationCallback (
    __inout PFLT_CALLBACK_DATA Data,
    __in PCFLT_RELATED_OBJECTS FltObjects,
    __deref_out_opt PVOID *CompletionContext
    );
 
NTSTATUS FilterUnload ( IN FLT_FILTER_UNLOAD_FLAGS Flags );
 
NTSTATUS FilterLoad (IN PCFLT_RELATED_OBJECTS  FltObjects,
                IN FLT_INSTANCE_SETUP_FLAGS  Flags,
                IN DEVICE_TYPE  VolumeDeviceType,
                IN FLT_FILESYSTEM_TYPE  VolumeFilesystemType);
 
 
typedef struct _MINIFILTER
{
    PDRIVER_OBJECT pDriverObject;
    PFLT_FILTER pFilter;
} MINIFILTER, *PMINIFILTER;
 
 
 const FLT_OPERATION_REGISTRATION Callbacks[] = {
 
    { IRP_MJ_CREATE,                                
      0,                                            
      PreFileOperationCallback,
      PostFileOperationCallback },
    
    { IRP_MJ_OPERATION_END }
};
 
const FLT_CONTEXT_REGISTRATION Contexts[] = {
    { FLT_CONTEXT_END }
};
 
CONST FLT_REGISTRATION FilterRegistration = {
 
    sizeof( FLT_REGISTRATION ),         //  Size
    FLT_REGISTRATION_VERSION,           //  Version
    0,                                  //  Flags
 
    Contexts,                               //  Context
    Callbacks,                          //  Operation callbacks
 
    FilterUnload,                     //  FilterUnload
 
    FilterLoad,                    //  InstanceSetup
    NULL,            //  InstanceQueryTeardown
    NULL,            //  InstanceTeardownStart
    NULL,         //  InstanceTeardownComplete
 
    NULL,                 //  GenerateFileName
    NULL            //  NormalizeNameComponent
};
 
MINIFILTER fileManager;
 
NTSTATUS FilterLoad (IN PCFLT_RELATED_OBJECTS  FltObjects,
    IN FLT_INSTANCE_SETUP_FLAGS  Flags,
    IN DEVICE_TYPE  VolumeDeviceType,
    IN FLT_FILESYSTEM_TYPE  VolumeFilesystemType)
{
    if (VolumeDeviceType == FILE_DEVICE_NETWORK_FILE_SYSTEM) {
       return STATUS_FLT_DO_NOT_ATTACH;
    }
 
    return STATUS_SUCCESS;
}
 
NTSTATUS FilterUnload ( IN FLT_FILTER_UNLOAD_FLAGS Flags )
{
    return STATUS_SUCCESS;
}
 
PWCHAR wcssplt(PWCHAR str, PWCHAR substr)
{
    PWCHAR result = NULL;
    PWCHAR subStPos =  wcswcs(str, substr);
    if(subStPos != 0)
    {
        int pos = subStPos - str;
        result = (PWCHAR)ExAllocatePoolWithTag(NonPagedPool ,sizeof(WCHAR)*pos + sizeof(UNICODE_NULL), VOLUME_TAG);
        RtlCopyMemory(result, str, sizeof(WCHAR)*pos);
        *(result+pos) = UNICODE_NULL;
    }
    return result;
}
 
FLT_PREOP_CALLBACK_STATUS
PreFileOperationCallback (
    __inout PFLT_CALLBACK_DATA Data,
    __in PCFLT_RELATED_OBJECTS FltObjects,
    __deref_out_opt PVOID *CompletionContext
    )
{
 
    NTSTATUS status;
    PFILE_OBJECT FileObject;
    PFileRedirectRule redirectRuleItem;
    PFLT_FILE_NAME_INFORMATION pFileNameInformation;
    PConfigurationMap rule;
    UNICODE_STRING fullPath;
    UNICODE_STRING processName;
    PWCHAR Volume;
 
    FLT_PREOP_CALLBACK_STATUS returnStatus = FLT_PREOP_SUCCESS_NO_CALLBACK;
    
    /* If this is a callback for a FS Filter driver then we ignore the event */
    if(FLT_IS_FS_FILTER_OPERATION(Data))
    {
        return FLT_PREOP_SUCCESS_NO_CALLBACK;
    }
 
    if (FltObjects->FileObject != NULL && Data != NULL) {
        FileObject = Data->Iopb->TargetFileObject;
                if(FileObject != NULL && Data->Iopb->MajorFunction == IRP_MJ_CREATE)
                {
                    processName.Length = 0;
                    processName.MaximumLength = NTSTRSAFE_UNICODE_STRING_MAX_CCH * sizeof(WCHAR);
                    processName.Buffer = ExAllocatePoolWithTag(NonPagedPool, processName.MaximumLength,CURRENT_PROCESS_TAG);
                    RtlZeroMemory(processName.Buffer, processName.MaximumLength);
 
                    status =  GetProcessImageName(&processName);
                    if(NT_SUCCESS(status))
                    {
                        if(LoggingEnabled()== 1)
                        {
                            DbgPrint("MiniFilter: Process: %ws", processName.Buffer);
                        }
                    }
                    else
                    {
                        return FLT_PREOP_SUCCESS_NO_CALLBACK;
                    }
                    rule = FindRuleByProcessName(&processName,GetConfigurationMap());
 
 
                    ExFreePool(processName.Buffer); 
 
                    if(rule != NULL){
                        if(LoggingEnabled() == 1)
                        {
                            DbgPrint("MiniFilter: File name %ws", FileObject->FileName.Buffer);
                        }
 
                        redirectRuleItem = rule->ProcessRule.Rule;
 
                        while(redirectRuleItem)
                        {
                            if(RtlCompareUnicodeString(&FileObject->FileName ,&redirectRuleItem->From, FALSE) == 0)
                            {
                                status = FltGetFileNameInformation( Data,
                                                FLT_FILE_NAME_NORMALIZED |
                                                FLT_FILE_NAME_QUERY_ALWAYS_ALLOW_CACHE_LOOKUP,
                                                &pFileNameInformation );
                                if(NT_SUCCESS(status))
                                {
 
                                    fullPath.Length = 0;
                                    fullPath.MaximumLength = NTSTRSAFE_UNICODE_STRING_MAX_CCH * sizeof(WCHAR);
                                    fullPath.Buffer = ExAllocatePoolWithTag(NonPagedPool, fullPath.MaximumLength, FULL_PATH_TAG);
                                    RtlZeroMemory(fullPath.Buffer, fullPath.MaximumLength);
 
                                    Volume = wcssplt(pFileNameInformation->Volume.Buffer, redirectRuleItem->From.Buffer );
 
                                    RtlAppendUnicodeToString(&fullPath, Volume);  
                                    RtlAppendUnicodeToString(&fullPath, redirectRuleItem->To.Buffer); 
 
                                    ExFreePool(Volume);
                                    ExFreePool(FileObject->FileName.Buffer); 
                                
                                    FileObject->FileName.Length = fullPath.Length; 
                                    FileObject->FileName.MaximumLength = fullPath.MaximumLength; 
                                    FileObject->FileName.Buffer = fullPath.Buffer;
 
                            
                                    Data->Iopb->TargetFileObject->RelatedFileObject = NULL;
                                    Data->IoStatus.Information = IO_REPARSE; 
                                    Data->IoStatus.Status = STATUS_ACCESS_DENIED;
                            
                                    DbgPrint("MiniFilter: Redirect done according the rule to %ws", fullPath.Buffer);
 
                                    return FLT_PREOP_COMPLETE;  
                                }
                            }
 
                            redirectRuleItem = redirectRuleItem->NextRule;
                        }
                    }
                }
    }
 
    return FLT_PREOP_SUCCESS_NO_CALLBACK;
}
 
FLT_POSTOP_CALLBACK_STATUS PostFileOperationCallback ( IN OUT PFLT_CALLBACK_DATA Data, 
    IN PCFLT_RELATED_OBJECTS FltObjects, 
    IN PVOID CompletionContext, 
    IN FLT_POST_OPERATION_FLAGS Flags)
{
 
    return FLT_POSTOP_FINISHED_PROCESSING;
 
}
//////////////////////////////////////////////////////////////
 
 
/* This device driver doesn't service I/O requests, so we provide only
   a dummy I/O dispatch routine. */
NTSTATUS
OnStubDispatch(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP           Irp
    )
{
    Irp->IoStatus.Status      = STATUS_ACCESS_DENIED;
    IoCompleteRequest (Irp,
                       IO_NO_INCREMENT
                       );
    return Irp->IoStatus.Status;
}
 
 
VOID OnUnload( IN PDRIVER_OBJECT DriverObject )
{
    FltUnregisterFilter(fileManager.pFilter);
    FreeConfigInfo();
    DbgPrint("MiniFilter: Unloaded");
}
 
 
 
NTSTATUS DriverEntry( IN PDRIVER_OBJECT theDriverObject, IN PUNICODE_STRING theRegistryPath )
{
  int i;
  NTSTATUS status;
  PCHAR ConfigInfo;
  UNICODE_STRING test;
 
  DbgPrint("MiniFilter: Started.");
 
  // Register a dispatch function
  for (i = 0; i < IRP_MJ_MAXIMUM_FUNCTION; i++) 
  {
      theDriverObject->MajorFunction[i] = OnStubDispatch;
  }
 
  theDriverObject->DriverUnload  = OnUnload; 
 
  fileManager.pDriverObject = theDriverObject;
 
  status = FltRegisterFilter(theDriverObject, &FilterRegistration, &fileManager.pFilter);
 
  if (!NT_SUCCESS(status))
  {
       DbgPrint("MiniFilter:  Driver not started. ERROR FltRegisterFilter - %08x\n", status); 
       return status;
  }
 
  ConfigInfo = ReadConfigurationFile();
  if(ConfigInfo != NULL && NT_SUCCESS(ParseConfigurationFile(ConfigInfo)))
  {
        ExFreePool(ConfigInfo);
        DbgPrint("MiniFilter: Configuration finished.");
  }else
  {
        if(ConfigInfo != NULL)ExFreePool(ConfigInfo);
        FltUnregisterFilter( fileManager.pFilter );
        DbgPrint("MiniFilter: Driver configuration was failed. Driver not started.");
        return STATUS_DEVICE_CONFIGURATION_ERROR;
  }
 
  status = FltStartFiltering( fileManager.pFilter );
 
  if (!NT_SUCCESS( status )) {
         FltUnregisterFilter( fileManager.pFilter );
         FreeConfigInfo();
         DbgPrint("MiniFilter:  Driver not started. ERROR FltStartFiltering - %08x\n", status);
         return status;
  }
 
   DbgPrint("MiniFilter: Filter was started and configured.");
   return STATUS_SUCCESS;
}