/*
  MyKiller.C
  Author: <Dayed>
  Last Updated: 2007-07-06

  This framework is generated by EasySYS 0.3.0 Modify
  This template file is copying from QuickSYS 0.3.0 written by Chunhua Liu
  //=============================================
  Modified by PLK_XiaoWei[0GiNr]
  http://www.0GiNr.com
  //=============================================
*/
#include "ntddk.h"
#include <windef.h>
#include <stdlib.h>
#include "MyKiller.h"    
#include "dbghelp.h"
#include "dayed.h"
#include "hookiat.h"

//===========================================
NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObj, PUNICODE_STRING pRegistryString);
NTSTATUS DispatchCreate(PDEVICE_OBJECT pDevObj, PIRP pIrp);
NTSTATUS DispatchClose(PDEVICE_OBJECT pDevObj, PIRP pIrp);
VOID DriverUnload(PDRIVER_OBJECT pDriverObj);
NTSTATUS DispatchIoctl(PDEVICE_OBJECT pDevObj, PIRP pIrp);

typedef NTSTATUS (*PSPTERMINATETHREADBYPOINTER)( PETHREAD, NTSTATUS);
NTKERNELAPI NTSTATUS PsLookupProcessByProcessId (IN ULONG ProcessId,OUT PEPROCESS *Process);
//==========================================




PEPROCESS  eProcess;
ULONG      processID;
PSPTERMINATETHREADBYPOINTER MyPspTerminateThreadByPointer ;



//==========================================
PVOID GetUndocumentFunctionAdress()
{
  ULONG size,index;
  PULONG buf;
  ULONG i;
  PSYSTEM_MODULE_INFORMATION module;
  PVOID driverAddress=0;
  ULONG ntosknlBase;
  ULONG ntosknlEndAddr;
  ULONG curAddr;
  NTSTATUS status;
  PVOID retAddr;
  ULONG code1_sp2=0x8b55ff8b,code2_sp2=0x0cec83ec,code3_sp2=0xfff84d83,code4_sp2=0x7d8b5756;
  
  ZwQuerySystemInformation(SystemModuleInformation,&size, 0, &size);
  if(NULL==(buf = (PULONG)ExAllocatePool(PagedPool, size)))
  {
    DbgPrint("failed alloc memory failed \n");
    return 0;
  }
  status=ZwQuerySystemInformation(SystemModuleInformation,buf, size , 0);
  if(!NT_SUCCESS( status ))
  {
    DbgPrint("failed query\n");
    return 0;
  }
  module = (PSYSTEM_MODULE_INFORMATION)(( PULONG )buf + 1);
  ntosknlEndAddr=(ULONG)module->Base+(ULONG)module->Size;
  ntosknlBase=(ULONG)module->Base;
  curAddr=ntosknlBase;
  ExFreePool(buf);
  for (i=curAddr;i<=ntosknlEndAddr;i++)
  {
    if ((*((ULONG *)i)==code1_sp2)&&(*((ULONG *)(i+4))==code2_sp2)&&(*((ULONG *)(i+8))==code3_sp2)&&(*((ULONG*)(i+12))==code4_sp2)) 
    {
      retAddr=(PVOID*)i;
      DbgPrint("MyPspTerminateThreadByPointer  adress is:%x\n",retAddr); 
      return retAddr;
    }
  }
  DbgPrint("Can't Find MyPspTerminateThreadByPointer  Address:%x\n"); 
  return 0;
}






//载自ReactOS-0.3.4-REL-src
PETHREAD
NTAPI
GetNextProcessThread(IN PEPROCESS Process,
           IN PETHREAD Thread OPTIONAL)
{
    PETHREAD FoundThread = NULL;
    PLIST_ENTRY ListHead, Entry;
    PAGED_CODE();
    
    if (Thread)
    {
    //  Entry = Thread->ThreadListEntry.Flink;;//   +0x22c ThreadListEntry  : _LIST_ENTRY
    Entry = (PLIST_ENTRY)((ULONG)(Thread)+0x22c);
    Entry=Entry->Flink;
    }
    else
    {
        Entry = (PLIST_ENTRY)((ULONG)(Process)+0x190);//+0x190 ThreadListHead   : _LIST_ENTRY
        Entry = Entry->Flink; 
    }
  // ListHead = &Process->ThreadListHead;
  ListHead = (PLIST_ENTRY)((ULONG)Process + 0x190);
    while (ListHead != Entry)
    {
    //   FoundThread = CONTAINING_RECORD(Entry, ETHREAD, ThreadListEntry);
    FoundThread = (PETHREAD)((ULONG)Entry - 0x22c);
    //    if (ObReferenceObjectSafe(FoundThread)) break;
    if (ObReferenceObject(FoundThread)) break;
        FoundThread = NULL;
        Entry = Entry->Flink;
    }
    if (Thread) ObDereferenceObject(Thread);
    return FoundThread;
}






