📄 winntmethods.~pas

📁 pipe类 pipe类 pipe类 pipe类 pipe类
💻 ~PAS
字号:
unit WinNTMethods;

interface

uses Windows, OMCDrv, DrvInterface, CmnTnC;


function PortDWordInNT(Port : DWord) : DWord;
function PortWordInNT(Port : DWord) : Word;
function PortInNT(Port : DWord) : Byte;
procedure PortDWordOutNT(Port : DWord; Data : DWord);
procedure PortWordOutNT(Port : DWord; Data : Word);
procedure PortOutNT(Port : DWord; Data : Byte);

function ReadMSRNT(ulECX:DWord; var MSRreg:tmsr):boolean;
function WriteMSRNT(ulECX:DWord;MSRreg:tmsr):boolean;

//function MemReadBlockNt(address: DWord; var data: Byte; count, unitsize: DWord): DWord;
function MemReadBlockNt(Addr: DWord; Size: Cardinal; var Dump): Boolean;


type
  NTSTATUS = Integer;
  PUnicodeString = ^TUnicodeString;  TUnicodeString = packed record    Length       : Word;    MaximumLength: Word;    Buffer       : PWideChar;  end;  PObjectAttributes = ^TObjectAttributes;  TObjectAttributes = record    Length                  : ULONG;    RootDirectory           : THandle;    ObjectName              : PUnicodeString;    Attributes              : ULONG;    SecurityDescriptor      : PSecurityDescriptor;    SecurityQualityOfService: PSecurityQualityOfService;  end;  TFNZwOpenSection = function(out Section: THandle; Access: ACCESS_MASK;    Attributes: PObjectAttributes): NTSTATUS; stdcall;  TFNRtlNtStatusToDosError = function(Status: NTSTATUS): DWORD; stdcall;const  PhysMemDevName = '\Device\PhysicalMemory';  PhysMemName: TUnicodeString = (    Length       : Length(PhysMemDevName) * SizeOf(WideChar);    MaximumLength: Length(PhysMemDevName) * SizeOf(WideChar) + SizeOf(WideChar);    Buffer       : PhysMemDevName;  );  PhysMemMask: ACCESS_MASK = SECTION_MAP_READ;  PhysMemAttr: TObjectAttributes = (    Length                  : SizeOf(TObjectAttributes);    RootDirectory           : 0;    ObjectName              : @PhysMemName;    Attributes              : $00000040;  // OBJ_CASE_INSENSITIVE    SecurityDescriptor      : nil;    SecurityQualityOfService: nil;  );
  
var
  ZwOpenSection: TFNZwOpenSection;
  RtlNtStatusToDosError: TFNRtlNtStatusToDosError;

implementation

uses SysUtils, Dialogs;

function PortDWordInNT(Port : DWord) : DWord;
var
  IOCTL_PCI_READ_PORT_ULONG:longint;
  data:DWord;
  IoctlResult:boolean;
	ReturnedLength:DWord;
begin
  data:=0;
  IOCTL_PCI_READ_PORT_ULONG:=CTL_CODE( PCI_TYPE, $902, METHOD_BUFFERED, FILE_READ_ACCESS );
  IoctlResult:=DeviceIoControl(
                        DriverHandle,
                        IOCTL_PCI_READ_PORT_ULONG,
                        @port,
                        sizeof(DWord),
                        @data,
                        sizeof(data),
                        ReturnedLength,
                        nil
                        );
  assert(IoctlResult);
	assert(ReturnedLength=sizeof(data));
  result:=data;

  if fDebug then AddToLog('IOCTL_PCI_READ_PORT_ULONG from PortDWordInNT, result '+BoolToStr(IoctlResult));
end;

function PortWordInNT(Port : DWord) : Word;
var
  IOCTL_PCI_READ_PORT_USHORT:longint;
  data:Word;
  IoctlResult:boolean;
	ReturnedLength:DWord;
begin
  data:=0;
  IOCTL_PCI_READ_PORT_USHORT:=CTL_CODE( PCI_TYPE, $901, METHOD_BUFFERED, FILE_READ_ACCESS );
  IoctlResult:=DeviceIoControl(
                        DriverHandle,
                        IOCTL_PCI_READ_PORT_USHORT,
                        @port,
                        sizeof(DWord),
                        @data,
                        sizeof(data),
                        ReturnedLength,
                        nil
                        );
  assert(IoctlResult);
	assert(ReturnedLength=sizeof(data));
  result:=data;

  if fDebug then AddToLog('IOCTL_PCI_READ_PORT_USHORT from PortWordInNT, result '+BoolToStr(IoctlResult));
end;

function PortInNT(Port : DWord) : Byte;
var
  IOCTL_PCI_READ_PORT_UCHAR:longint;
  data:byte;
  IoctlResult:boolean;
	ReturnedLength:DWord;
begin
  data:=0;
  IOCTL_PCI_READ_PORT_UCHAR:=CTL_CODE( PCI_TYPE, $900, METHOD_BUFFERED, FILE_READ_ACCESS );
  IoctlResult:=DeviceIoControl(
                        DriverHandle,
                        IOCTL_PCI_READ_PORT_UCHAR,
                        @Port,
                        sizeof(DWord),
                        @data,
                        sizeof(data),
                        ReturnedLength,
                        nil
                        );
  assert(IoctlResult);
  assert(ReturnedLength=sizeof(data));
  result:=data;

  if fDebug then AddToLog('IOCTL_PCI_READ_PORT_UCHAR from PortInNT, result '+BoolToStr(IoctlResult));
end;

procedure PortDWordOutNT(Port : DWord; Data : DWord);
type
  TPCIInputBuffer=packed record
    PortNumber:DWord;
    DWordData:DWord;
  end;
var
  IOCTL_PCI_WRITE_PORT_ULONG:longint;
  IoctlResult:boolean;
  ReturnedLength:DWord;
  DataLength:DWord;
  PCIInputBuffer:TPCIInputBuffer;
begin
  IOCTL_PCI_WRITE_PORT_ULONG:=CTL_CODE(PCI_TYPE,  $912, METHOD_BUFFERED, FILE_WRITE_ACCESS);
  PCIInputBuffer.DWordData:=data;
	PCIInputBuffer.PortNumber:=port;
  DataLength:=32+sizeof(PCIInputBuffer.DWordData);
  IoctlResult:=DeviceIoControl(
                        DriverHandle,
                        IOCTL_PCI_WRITE_PORT_ULONG,
                        @PCIInputBuffer,
                        DataLength,
                        nil,
                        0,
                        ReturnedLength,
                        nil
                        );
  assert(IoctlResult);

  if fDebug then AddToLog('IOCTL_PCI_WRITE_PORT_ULONG from PortDWordOutNT, result '+BoolToStr(IoctlResult));
end;

procedure PortWordOutNT(Port : DWord; Data : Word);
type
  TPCIInputBuffer=packed record
    PortNumber:DWord;
    WordData:Word;
  end;
var
  IOCTL_PCI_WRITE_PORT_USHORT:longint;
  IoctlResult:boolean;
  ReturnedLength:DWord;
  DataLength:DWord;
  PCIInputBuffer:TPCIInputBuffer;
begin
  IOCTL_PCI_WRITE_PORT_USHORT:=CTL_CODE(PCI_TYPE,  $911, METHOD_BUFFERED, FILE_WRITE_ACCESS);
  PCIInputBuffer.WordData:=data;
	PCIInputBuffer.PortNumber:=port;
  DataLength:=32+sizeof(PCIInputBuffer.WordData);
  IoctlResult:=DeviceIoControl(
                        DriverHandle,
                        IOCTL_PCI_WRITE_PORT_USHORT,
                        @PCIInputBuffer,
                        DataLength,
                        nil,
                        0,
                        ReturnedLength,
                        nil
                        );
  assert(IoctlResult);

  if fDebug then AddToLog('IOCTL_PCI_WRITE_PORT_USHORT from PortWordOutNT, result '+BoolToStr(IoctlResult));
end;

procedure PortOutNT(Port : DWord; Data : Byte);
type
  TPCIInputBuffer=packed record
    PortNumber:DWord;
    CharData:byte;
  end;
var
  IOCTL_PCI_WRITE_PORT_UCHAR:longint;
  IoctlResult:boolean;
  ReturnedLength:DWord;
  DataLength:DWord;
  PCIInputBuffer:TPCIInputBuffer;
begin
  IOCTL_PCI_WRITE_PORT_UCHAR:=CTL_CODE(PCI_TYPE,  $910, METHOD_BUFFERED, FILE_WRITE_ACCESS);
  PCIInputBuffer.CharData:=data;
	PCIInputBuffer.PortNumber:=port;
  DataLength:=32+sizeof(PCIInputBuffer.CharData);
  IoctlResult:=DeviceIoControl(
                        DriverHandle,
                        IOCTL_PCI_WRITE_PORT_UCHAR,
                        @PCIInputBuffer,
                        DataLength,
                        nil,
                        0,
                        ReturnedLength,
                        nil
                        );
  assert(IoctlResult);

  if fDebug then AddToLog('IOCTL_PCI_WRITE_PORT_UCHAR from PortOutNT, result '+BoolToStr(IoctlResult));
end;

function ReadMSRNT(ulECX:DWord; var MSRreg:tmsr):boolean;
var
  IOCTL_READ_MSR:longint;
  ReturnedLength:DWord;
  IoctlResult:boolean;
  buf:array[1..2] of DWord;
begin
  IOCTL_READ_MSR:=CTL_CODE(MSR_TYPE, $981, METHOD_BUFFERED, FILE_ANY_ACCESS);
	IoctlResult:=DeviceIoControl(
					DriverHandle,				// Handle to device
					IOCTL_READ_MSR,		  // RDMSR code
					@ulECX,				      // Buffer to driver
					sizeof(ulECX),		  // Length of buffer in bytes.
					@buf,				        // Buffer from driver.
					sizeof(buf),		    // Length of buffer in bytes.
					ReturnedLength,	    // Bytes placed in outbuf.
					nil				          //
					);

  MSRreg.LowPart:=buf[1];
  MSRreg.HiPart:=buf[2];
  result:=IoctlResult;

  if fDebug then AddToLog('IOCTL_READ_MSR from ReadMSRNT, result '+BoolToStr(IoctlResult));
end;

function WriteMSRNT(ulECX:DWord;MSRreg:tmsr):boolean;
var
  IOCTL_WRITE_MSR:longint;
  ReturnedLength:DWord;
  IoctlResult:boolean;
  buf:array[1..3] of DWord;
begin
  buf[1]:=ulECX;
  buf[2]:=MSRreg.LowPart;
  buf[3]:=MSRreg.HiPart;

  IOCTL_WRITE_MSR:=CTL_CODE(MSR_TYPE, $982, METHOD_BUFFERED, FILE_ANY_ACCESS);
  IoctlResult:=DeviceIoControl(
					DriverHandle,				// Handle to device
					IOCTL_WRITE_MSR,	  // WRMSR code
					@buf,				        // Buffer to driver
					sizeof(buf),		    // Length of buffer in bytes.
					@result,			      // Buffer from driver.
					sizeof(result),		  // Length of buffer in bytes.
					ReturnedLength,	    // Bytes placed in outbuf.
					nil				          // nil
					);
  result:=IoctlResult;

  if fDebug then AddToLog('IOCTL_WRITE_MSR from WriteMSRNT, result '+BoolToStr(IoctlResult));
end;

function MemReadBlockNt(Addr: DWord; Size: Cardinal; var Dump): Boolean;
var
  Stat: NTSTATUS;
  Sect: THandle;  View: Pointer;
  data: Byte;
begin
  if not Assigned(ZwOpenSection) or not Assigned(RtlNtStatusToDosError) then
  begin
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    result:=false;
    exit;
  end;

  Stat := ZwOpenSection(Sect, PhysMemMask, @PhysMemAttr);
  if Stat >= 0 then  try    View := MapViewOfFile(Sect, PhysMemMask, 0, $1, Size);    //ShowMessage(format('%x', [Cardinal(RomBase)]))    if View <> nil then    try      Move(View^, Dump, Size);      Move(View^, data, SizeOf(data));      ShowMessage(format('%x', [data]));      Result := True;    finally      UnmapViewOfFile(View);    end;  finally    CloseHandle(Sect);  end  else  begin
    SetLastError(RtlNtStatusToDosError(Stat));
    result:=false;
    exit;
  end;
  result:=true;
end;

{function MemReadBlockNt(address: DWord; var data: Byte; count, unitsize: DWord): DWord;
type
  PCIDEBUG_MEMREAD_INPUT = packed record
    address: DWord;
    unitsize: DWord;
	  count: DWord;
  end;
var
  IOCTL_PCI_READ_MEM: longint;
  param: PCIDEBUG_MEMREAD_INPUT;
  ReturnedLength, size: DWord;
  IoctlResult: boolean;
begin
  IOCTL_PCI_READ_MEM:=CTL_CODE(PCI_TYPE, $920, METHOD_BUFFERED, FILE_READ_ACCESS);
  param.address:=address;
	param.unitsize:=unitsize;
	param.count:=count;
  size:=param.unitsize * param.count;
  IoctlResult:=DeviceIoControl(
                        DriverHandle,							      // Handle to device
                        IOCTL_PCI_READ_MEM,				      // IO Control code
                        @param,							            // Buffer to driver
                        sizeof(PCIDEBUG_MEMREAD_INPUT),	// Length of buffer in bytes.
                        @data,							            // Buffer from driver.
                        size,							              // Length of buffer in bytes.
                        ReturnedLength,				          // Bytes placed in outbuf.
                        nil							                // NULL means wait till I/O completes.
                        );

  if(IoctlResult) and (ReturnedLength = size) then result:=param.count
  else result:=0;

end; }

end.
💿 文件大小 544 K
👤 上传用户 ylchsj521
📂 所属分类其他
🏷️ 相关标签

#pipe
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -