访问物理内存

这是一个驱动访问物理内存的小例子，但凡驱动都不可避免稳定性，

因此就尽量少在里面干其他事 ：）

 

演示访问物理内存 0xf0000 ----0xfffff空间 64K的物理内存(其实是SMBIOS段)

 

MemQuery.h

#pragma once
#include "ntifs_ex.h"

typedef struct _DEVICE_EXTENSION
{
    ULONG  StateVariable;
} DEVICE_EXTENSION, *PDEVICE_EXTENSION;

//
// Define the various device type values.  Note that values used by Microsoft
// Corporation are in the range 0-0x7FFF(32767), and 0x8000(32768)-0xFFFF(65535)
// are reserved for use by customers.
//
#define FILE_DEVICE_MEMQUERY    0x8000

//
// Macro definition for defining IOCTL and FSCTL function control codes. Note
// that function codes 0-0x7FF(2047) are reserved for Microsoft Corporation,
// and 0x800(2048)-0xFFF(4095) are reserved for customers.
//
#define MEMQUERY_IOCTL_BASE    0x800

//
// The device driver IOCTLs
//

#define CTL_CODE_MEMQUERY(i) CTL_CODE(FILE_DEVICE_MEMQUERY, MEMQUERY_IOCTL_BASE+i, METHOD_BUFFERED, FILE_ANY_ACCESS)

#define IOCTL_MEMQUERY_QUERYBIOS    CTL_CODE_MEMQUERY(0)

//
// Name that Win32 front end will use to open the MemQuery device
//

#define MEMQUERY_DEVICE_NAME_WIN32    "//./MemQuery"



#if DBG
#define dprintf DbgPrint
#else
#define dprintf
#endif

#define kprintf DbgPrint

#define NT_DEVICE_NAME    L"/Device/MemQuery"
#define DOS_DEVICE_NAME L"/DosDevices/MemQuery"

 

MemQuery.cpp

#include "MemQuery.h"

NTSTATUS MemQueryDispatchCreate(IN PDEVICE_OBJECT DeviceObject,IN PIRP Irp);

NTSTATUS MemQueryDispatchClose(IN PDEVICE_OBJECT DeviceObject,IN PIRP Irp);

NTSTATUS MemQueryDispatchDeviceControl(IN PDEVICE_OBJECT DeviceObject,IN PIRP Irp);

VOID MemQueryUnload(IN PDRIVER_OBJECT DriverObject);

NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject,IN PUNICODE_STRING RegistryPath)
{
    dprintf("MemQuery DriverEntry: %S ", RegistryPath->Buffer);

    UNICODE_STRING ntDeviceName;
    RtlInitUnicodeString(&ntDeviceName, NT_DEVICE_NAME);
    PDEVICE_OBJECT DeviceObject = NULL;
    NTSTATUS ntStatus = IoCreateDevice(
        DriverObject,
        sizeof(DEVICE_EXTENSION),
        &ntDeviceName,
        FILE_DEVICE_MEMQUERY,
        0,
        TRUE,
        &DeviceObject
        );

    if (!NT_SUCCESS(ntStatus))
    {
        dprintf("MemQuery IoCreateDevice=0x%x ", ntStatus);
        return ntStatus;
    }

    PDEVICE_EXTENSION DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
    UNICODE_STRING dosDeviceName;
    RtlInitUnicodeString(&dosDeviceName, DOS_DEVICE_NAME);

    ntStatus = IoCreateSymbolicLink(&dosDeviceName, &ntDeviceName);

    if (!NT_SUCCESS(ntStatus))
    {
        IoDeleteDevice(DeviceObject);
        return ntStatus;
    }

    DriverObject->MajorFunction[IRP_MJ_CREATE]         = MemQueryDispatchCreate;
    DriverObject->MajorFunction[IRP_MJ_CLOSE]          = MemQueryDispatchClose;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = MemQueryDispatchDeviceControl;
    DriverObject->DriverUnload                         = MemQueryUnload;

    return ntStatus;
}

NTSTATUS MemQueryDispatchCreate(IN PDEVICE_OBJECT DeviceObject,IN PIRP Irp)
{
    NTSTATUS ntStatus;
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    dprintf("MemQuery IRP_MJ_CREATE ");
    ntStatus = Irp->IoStatus.Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return ntStatus;
}

