Язык программирования для написания myAC 1.5.8 14 hack

#include <NTDDK.h>
#include <WINDEF.h>
#include <NTIFS.h>
#include <STDIO.h>
#include <WINUSER.h>
#include "IOCTL.h"
#include "ZDisasm.h"

/*
[sXe Injected 4.4]
[32][7C90D793] - NtCreateSection
[35][7C90D7D2] - NtCreateThread *NEED*
[74][7C90DCFD] - NtOpenFile *NEED*
[7A][7C90DD7B] - NtOpenProcess *NEED*
[89][7C90DEB6] - NtProtectVirtualMemory
[AD][7C90E1AA] - NtQuerySystemInformation *NEED*
[D5][7C90E4F2] - NtSetContextThread
[FE][7C90E84F] - NtSuspendThread
[115][7C90EA32] - NtWriteVirtualMemory *NEED*
*/

__declspec(dllimport) PSERVICE_DESCRIPTOR_TABLE KeServiceDescriptorTable;
__declspec(dllimport) _stdcall KeAddSystemServiceTable(PVOID, PVOID, PVOID, PVOID, PVOID);
PSERVICE_DESCRIPTOR_TABLE KeServiceDescriptorTableShadow = NULL;

typedef struct _MODULE_ENTRY
{
   LIST_ENTRY le_mod;
   ULONG  unknown[4];
   ULONG  base;
   ULONG  driver_start;
   ULONG  unk1;
   UNICODE_STRING driver_Path;
   UNICODE_STRING driver_Name;
} MODULE_ENTRY, *PMODULE_ENTRY;

const WCHAR DeviceNameBuffer[] = L"\\Device\\SXEDISABLER";
const WCHAR DeviceLinkBuffer[] = L"\\DosDevices\\SXEDISABLER";

PMODULE_ENTRY g_psLoadedModuleList = NULL;
PDEVICE_OBJECT g_RootkitDevice = NULL;
ULONG g_uProcessNameOffset = 0;
NTSTATUS ntStatus = 0;

UCHAR DetourCode[] = "\xE9\x00\x00\x00\x00";
INT DetourSize = 5;

DWORD dwNtCreateThread;
BYTE pbNtCreateThread[5];

DWORD dwNtOpenFile;
BYTE pbNtOpenFile[5];

DWORD dwNtOpenProcess;
BYTE pbNtOpenProcess[5];

DWORD dwNtQuerySystemInformation;
BYTE pbNtQuerySystemInformation[5];

DWORD dwNtSetContextThread;
BYTE pbNtSetContextThread[5];

DWORD dwNtSuspendThread;
BYTE pbNtSuspendThread[5];

DWORD dwNtWriteVirtualMemory;
BYTE pbNtWriteVirtualMemory[5];