NTSTATUS TerminateProcess( PEPROCESS Process )
{
  NTSTATUS          Status;
  PETHREAD          Thread;
  
  Status = STATUS_SUCCESS;
  __try
  {
    for (Thread = GetNextProcessThread( Process, NULL );
    Thread != NULL;
    Thread = GetNextProcessThread( Process, Thread ))
    {
      Status = STATUS_SUCCESS;
      Status = (*MyPspTerminateThreadByPointer)( Thread, 0);
    }
  }
  __except(EXCEPTION_EXECUTE_HANDLER)
  {
    Status = GetExceptionCode();
  }
  return Status;
}


//==========================================


NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObj, PUNICODE_STRING pRegistryString)
{
  NTSTATUS status = STATUS_SUCCESS;
  UNICODE_STRING ustrLinkName;
  UNICODE_STRING ustrDevName;    
  PDEVICE_OBJECT pDevObj;
  
  dprintf("[MyKiller] DriverEntry: %S\n",pRegistryString->Buffer);

    // Create dispatch points for device control, create, close.
  pDriverObj->MajorFunction[IRP_MJ_CREATE] = DispatchCreate;
  pDriverObj->MajorFunction[IRP_MJ_CLOSE] = DispatchClose;
  pDriverObj->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DispatchIoctl;
  pDriverObj->DriverUnload = DriverUnload;
  //

  RtlInitUnicodeString(&ustrDevName, DEVICE_NAME);
  
  status = IoCreateDevice(pDriverObj, 
        0,
        &ustrDevName, 
        FILE_DEVICE_UNKNOWN,
        0,
        FALSE,
        &pDevObj);

  dprintf("[MyKiller] Device Name %S",ustrDevName.Buffer);

  if(!NT_SUCCESS(status))
  {
    dprintf("[MyKiller] IoCreateDevice = 0x%x\n", status);
    return status;
  }

  
  RtlInitUnicodeString(&ustrLinkName, LINK_NAME);

  status = IoCreateSymbolicLink(&ustrLinkName, &ustrDevName);  
  if(!NT_SUCCESS(status))
  {
    dprintf("[MyKiller] IoCreateSymbolicLink = 0x%x\n", status);
    IoDeleteDevice(pDevObj);  
    return status;
  }
  
  dprintf("[MyKiller] SymbolicLink:%S",ustrLinkName.Buffer);

  //获取PspTerminateThreadByPointer地址
  MyPspTerminateThreadByPointer  =GetUndocumentFunctionAdress();

  return STATUS_SUCCESS;
}









VOID DriverUnload(PDRIVER_OBJECT pDriverObj)
{  
  UNICODE_STRING strLink;
  RtlInitUnicodeString(&strLink, LINK_NAME);
  //
    // Delete the symbolic link
    //
  IoDeleteSymbolicLink(&strLink);
  //
    // Delete the device object
    //
  IoDeleteDevice(pDriverObj->DeviceObject);
  dprintf("[MyKiller] Unloaded\n");
}









NTSTATUS DispatchCreate(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
  pIrp->IoStatus.Status = STATUS_SUCCESS;
  pIrp->IoStatus.Information = 0;
  dprintf("[MyKiller] IRP_MJ_CREATE\n");
  IoCompleteRequest(pIrp, IO_NO_INCREMENT);
  return STATUS_SUCCESS;
}








NTSTATUS DispatchClose(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
  pIrp->IoStatus.Status = STATUS_SUCCESS;
  pIrp->IoStatus.Information = 0;
  dprintf("[MyKiller] IRP_MJ_CLOSE\n");
  IoCompleteRequest(pIrp, IO_NO_INCREMENT);
  return STATUS_SUCCESS;
}








NTSTATUS DispatchIoctl(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
  NTSTATUS status = STATUS_INVALID_DEVICE_REQUEST;
  PIO_STACK_LOCATION pIrpStack;
  ULONG uIoControlCode;
  PVOID pIoBuffer;
  ULONG uInSize;
  ULONG uOutSize;

  pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
  uIoControlCode = pIrpStack->Parameters.DeviceIoControl.IoControlCode;
  pIoBuffer = pIrp->AssociatedIrp.SystemBuffer;
  uInSize = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;
  uOutSize = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;

  switch(uIoControlCode)
  {
  case IOCTL_Killer:
    {
      dprintf("Call IOCTL_Killer");

      __try
      {
        memcpy(&processID,pIoBuffer,sizeof(processID));
        status=PsLookupProcessByProcessId(processID,&eProcess);
        if(NT_SUCCESS(status))
        {
          ObDereferenceObject(eProcess);
        }
        status=TerminateProcess(eProcess);
        if(NT_SUCCESS(status))
        {
          dprintf("TerminateProcess Ok!\n");
        }
      }
      __except(EXCEPTION_EXECUTE_HANDLER)
      {
        ;
      }
      
    //  status = STATUS_SUCCESS;
        break;
    }
  }

  if(status == STATUS_SUCCESS)
    pIrp->IoStatus.Information = uOutSize;
  else
    pIrp->IoStatus.Information = 0;

  pIrp->IoStatus.Status = status;
  IoCompleteRequest(pIrp, IO_NO_INCREMENT);

  return status;
}