NTSTATUS MemQueryDispatchClose(IN PDEVICE_OBJECT DeviceObject,IN PIRP Irp)
{
    NTSTATUS ntStatus;
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    dprintf("MemQuery IRP_MJ_CLOSE ");
    ntStatus = Irp->IoStatus.Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return ntStatus;
}

NTSTATUS MemQueryDispatchDeviceControl(IN PDEVICE_OBJECT DeviceObject,IN PIRP Irp)
{
    NTSTATUS ntStatus;
    PIO_STACK_LOCATION IrpStack = IoGetCurrentIrpStackLocation(Irp);
    PDEVICE_EXTENSION DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
    PVOID lpInOutBuffer;
    ULONG nInBufferSize, nOutBufferSize, dwIoControlCode;

    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;

    lpInOutBuffer = Irp->AssociatedIrp.SystemBuffer;
    nInBufferSize = IrpStack->Parameters.DeviceIoControl.InputBufferLength;
    nOutBufferSize = IrpStack->Parameters.DeviceIoControl.OutputBufferLength;

    dprintf("MemQuery IRP_MJ_DEVICE_CONTROL ");

    dwIoControlCode = IrpStack->Parameters.DeviceIoControl.IoControlCode;

    switch (dwIoControlCode)
    {
    case IOCTL_MEMQUERY_QUERYBIOS:
        {
            if(nOutBufferSize<64*1024)
            {
                Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
                dprintf("nOutBufferSize<64*1024");
            }
            else
            {
                PHYSICAL_ADDRESS paddr; 
                paddr.QuadPart = (__int64)0x000f0000; 
                PVOID maped = MmMapIoSpace(paddr, 64*1024, MmNonCached);
                dprintf("We start map io space,mapped addr is %p",maped);
                if(maped!=NULL)
                {
                    READ_REGISTER_BUFFER_UCHAR((PUCHAR)maped, (PUCHAR)lpInOutBuffer, 64*1024);
                    MmUnmapIoSpace(maped, 64*1024);
                    Irp->IoStatus.Information = 64*1024;
                }
                else
                {
                    Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
                    dprintf("MmMapIoSpace return NULL");
                }
            }
            break;
        }

    default:
        Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
        dprintf("MemQuery unknown IRP_MJ_DEVICE_CONTROL ");
        break;
    }
    ntStatus = Irp->IoStatus.Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return ntStatus;
}

VOID MemQueryUnload(IN PDRIVER_OBJECT DriverObject)
{
    UNICODE_STRING dosDeviceName;
    RtlInitUnicodeString(&dosDeviceName, DOS_DEVICE_NAME);
    IoDeleteSymbolicLink(&dosDeviceName);
    IoDeleteDevice(DriverObject->DeviceObject);
    dprintf("MemQuery unloaded ");
}

 

下面的小程序演示如何调用这个驱动并获得目标段的数据:

 

#pragma once
#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
#include <WinSvc.h>
#include <winioctl.h>
#include <stdlib.h>
#include <stdio.h>
#include <vector>
#define FILE_DEVICE_MEMQUERY    0x8000
using namespace std;
//
// Macro definition for defining IOCTL and FSCTL function control codes. Note
// that function codes 0-0x7FF(2047) are reserved for Microsoft Corporation,
// and 0x800(2048)-0xFFF(4095) are reserved for customers.
//
#define MEMQUERY_IOCTL_BASE    0x800

//
// The device driver IOCTLs
//

#define CTL_CODE_MEMQUERY(i) CTL_CODE(FILE_DEVICE_MEMQUERY, MEMQUERY_IOCTL_BASE+i, METHOD_BUFFERED, FILE_ANY_ACCESS)

#define IOCTL_MEMQUERY_QUERYBIOS    CTL_CODE_MEMQUERY(0)


typedef struct _tagPhyMemStruct
{
    BYTE pBuf[0x1001];

//    _tagPhyMemStruct()
//    {
//        memset( szBuf, 0 , 0x1001 );
//    };
}PHYMEM_STRUCT;