//======================================================================================================
// DRIVER CODE
//======================================================================================================
ULONG GetProcessNameOffset( VOID )
{
    ULONG i;

    for(i = 0; i < 3 * PAGE_SIZE; i++)
   {
       if( !strncmp("System", (PCHAR)PsGetCurrentProcess() + i, strlen("System")) )
       {
             return i;
       }
    }

    return 0;
}
//======================================================================================================
ULONG GetProcessName( PCHAR theName )
{
   PEPROCESS curproc;
   char* nameptr;
   ULONG i;

   if( g_uProcessNameOffset )
   {
      curproc = PsGetCurrentProcess();
      nameptr = (PCHAR) curproc + g_uProcessNameOffset;
      strncpy( theName, nameptr, 16 );
      theName[ 16 ] = 0;
      return TRUE;
    }

   return FALSE;
}
//======================================================================================================
VOID RestoreALL( VOID )
{
   __asm
   {
      cli
      push eax
      mov eax, cr0
      and eax, 0xFFFEFFFF
      mov cr0, eax
      pop eax
   }

   //NtCreateThread
   RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0x35], pbNtCreateThread, DetourSize);
   //NtOpenFile
   RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0x74], pbNtOpenFile, DetourSize);
   //NtOpenProcess
   RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0x7A], pbNtOpenProcess, DetourSize);
   //NtQuerySystemInformation
   RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0xAD], pbNtQuerySystemInformation, DetourSize);
   //NtSetContextThread
   RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0xD5], pbNtSetContextThread, DetourSize);
   //NtSuspendThread
   RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0xFE], pbNtSuspendThread, DetourSize);
   //NtWriteVirtualMemory
   RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0x115], pbNtWriteVirtualMemory, DetourSize);

   __asm
   {
      push eax
      mov eax, cr0
      or eax, not 0xFFFEFFFF
      mov cr0, eax
      pop eax
      sti
   }
}
//======================================================================================================
VOID PatchALL( VOID )
{
   __asm
   {
      cli
      push eax
      mov eax, cr0
      and eax, 0xFFFEFFFF
      mov cr0, eax
      pop eax
   }

   //NtCreateThread
   RtlCopyMemory(pbNtCreateThread, KeServiceDescriptorTableShadow[0].ServiceTable[0x35], DetourSize);
   *(DWORD*)(DetourCode+1) = dwNtCreateThread - ( (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0x35] + 5 );
   RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0x35], DetourCode, DetourSize);

   //NtOpenFile
   RtlCopyMemory(pbNtOpenFile, KeServiceDescriptorTableShadow[0].ServiceTable[0x74], DetourSize);
   *(DWORD*)(DetourCode+1) = dwNtOpenFile - ( (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0x74] + 5 );;
   RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0x74], DetourCode, DetourSize);

   //NtOpenProcess
   RtlCopyMemory(pbNtOpenProcess, KeServiceDescriptorTableShadow[0].ServiceTable[0x7A], DetourSize);
   *(DWORD*)(DetourCode+1) = dwNtOpenProcess - ( (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0x7A] + 5 );
   RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0x7A], DetourCode, DetourSize);

   //NtQuerySystemInformation
   RtlCopyMemory(pbNtQuerySystemInformation, KeServiceDescriptorTableShadow[0].ServiceTable[0xAD], DetourSize);
   *(DWORD*)(DetourCode+1) = dwNtQuerySystemInformation - ( (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0xAD] + 5 );
   RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0xAD], DetourCode, DetourSize);

   //NtSetContextThread
   RtlCopyMemory(pbNtSetContextThread, KeServiceDescriptorTableShadow[0].ServiceTable[0xD5], DetourSize);
   *(DWORD*)(DetourCode+1) = dwNtSetContextThread - ( (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0xD5] + 5 );
   RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0xD5], DetourCode, DetourSize);

   //NtSuspendThread
   RtlCopyMemory(pbNtSuspendThread, KeServiceDescriptorTableShadow[0].ServiceTable[0xFE], DetourSize);
   *(DWORD*)(DetourCode+1) = dwNtSuspendThread - ( (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0xFE] + 5 );
   RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0xFE], DetourCode, DetourSize);

   //NtWriteVirtualMemory
   RtlCopyMemory(pbNtWriteVirtualMemory, KeServiceDescriptorTableShadow[0].ServiceTable[0x115], DetourSize);
   *(DWORD*)(DetourCode+1) = dwNtWriteVirtualMemory - ( (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0x115] + 5 );
   RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0x115], DetourCode, DetourSize);

   __asm
   {
      push eax
      mov eax, cr0
      or eax, not 0xFFFEFFFF
      mov cr0, eax
      pop eax
      sti
   }
}
//======================================================================================================
unsigned int getAddressOfShadowTable()
{
   unsigned int i;
   unsigned char *p;
   unsigned int dwordatbyte;
 
   p = (unsigned char*)KeAddSystemServiceTable;
 
   for(i = 0; i < 4096; i++, p++)
   {
      __try
      {
         dwordatbyte = *(unsigned int*)p;
      }
      __except(EXCEPTION_EXECUTE_HANDLER)
      {
         return 0;
      }
 
      if(MmIsAddressValid((PVOID)dwordatbyte))
      {
         if(memcmp((PVOID)dwordatbyte, &KeServiceDescriptorTable, 16) == 0)
         {
            if((PVOID)dwordatbyte == &KeServiceDescriptorTable)
            {
               continue;
            }
 
            return dwordatbyte;
         }
      }
   }
 
   return 0;
}
//======================================================================================================
BOOL getShadowTable()
{
   KeServiceDescriptorTableShadow = (PSERVICE_DESCRIPTOR_TABLE)getAddressOfShadowTable();
 
   if(KeServiceDescriptorTableShadow == NULL)
   {
       return FALSE;
   }
   else
   {
      return TRUE;
    }
}
//=====================================================================================================
NTSTATUS DriverDeviceControl( PFILE_OBJECT FileObject, BOOLEAN Wait, PVOID InputBuffer, ULONG InputBufferLength, PVOID OutputBuffer, ULONG OutputBufferLength, ULONG IoControlCode, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject )
{
   IoStatus->Status = STATUS_SUCCESS;
    IoStatus->Information = 0;

    switch( IoControlCode )
   {
      case IOCTL_DEVICE_INITIALIZE:
      {
         dwNtCreateThread = (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0x35];
         dwNtOpenFile = (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0x74];
         dwNtOpenProcess = (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0x7A];
         dwNtQuerySystemInformation = (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0xAD];
         dwNtSetContextThread = (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0xD5];
         dwNtSuspendThread = (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0xFE];
         dwNtWriteVirtualMemory = (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0x115];
         break;
      }
      case IOCTL_DEVICE_DISABLE:
      {
         PatchALL();
         break;
      }
      case IOCTL_DEVICE_RESTORE:
      {
         RestoreALL();
         break;
      }
      default:
      {
         IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
         break;
      }
   }

    return IoStatus->Status;
}
//======================================================================================================
DWORD FindPsLoadedModuleList(PDRIVER_OBJECT DriverObject)
{
   PMODULE_ENTRY psReturnEntry = NULL;

   if( !DriverObject )
      return 0;

   psReturnEntry = *((PMODULE_ENTRY*)((DWORD)DriverObject + 0x14));

   return (DWORD)psReturnEntry;
}
//======================================================================================================
ULONG UnlinkDriverEntry(PDRIVER_OBJECT DriverObject)
{
   if( g_psLoadedModuleList && DriverObject->DriverStart )
   {
      PMODULE_ENTRY pm_current = g_psLoadedModuleList;

      while((PMODULE_ENTRY)pm_current->le_mod.Flink != g_psLoadedModuleList)
      {
         if ((pm_current->unk1 != 0x00000000) && (pm_current->driver_Path.Length != 0))
         {
            if((ULONG)DriverObject->DriverStart == pm_current->base)
            {
               *((PDWORD)pm_current->le_mod.Blink) = (DWORD)pm_current->le_mod.Flink;
               pm_current->le_mod.Flink->Blink = pm_current->le_mod.Blink;
               return 1;
            }
         }

         pm_current = (MODULE_ENTRY*)pm_current->le_mod.Flink;
      }
   }

   return 0;
}
//=====================================================================================================
NTSTATUS DriverDispatch( PDEVICE_OBJECT DeviceObject, PIRP Irp )
{
   NTSTATUS ntStatus;
    PIO_STACK_LOCATION irpStack;
    PVOID inputBuffer;
    PVOID outputBuffer;
    ULONG inputBufferLength;
    ULONG outputBufferLength;
    ULONG ioControlCode;
   UNICODE_STRING ucDevicelink;

    ntStatus = Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    irpStack = IoGetCurrentIrpStackLocation (Irp);

    inputBuffer = Irp->AssociatedIrp.SystemBuffer;
    inputBufferLength = irpStack->Parameters.DeviceIoControl.InputBufferLength;
    outputBuffer = Irp->AssociatedIrp.SystemBuffer;
    outputBufferLength = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
    ioControlCode = irpStack->Parameters.DeviceIoControl.IoControlCode;

    switch (irpStack->MajorFunction)
   {
      case IRP_MJ_CREATE:
      {
         break;
      }
      case IRP_MJ_SHUTDOWN:
      {
         break;
      }
      case IRP_MJ_CLOSE:
      {
         break;
      }
      case IRP_MJ_DEVICE_CONTROL:
      {
         if( IOCTL_TRANSFER_TYPE(ioControlCode) == METHOD_NEITHER )
         {
            outputBuffer = Irp->UserBuffer;
         }

         ntStatus = DriverDeviceControl( irpStack->FileObject, TRUE, inputBuffer, inputBufferLength, outputBuffer, outputBufferLength, ioControlCode, &Irp->IoStatus, DeviceObject );
         break;
      }
    }

    IoCompleteRequest( Irp, IO_NO_INCREMENT );
    return ntStatus; 
}
//=====================================================================================================
VOID DriverUnload( PDRIVER_OBJECT DriverObject )
{
   UNICODE_STRING ucDeviceLink;
   RtlInitUnicodeString( &ucDeviceLink, DeviceLinkBuffer );
   IoDeleteSymbolicLink( &ucDeviceLink );
   IoDeleteDevice(DriverObject->DeviceObject);
}
//=====================================================================================================
NTSTATUS DriverEntry( PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath )
{
   INT i;
    NTSTATUS ntStatus;
    UNICODE_STRING ucDeviceName;
    UNICODE_STRING ucDeviceLink;

   g_psLoadedModuleList = (PMODULE_ENTRY)FindPsLoadedModuleList( DriverObject );
   g_uProcessNameOffset = GetProcessNameOffset();

   if( !g_psLoadedModuleList || !g_uProcessNameOffset || !getShadowTable() || !UnlinkDriverEntry(DriverObject) )
   {
      return STATUS_UNSUCCESSFUL;
   }

   RtlInitUnicodeString( &ucDeviceName, DeviceNameBuffer );
    RtlInitUnicodeString( &ucDeviceLink, DeviceLinkBuffer );

   ntStatus = IoCreateDevice(DriverObject, 0, &ucDeviceName, FILE_DEVICE_HACK, 0, TRUE, &g_RootkitDevice);

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

   ntStatus = IoCreateSymbolicLink(&ucDeviceLink, &ucDeviceName);
   
   if( !NT_SUCCESS(ntStatus) )
   {
      IoDeleteDevice(DriverObject->DeviceObject);
      return ntStatus;
   }

   for(i = 0; i < IRP_MJ_MAXIMUM_FUNCTION; i++)
   {
        DriverObject->MajorFunction[i] = DriverDispatch;
   }

   DriverObject->DriverUnload = DriverUnload;

   return STATUS_SUCCESS;
}
//=====================================================================================================