vector <PHYMEM_STRUCT*> vtPhymemItems;
class MemDriver
{
public:
    MemDriver(){_handle=NULL;}
    ~MemDriver(){if(_handle!=NULL)CloseHandle(_handle);}
    bool InstallAndStart();
    bool UnInstall();
public:
    bool OpenDriver();
    void QueryBiosMemory();
private:
    HANDLE _handle;
};




#define DRIVERNAME "MemQuery"
#define DRIVERFILANAME "MemQuery.sys"

bool MemDriver::UnInstall()
{
    SC_HANDLE scmHandle=OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
    if(scmHandle!=0)
    {
        SC_HANDLE handle=OpenService(scmHandle,DRIVERNAME,SERVICE_ALL_ACCESS);
        if(handle!=0)
        {
            SERVICE_STATUS status;
            ControlService(handle,SERVICE_CONTROL_STOP,&status);
            DeleteService(handle);
            CloseServiceHandle(handle);
        }
        CloseServiceHandle(scmHandle);
    }
    return true;
}

bool MemDriver::InstallAndStart()
{
    char systemDir[MAX_PATH];
    GetSystemDirectory(systemDir,MAX_PATH);
    strcat(systemDir,"/drivers/");
    strcat(systemDir,DRIVERFILANAME);
    UnInstall();
    SetFileAttributes(systemDir,0);
    DeleteFile(systemDir);
    if(CopyFile("I:/BiosQuery/MemQuery/Debug/MemQuery.sys",systemDir,FALSE)==0)
        return false;

    SC_HANDLE scmHandle=OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
    if(scmHandle==0)
        return false;
    SC_HANDLE newDriver=CreateService(scmHandle,DRIVERNAME,DRIVERNAME,SERVICE_ALL_ACCESS,SERVICE_KERNEL_DRIVER,SERVICE_DEMAND_START,SERVICE_ERROR_IGNORE,systemDir,NULL,NULL,NULL,NULL,NULL);
    if(newDriver!=NULL)
    {
        const char *args=NULL;
        StartService(newDriver,0,&args);
        CloseServiceHandle(newDriver);
    }
    CloseServiceHandle(scmHandle);
    return true;
}

bool MemDriver::OpenDriver()
{
    char drvName[MAX_PATH];
    wsprintf(drvName,"//./%s",DRIVERNAME);
    _handle=CreateFile(drvName,GENERIC_ALL,0,NULL,OPEN_EXISTING,0,0);
    if(_handle==INVALID_HANDLE_VALUE)
    {
        return false;
    }
    return true;
}

void MemDriver::QueryBiosMemory()
{
    static char outbuf[64*1024];
    DWORD retLen=sizeof(outbuf);
    memset(&outbuf,0,sizeof(outbuf));

    int inbuf=0;
    if(!DeviceIoControl(_handle,IOCTL_MEMQUERY_QUERYBIOS,&inbuf,sizeof(inbuf),&outbuf,sizeof(outbuf),&retLen,NULL))
    {
        //在这个数据里面
        return;
    } 
    int j=1;

    PHYMEM_STRUCT *phyMem = new PHYMEM_STRUCT;


    BYTE  pTempBuf[0x1000 + 1];
    
    memset( pTempBuf,0,sizeof( pTempBuf ) );
    

    for ( DWORD dwBase0 = 0xf0000; dwBase0 < 0xfffff; dwBase0 += 0x1000 )
    {
        DWORD dwLength = 0;

        memcpy(pTempBuf,&outbuf[dwLength],0x1000);
        
        memset(phyMem->pBuf,0,0x1001);

        memcpy(phyMem->pBuf,pTempBuf,0x1000);

        vtPhymemItems.push_back(phyMem);

        dwLength += 0x1000;
    }
    
    DWORD dwLength1 = 0x1000;
    for(int i = 0; i < ( dwLength1 - 4 ); ++i)
    {
        if(strncmp((char*)&outbuf[i], "_SM_", 4) == 0 )
            MessageBox(NULL,"", " ",MB_OK);
    }
}

MemDriver gMemDriver;
int main(int argc,char *argv[])
{
    gMemDriver.UnInstall();
    gMemDriver.InstallAndStart();
    gMemDriver.OpenDriver();
    gMemDriver.QueryBiosMemory();
    gMemDriver.UnInstall();
    return 0;
}