hookprint

最新推荐文章于 2023-03-03 09:18:11 发布
最新推荐文章于 2023-03-03 09:18:11 发布
阅读量719 收藏
点赞数
分类专栏： HOOK
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q123456789098/article/details/44516049
版权
// memreadDlg.cpp : implementation file
//
#include <winsock2.h>
#include <ws2tcpip.h>
#include <iphlpapi.h>
#include <stdio.h>
#include <time.h>

#pragma comment(lib, "iphlpapi.lib")
#pragma comment(lib, "ws2_32.lib")


#define PAGE_NONE -1
#pragma comment(lib,"psapi.lib")


#define ELFADD(a,b) (DWORD*)((DWORD)(a) + (DWORD)(b))
#define addptr ELFADD
#define distance(a,b,c) ((DWORD)(a)-(DWORD)(b)+(DWORD)(c))

#define PAGE_SIZE 4096
#define outputdstring debug

/
// CAboutDlg dialog used for App About
/
// CMemreadDlg dialog
/
// CMemreadDlg message handlers
char timestringarr[20]={0};
char*timestring()
{    
     char tmpbuf[128], ampm[] = "AM";
     time_t ltime;
     struct tm *today;
     /* Get UNIX-style time and display as number and string. */
     time( &ltime );
        
     /* Convert to time structure and adjust for PM if necessary. */
     today = localtime( &ltime );
     if( today->tm_hour > 12 )
     {
    strcpy( ampm, "PM" );
    today->tm_hour -= 12;
     }
     if( today->tm_hour == 0 )    /* Adjust if midnight hour. */
    today->tm_hour = 12;

     strcpy(timestringarr,asctime( today ) + 11);
     timestringarr[8]=0;

     return 0;
}

void flog(const char*format,...)
{
    va_list v;
    char buffer[500];
    //SYSTEMTIME  systemtime;
    FILE* fp=NULL;
    char* ppath = "flog.txt";
    
    
    if( (fp=fopen(ppath, "a+"))==NULL)
    {
        return;
    }    
    
    va_start(v,format);
    _vsnprintf(buffer,500,format,v);
    va_end(v);        
    
    fprintf(fp,"[%s]%s\n",timestring(),buffer);        
    
    fclose(fp);    
}

void OutputDebugStringApi(const char*format,...)
{
    va_list v;
    char buffer[500];
    //SYSTEMTIME  systemtime;

    va_start(v,format);
    _vsnprintf(buffer,500,format,v);
    va_end(v);        
    
    OutputDebugStringA(buffer);
}
int rise_pri()
{
    BOOL   rc;
    HANDLE   hToken;
    TOKEN_PRIVILEGES   *pTokenPriv;
    LUID_AND_ATTRIBUTES   la;
    DWORD   Len;
    rc=OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES,&hToken);
    if(rc==FALSE)return   rc;
    LookupPrivilegeValue(NULL,SE_DEBUG_NAME,&la.Luid);
    la.Attributes=SE_PRIVILEGE_ENABLED;
    pTokenPriv   =   new   TOKEN_PRIVILEGES[2];
    pTokenPriv-> PrivilegeCount=1;
    memcpy(pTokenPriv-> Privileges,&la,sizeof(LUID_AND_ATTRIBUTES));
    rc=AdjustTokenPrivileges(hToken,FALSE,pTokenPriv,0,NULL,&Len);
    return   rc;
}

ULONG GetMyFunctionLen(DWORD pfn)
{
    ULONG res = 0;
    __asm
    {
        pushad
            pushfd
        MOV EAX, 0x90909090     // 新的函数以0x90909090作为结束的标志
            MOV ECX, 0xFFFFFFFF
            MOV EDI, pfn
            CLD
            REPNZ SCASD
            NOT ECX
            DEC ECX
            MOV res, ECX
            popfd
            popad
    }
    return res * 4;
}

int makerw(int address,int size,int newmode)
{
    ULONG oldaccessattr = 0;
    //ULONG a;
    if(!    VirtualProtectEx(GetCurrentProcess(),(void*)address,size,PAGE_EXECUTE_READWRITE,&oldaccessattr)){        
            OutputDebugStringA("virtualprotect error");
        return -1;
    }
    //VirtualProtectEx(GetCurrentProcess(),(void*)address,size,PAGE_EXECUTE_READWRITE,&a);
    //outputdstring("address %x --> %x from %x  status %x",address,PAGE_EXECUTE_READWRITE,global_attr,a);

    return oldaccessattr;
}


DWORD Patch_new(DWORD codeaddress,int thisclausebytes, DWORD pfnNewFunction)
{
  ULONG fakefunctionlen,newplacecodelength;
  DWORD SectionGapStart;

  rise_pri();
 
  fakefunctionlen = GetMyFunctionLen( pfnNewFunction);
  OutputDebugStringApi("[Patch_new]functionlen=%d pfnNewFunction=%x codeaddress=%x thisclausebytes=%d",fakefunctionlen,pfnNewFunction,codeaddress,thisclausebytes);
 
  newplacecodelength=fakefunctionlen+thisclausebytes+5;
   
  SectionGapStart = (DWORD)new char[newplacecodelength];
  if (SectionGapStart == NULL)    return 0;

   makerw((int)SectionGapStart,newplacecodelength,0);
   makerw((int)pfnNewFunction,fakefunctionlen,0);

   OutputDebugStringApi("makerw");

   memcpy((void*)SectionGapStart,(void*)pfnNewFunction,fakefunctionlen);
   OutputDebugStringApi("copynewcode.1");
   memcpy((void*)(SectionGapStart+fakefunctionlen),(void*)codeaddress,thisclausebytes);
   OutputDebugStringApi("copyclausecode.1");

   /* 我的机器上的CreateProcessW的代码，是这样了。
    KERNEL32!CreateProcessW
    001B:77E6B252    55    PUSH     EBP
    001B:77E6B253    8BEC    MOV    EBP, ESP
    001B:77E6B255    FF752C    PUSH    DWORD PTR [EBP+2C]
    第二条和第三条指令正好是5Byte的长度，所以，我选择把第二条和第三条改成跳转指令。
    跳转指令码为0xE9，位移计算：目的地址 - 起始地址 - 跳转指令本身的长度。
  */

  *(PUCHAR)((PUCHAR)SectionGapStart +fakefunctionlen+thisclausebytes) = 0xE9;
  *(PULONG)((PUCHAR)SectionGapStart+fakefunctionlen+thisclausebytes+1) = (ULONG)(codeaddress + thisclausebytes)
                                          - (ULONG)(SectionGapStart + fakefunctionlen+thisclausebytes) - 5;
  //__asm CLI                        
  OutputDebugStringApi("[Patch_new]---2---");
  makerw((int)codeaddress,5,0);
  OutputDebugStringApi("[Patch_new]---3---");
  *(PUCHAR)((PUCHAR)codeaddress) = 0xE9;
  *(PULONG)((PCHAR)codeaddress + 1) = (ULONG)SectionGapStart - (ULONG)codeaddress- 5;
  //__asm STI
  //PTE_ENTRY((ULONG)pfnOrig) &= 0xFFD;
  OutputDebugStringApi("[Patch_new]ok");


  return SectionGapStart;
}

char string1[] = "--->condition 1";
char string2[] = "--->condition 2";
char string3[] = "--->condition 3";
char string4[] = "--->condition 4";
char string5[] = "--->condition 5";
char string6[] = "--->condition 6";
char string7[] = "--->condition 7";
char string8[] = "--->condition 8";
char string9[] = "--->condition 9";
char stringA[] = "--->condition A";

DWORD  opfn=(DWORD)OutputDebugString;
__declspec(naked) NewCreateProcessW1()
{
  __asm
  {
    PUSHAD
        pushfd
        lea eax, string1
        push eax
        call opfn
        popfd
    POPAD
    _emit 0x90
    _emit 0x90
    _emit 0x90
    _emit 0x90
    _emit 0x90
    _emit 0x90
    _emit 0x90
    _emit 0x90
    _emit 0x90
    _emit 0x90
    _emit 0x90
    _emit 0x90
    _emit 0x90
  }
}

__declspec(naked) NewCreateProcessW2()
{
    __asm
    {
        PUSHAD
            pushfd
            lea eax, string2
            push eax
            call opfn   
            popfd
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
  }
}

__declspec(naked) condition3()
{
    __asm
    {
        PUSHAD
            pushfd
            lea eax, string3
            push eax
            call opfn
            popfd
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
__declspec(naked) condition4()
{
    __asm
    {
        PUSHAD
            pushfd
            lea eax, string4
            push eax
            call opfn
            popfd
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
__declspec(naked) condition5()
{
    __asm
    {
        PUSHAD
            pushfd
            lea eax, string5
            push eax
            call opfn  
            popfd
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
__declspec(naked) condition6()
{
    __asm
    {
        PUSHAD
            pushfd
            lea eax, string6
            push eax
            call opfn
            popfd
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
__declspec(naked) condition7()
{
    __asm
    {
        PUSHAD
            pushfd
            lea eax, string7
            push eax
            call opfn   
            popfd
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
__declspec(naked) condition8()
{
    __asm
    {
        PUSHAD
            pushfd
            lea eax, string8
            push eax
            call opfn  
            popfd
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
__declspec(naked) condition9()
{
    __asm
    {
        PUSHAD
            pushfd
            lea eax, string9
            push eax
            call opfn  
            popfd
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
__declspec(naked) conditionA()
{
    __asm
    {
        PUSHAD
            pushfd
            lea eax, stringA
            push eax
            call opfn
            popfd
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
void __stdcall printebpwidestring(WCHAR* ebpoffsetstringptr)
{
    OutputDebugStringW(ebpoffsetstringptr);
}
void __stdcall printebpansistring(char* ebpoffsetstringptr)
{
    OutputDebugStringA(ebpoffsetstringptr);
}
void __stdcall printbuffer(unsigned char* data)
{
    char buffer[50];
    int i=0;
     sprintf(buffer,"%.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x",data[i],data[i+1],data[i+2],data[i+3],data[i+4],data[i+5],data[i+6],data[i+7]);
    OutputDebugStringA(buffer);
    i+=8;
    sprintf(buffer,"%.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x",data[i],data[i+1],data[i+2],data[i+3],data[i+4],data[i+5],data[i+6],data[i+7]);
    OutputDebugStringA(buffer);
    i+=8;
    sprintf(buffer,"%.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x",data[i],data[i+1],data[i+2],data[i+3],data[i+4],data[i+5],data[i+6],data[i+7]);
    OutputDebugStringA(buffer);
    i+=8;
    sprintf(buffer,"%.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x",data[i],data[i+1],data[i+2],data[i+3],data[i+4],data[i+5],data[i+6],data[i+7]);
    OutputDebugStringA(buffer);
    i+=8;
    sprintf(buffer,"%.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x",data[i],data[i+1],data[i+2],data[i+3],data[i+4],data[i+5],data[i+6],data[i+7]);
    OutputDebugStringA(buffer);
    i+=8;
    sprintf(buffer,"%.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x",data[i],data[i+1],data[i+2],data[i+3],data[i+4],data[i+5],data[i+6],data[i+7]);
    OutputDebugStringA(buffer);
    i+=8;
    sprintf(buffer,"%.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x",data[i],data[i+1],data[i+2],data[i+3],data[i+4],data[i+5],data[i+6],data[i+7]);
    OutputDebugStringA(buffer);
    i+=8;
    sprintf(buffer,"%.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x",data[i],data[i+1],data[i+2],data[i+3],data[i+4],data[i+5],data[i+6],data[i+7]);
    OutputDebugStringA(buffer);
    i+=8;
    sprintf(buffer,"%.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x",data[i],data[i+1],data[i+2],data[i+3],data[i+4],data[i+5],data[i+6],data[i+7]);
    OutputDebugStringA(buffer);
    i+=8;
    sprintf(buffer,"%.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x",data[i],data[i+1],data[i+2],data[i+3],data[i+4],data[i+5],data[i+6],data[i+7]);
    OutputDebugStringA(buffer);
    i+=8;
    sprintf(buffer,"%.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x",data[i],data[i+1],data[i+2],data[i+3],data[i+4],data[i+5],data[i+6],data[i+7]);
    OutputDebugStringA(buffer);
}
typedef void (__stdcall* printebpwidestring_T)(WCHAR* ebpoffsetstringptr);
typedef void (__stdcall* printebpansistring_T)(char* ebpoffsetstringptr);

DWORD ebpoffsetwide = 0;
DWORD ebpoffsetansi = 0;
printebpwidestring_T fn_printebpwidestring = printebpwidestring;
printebpansistring_T fn_printebpansistring = printebpansistring;
__declspec(naked) _printwidestringonebp()
{
    __asm
    {
        PUSHAD
            pushfd
            mov eax, ebpoffsetwide
            sub ebp,eax
            mov eax,[ebp]
            push eax
            call fn_printebpwidestring  
            popfd
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
__declspec(naked) _printasnistringonebp()
{
    __asm
    {
        PUSHAD
            pushfd
            mov eax, ebpoffsetansi
            sub ebp,eax
            mov eax,[ebp]
            push eax
            call fn_printebpansistring
            popfd
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
#define  GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS         (0x04)  // lpModuleName是模块中的一个地址
    typedef BOOL (WINAPI* GetModuleHandleExA_T)(
                    DWORD        dwFlags,
                    LPCSTR     lpModuleName,
                    HMODULE*    phModule
                    );
    HMODULE getmodulename(char* buffer,int size,void* addri)
    {
        HMODULE hmodule;
        char FileName[MAX_PATH] = {0};
        GetModuleHandleExA_T GetModuleHandleExA=(GetModuleHandleExA_T)GetProcAddress(GetModuleHandle("kernel32.dll"),"GetModuleHandleExA");
        GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (LPCSTR)addri, &hmodule);
        GetModuleFileNameA(hmodule, buffer, size);
        return hmodule;
}
void __stdcall printval(DWORD a)
{
    char cc[50];
    OutputDebugStringA("-------printval-------");
//     char buffer[300];
//     HMODULE hmod = getmodulename(buffer,300,(void*)a);
    sprintf(cc,"printval %x",a);
//    OutputDebugStringA(buffer);
    OutputDebugStringA(cc);
    OutputDebugStringA("-------printval end-------");
}

typedef void (__stdcall* printval_T)(DWORD a);

DWORD stackvaraddress = 0;
DWORD globalvaraddress = 0;
DWORD ecxoffsetaddress = 0;

printval_T fn_printval = printval;
DWORD offset_ecx_class_wide = 0;
__declspec(naked) _printwidestringecxclass()
{
    __asm
    {
        PUSHAD
            pushfd
            mov eax, offset_ecx_class_wide
            add eax,ecx
            mov eax,[eax]
             push eax
            call fn_printebpwidestring
            popfd
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
DWORD offset_ecx_class_ansi = 0;
__declspec(naked) _printansistringecxclass()
{
    __asm
    {
        PUSHAD
            pushfd
            mov eax, offset_ecx_class_ansi
            add eax,ecx
            mov eax,[eax]
            push eax
            call fn_printebpansistring
            popfd
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
__declspec(naked) _printecxclassmember()
{
    __asm
    {
        PUSHAD
            pushfd
            mov eax, ecxoffsetaddress
            add eax,ecx
            push eax
            call fn_printval
            popfd
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
__declspec(naked) _printstackvar()
{
    __asm
    {
        PUSHAD
            mov eax, stackvaraddress
            sub ebp,eax
            mov eax,[ebp]
            push eax
            call fn_printval   
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
__declspec(naked) _printglobalvar()
{
    __asm
    {
        PUSHAD
            mov eax, globalvaraddress
             mov eax,[eax]
            push eax
            call fn_printval   
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}

void __stdcall print_regs(int eax,int ebx,int ecx,int edx,int esi,int edi,int ebp)
{
    char buffer[200];
    sprintf(buffer,"eax=%x ebx=%x ecx=%x edx=%x esi=%x edi=%x ebp=%x",eax,ebx,ecx,edx,esi,edi,ebp);
    OutputDebugStringA(buffer);
}

DWORD  fnprint_regs=(DWORD)print_regs;
__declspec(naked) printregs()
{
    __asm
    {
        PUSHAD
            push ebp
            push edi
            push esi
            push edx
            push ecx
            push ebx
            push eax
            call fnprint_regs   
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
void __stdcall print_8eax(int eax)
{
    char buffer[30];
    sprintf(buffer,"[%x]=%x",eax,*(DWORD*)eax);
    OutputDebugStringA(buffer);
}
DWORD  fnprint_8eax=(DWORD)print_8eax;
__declspec(naked) printLeax()
{
    __asm
    {
        PUSHAD
             push eax
            call fnprint_8eax   
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
__declspec(naked) printLebx()
{
    __asm
    {
        PUSHAD
             push ebx
            call fnprint_8eax   
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
__declspec(naked) printLecx()
{
    __asm
    {
            PUSHAD
             push ecx
            call fnprint_8eax   
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
__declspec(naked) printLedx()
{
    __asm
    {
        PUSHAD
            push edx
            call fnprint_8eax   
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
__declspec(naked) printLesi()
{
    __asm
    {
        PUSHAD
             push esi
            call fnprint_8eax   
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
__declspec(naked) printLedi()
{
    __asm
    {
        PUSHAD
             push edi
            call fnprint_8eax   
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
__declspec(naked) printLebp()
{
    __asm
    {
        PUSHAD
             push ebp
            call fnprint_8eax   
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
void __stdcall print_stack(DWORD* esp)
{
    char buffer[30];
    int i;
    for(i=0;i<64;i++){
     sprintf(buffer,"[%x]=%x",&esp[i],esp[i]);
     OutputDebugStringA(buffer);
    }
}
DWORD fnprint_stack=(DWORD)print_stack;
__declspec(naked) printstack()
{
    __asm
    {
        PUSHAD
            push ebp
            call fnprint_stack   
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}

void __stdcall print_eax_ansistring(char* eax)
{
    OutputDebugStringA("-----print_eax_ansistring +------------");
      OutputDebugStringA(eax);
    OutputDebugStringA("-----print_eax_ansistring -------------");

}
DWORD fn_printeax_ansistring=(DWORD)print_eax_ansistring;
__declspec(naked) printeaxansistring()
{
    __asm
    {
            PUSHAD
            pushfd
            push eax
            call fn_printeax_ansistring  
            popfd
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}

void __stdcall print_ecx_ansistring(char* ecx)
{
    OutputDebugStringA("-----print_ecx_ansistring +------------");
    OutputDebugStringA(ecx);
    OutputDebugStringA("-----print_ecx_ansistring -------------");
    
}
DWORD fn_printecx_ansistring=(DWORD)print_ecx_ansistring;
__declspec(naked) printecxansistring()
{
    __asm
    {
            PUSHAD
            pushfd
            push ecx
            call fn_printecx_ansistring  
            popfd
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}





void  __stdcall hook_cond1(DWORD  addresshook,int instructionlen)
{
    DWORD temp = (DWORD)NewCreateProcessW1;
#ifdef _DEBUG
    DWORD* ptr =(DWORD*) (temp+1);
    temp = temp+5+ptr[0];
#endif
    Patch_new(addresshook,instructionlen,temp);
}
void __stdcall hook_cond2(DWORD  addresshook,int instructionlen)
{
    Patch_new(addresshook,instructionlen,(DWORD)NewCreateProcessW2);
}
void __stdcall hook_cond3(DWORD  addresshook,int instructionlen)
{
    Patch_new(addresshook,instructionlen,(DWORD)condition3);
}
void __stdcall hook_cond4(DWORD  addresshook,int instructionlen)
{
    Patch_new(addresshook,instructionlen,(DWORD)condition4);
}
void __stdcall hook_cond5(DWORD  addresshook,int instructionlen)
{
    Patch_new(addresshook,instructionlen,(DWORD)condition5);
}
void __stdcall hook_cond6(DWORD  addresshook,int instructionlen)
{
    Patch_new(addresshook,instructionlen,(DWORD)condition6);
}
void __stdcall hook_cond7(DWORD  addresshook,int instructionlen)
{
    Patch_new(addresshook,instructionlen,(DWORD)condition7);
}
void __stdcall hook_cond8(DWORD  addresshook,int instructionlen)
{
    Patch_new(addresshook,instructionlen,(DWORD)condition8);
}
void __stdcall hook_cond9(DWORD  addresshook,int instructionlen)
{
    Patch_new(addresshook,instructionlen,(DWORD)condition9);
}
void __stdcall hook_condA(DWORD  addresshook,int instructionlen)
{
    Patch_new(addresshook,instructionlen,(DWORD)conditionA);
}

void __stdcall hook_printregs(DWORD  addresshook,int instructionlen)
{
    Patch_new(addresshook,instructionlen,(DWORD)printregs);
}
void __stdcall hook_printstack(DWORD  addresshook,int instructionlen)
{
    Patch_new(addresshook,instructionlen,(DWORD)printstack);
}
void __stdcall hook_printmemeax(DWORD  addresshook,int instructionlen)
{
    Patch_new(addresshook,instructionlen,(DWORD)printLeax);
}
void __stdcall hook_printeaxansistring(DWORD  addresshook,int instructionlen)
{
    Patch_new(addresshook,instructionlen,(DWORD)printeaxansistring);
}
void __stdcall hook_printecxansistring(DWORD  addresshook,int instructionlen)
{
    Patch_new(addresshook,instructionlen,(DWORD)printecxansistring);
}
void __stdcall hook_printmemebx(DWORD  addresshook,int instructionlen)
{
    Patch_new(addresshook,instructionlen,(DWORD)printLebx);
}
void __stdcall hook_printmemecx(DWORD  addresshook,int instructionlen)
{
    Patch_new(addresshook,instructionlen,(DWORD)printLecx);
}
void __stdcall hook_printmemedx(DWORD  addresshook,int instructionlen)
{
    Patch_new(addresshook,instructionlen,(DWORD)printLedx);
}
void __stdcall hook_printmemesi(DWORD  addresshook,int instructionlen)
{
    Patch_new(addresshook,instructionlen,(DWORD)printLesi);
}
void __stdcall hook_printmemedi(DWORD  addresshook,int instructionlen)
{
    Patch_new(addresshook,instructionlen,(DWORD)printLedi);
}
void __stdcall hook_printmemebp(DWORD  addresshook,int instructionlen)
{
    Patch_new(addresshook,instructionlen,(DWORD)printLebp);
}
void __stdcall hook_printasnistringonebp(DWORD  addresshook,int instructionlen,DWORD offset)
{
    ebpoffsetansi = offset;
    Patch_new(addresshook,instructionlen,(DWORD)_printasnistringonebp);
}
void __stdcall hook_printwidestringonebp(DWORD  addresshook,int instructionlen,DWORD offset)
{
    ebpoffsetwide = offset;
    Patch_new(addresshook,instructionlen,(DWORD)_printwidestringonebp);
}
void __stdcall hook_printglobalvar(DWORD  addresshook,int instructionlen,DWORD address)
{
    globalvaraddress = address;
    Patch_new(addresshook,instructionlen,(DWORD)_printglobalvar);
}
void __stdcall hook_printstackvar(DWORD  addresshook,int instructionlen,DWORD address)
{
    stackvaraddress = address;
    Patch_new(addresshook,instructionlen,(DWORD)_printstackvar);
}
void __stdcall hook_printecxclassmember(DWORD  addresshook,int instructionlen,DWORD address)
{
    ecxoffsetaddress = address;
    Patch_new(addresshook,instructionlen,(DWORD)_printecxclassmember);
}
void __stdcall hook_printwidestringecxclass(DWORD  addresshook,int instructionlen,DWORD address)
{
    offset_ecx_class_wide = address;
    Patch_new(addresshook,instructionlen,(DWORD)_printwidestringecxclass);
}

void __stdcall hook_printansistringecxclass(DWORD  addresshook,int instructionlen,DWORD address)
{
    offset_ecx_class_ansi = address;
    Patch_new(addresshook,instructionlen,(DWORD)_printansistringecxclass);
}
DWORD offset_stack_printebpindirectwidestring=0;
DWORD offset_indirect_printebpindirectwidestring=0;
__declspec(naked) _printebpindirectwidestring()
{
    __asm
    {
        PUSHAD
            mov eax, offset_stack_printebpindirectwidestring
            sub ebp,eax
            mov eax,[ebp]
            mov ebx,offset_indirect_printebpindirectwidestring
            add eax,ebx
            mov eax,[eax]
            push eax
            call fn_printebpwidestring   
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
void __stdcall hook_printebpindirectwidestring(DWORD  addresshook,int instructionlen,DWORD stackoffset,DWORD classoffset)
{
    offset_stack_printebpindirectwidestring = stackoffset;
    offset_indirect_printebpindirectwidestring = classoffset;
    Patch_new(addresshook,instructionlen,(DWORD)_printebpindirectwidestring);
}
DWORD offset_stack_printansistringstackvarclass=0;
DWORD offset_class_printansistringstackvarclass=0;
__declspec(naked) _printansistringstackvarclass()
{
    __asm
    {
        PUSHAD
            mov eax, offset_stack_printansistringstackvarclass
            sub ebp,eax
            mov eax,[ebp]
            mov ebx,offset_class_printansistringstackvarclass
            add eax,ebx
            mov eax,[eax]
            push eax
            call fn_printebpansistring   
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
void __stdcall hook_printansistringstackvarclass(DWORD  addresshook,int instructionlen,DWORD stackoffset,DWORD classoffset)
{
    offset_stack_printansistringstackvarclass = stackoffset;
    offset_class_printansistringstackvarclass = classoffset;
    Patch_new(addresshook,instructionlen,(DWORD)_printansistringstackvarclass);
}
DWORD offset_stack_offset=0;
DWORD offset_stack_offset2=0;
__declspec(naked) _printstackvarIndirectVal()
{
    __asm
    {
        PUSHAD
            mov eax, offset_stack_offset
            sub ebp,eax
            mov eax,[ebp]
            mov ebx,offset_stack_offset2
            add eax,ebx
            mov eax,[eax]
            push eax
            call fn_printval   
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
void __stdcall hook_printstackvarIndirectVal(DWORD  addresshook,int instructionlen,DWORD stackoffset,DWORD indirectoffset)
{
    offset_stack_offset = stackoffset;
    offset_stack_offset2 = indirectoffset;
    Patch_new(addresshook,instructionlen,(DWORD)_printstackvarIndirectVal);
}

typedef void (__stdcall*fn_printbuffer_T)(unsigned char* databuffer);
fn_printbuffer_T fn_printbuffer=printbuffer;
DWORD offset_ebp_base=0;
__declspec(naked) _printebpbasebuffer()
{
    __asm
    {
        PUSHAD
            mov eax, offset_ebp_base
            sub ebp,eax
            mov eax,[ebp]
            push eax
            call fn_printbuffer   
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
void __stdcall hook_printebpbasebuffer(DWORD  addresshook,int instructionlen,DWORD stackoffset)
{
    offset_ebp_base = stackoffset;
    Patch_new(addresshook,instructionlen,(DWORD)_printebpbasebuffer);
}
 DWORD offset_ebp_base_printbuffer=0;
 DWORD offset_ebp_indirect_base_printbuffer=0;

__declspec(naked) _printebpindirectbuffer()
{
    __asm
    {
        PUSHAD
            mov eax, offset_ebp_base_printbuffer
            sub ebp,eax
            mov eax,[ebp]
            mov ebx,offset_ebp_indirect_base_printbuffer
            add eax,ebx
            mov eax,[eax]
            push eax
            call fn_printbuffer   
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
void __stdcall hook_printebpindirectbuffer(DWORD  addresshook,int instructionlen,DWORD stackoffset,int indirectoffset)
{
    offset_ebp_base_printbuffer = stackoffset;
    offset_ebp_indirect_base_printbuffer = indirectoffset;
    Patch_new(addresshook,instructionlen,(DWORD)_printebpindirectbuffer);
}
DWORD offset_fn_parameter=0;
DWORD offset_indirect_fn_parameter=0;
__declspec(naked) _printfnparamterwidestringindirect()
{
    __asm
    {
        PUSHAD
            mov eax, offset_fn_parameter
            add ebp,eax
            mov eax,[ebp]
            mov ebx,offset_indirect_fn_parameter
            add eax,ebx
            mov eax,[eax]
            push eax
            call fn_printebpwidestring   
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
void __stdcall hook_printfnparamterwidestringindirect(DWORD  addresshook,int instructionlen,DWORD stackoffset,int indirectoffset)
{
    offset_fn_parameter = stackoffset;
    offset_indirect_fn_parameter = indirectoffset;
    Patch_new(addresshook,instructionlen,(DWORD)_printfnparamterwidestringindirect);
}
DWORD offset_fn_parameter_int=0;
__declspec(naked) _printfnparamterDec()
{
    __asm
    {
        PUSHAD
            mov eax, offset_fn_parameter_int
            add ebp,eax
            mov eax,[ebp]
             push eax
            call fn_printval   
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
void __stdcall hook_printfnparamterDec(DWORD  addresshook,int instructionlen,DWORD decoffset)
{
    offset_fn_parameter_int = decoffset;
     Patch_new(addresshook,instructionlen,(DWORD)_printfnparamterDec);
}
DWORD offset_get_eax_offset_val=0;
__declspec(naked) _printeaxoffsetval()
{
    __asm
    {
        PUSHAD
            mov ebx, offset_fn_parameter_int
            add ebx,eax
            mov ebx,[ebx]
            push ebx
            call fn_printval   
            POPAD
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
            _emit 0x90
    }
}
void __stdcall hook_printeaxoffsetval(DWORD  addresshook,int instructionlen,DWORD decoffset)
{
    offset_get_eax_offset_val = decoffset;
    Patch_new(addresshook,instructionlen,(DWORD)_printeaxoffsetval);
}
q123456789098
关注
专栏目录
不依赖插件 给 Unity 项目接入 Lua
杂七杂八
01-20 1445
之前在公司给项目接入过 xLua .接入过程非常傻瓜. 又了解到 Unity 由于历史原因，有各种各样的 lua 接入插件。 slua,xlua,tolua 等等层出不穷。 如果是为了直接在 Unity 项目里使用 Lua,使用现成的插件肯定是最好的选择。如果是为了学习，就需要自己亲手实践一番 之前并不了解 unity 接入 lua 的原理 。 最近通过公司的项目，查阅看官方文档，了解到 Unit...
HookPrintf.rar
11-18
有时需要在UI程序中使用printf（），本程序通过HOOK CRT库来达到目的。
pytorch forward_pytorch使用hook打印中间特征图、计算网络算力等
weixin_39758696的博客
11-22 668
0、参考https://oldpan.me/archives/pytorch-autograd-hookhttps://pytorch.org/docs/stable/search.html?q=hook&check_keywords=yes&area=defaulthttps://github.com/pytorch/pytorch/issues/598https://githu...
python hook系统方法print，使得所有输出带上时间戳
聆听风雨的博客
11-12 891
hook print，使得所有的print带上时间戳
实操官方例子 Frida Hook EXE 以 printf 为例
KD的疯狂实验室
06-14 2566
直接自己写一个printf 然后 hook它,并且解决了 js 和 py 代码混在一起 不能高亮的问题
用Apihook实现的打印监控
05-23
用Apihook实现的打印监控 拦截startDoc函数-Implemented by the print control block Apihook startDoc function
api hook writeprinter例子(系统API)
10-29
包括2个实例，第一个是api hook入门详细介绍，钩自己写的API例子，第二个是钩系统API的例子，非常详细，有测试源码，认证看完肯定明白其中原理，相信我，有什么不明白留言，一一回复！
前端hook项目pc总结笔记-打印实现局部打印
最新发布
qq_41632427的博客
03-03 100
前端
printhookprocl
10-29 282
      函数功能：该挂钩函数是一个由应用程序或库定义的回调函数，此回调函数与PrintDlg函数一起使用。    函数接收指定给Print公共对话框的缺省对话框函数的消息和通知。LPPWTHOOKPROC类型定义了一个指向此回调函数的指针。PrintHookProc为由应用程序或库定义的函数名的位置占有者。    函数原型：UINT CALLBACK PrintHookProc（HWND hd
基于51单片机的printf函数的实现
12-16
利用51单片机C语言实现printf函数的功能，带PROTEUS仿真源文件，带源程序。
【HttpRunner学习总结2】---- hook机制 钩子函数
CSDN_mayan的博客
06-10 883
HttpRunner 已实现了全新的 hook 机制，可以在请求前和请求后调用钩子函数。hook 机制分为两个层级：运行测试用例层面、运行请求层面 。 2.运行请求层面（RunRequest） 在 pytest 测试用例的 中新增关键字 和 。 三、编写 hook 函数 hook 函数的定义放置在项目的 中，在 pytest/YAML/JSON 中调用 hook 函数仍然是采用 的形式。对于测试用例层面的 hook 函数，与 YAML/JSON 中自定义的函...
第八课 函数
ninthsky09的博客
07-22 94
0 可变对象 数据最终放在内存中。每个对象都保存了三个数据。 1.id（标识） 2.type（类型） 3. value （值） 关于可变对象的修改，可以参考下面程序理解： a =[1,2,3] #首先给a赋值列表，1，2，3 print(a,id(a)) #打印a，和a的id a[0]=6 #换掉列表a的第一个值，改为6 print(a,id(a)) #打印a，和a的id，a的id和之前的一样。 a =[4,5,6] #给a重新赋值列表 print(a,id(a)) #打印a，和a的id，a的id和之前不一
C语言中钩子函数使用讲解
咸鱼弟的博客
10-05 6782
钩子(hook)又称钩子函数，是在一个有序的周期中的某些特殊时刻，系统内部预先设置好的函数，当系统周期到达指定时刻 会自动执行该'钩子'。钩子函数的函数体内容由开发者编写，这绐了幵发者在不同阶段做某些处理的机会。
数据结构与算法 第八天常见排序+冒泡排序+快速排序+文件IO+大数据排序+文件合并
m0_45463480的博客
04-30 686
数据结构与算法 第七天常见排序+冒泡排序+快速排序+大数据排序 第一章 冒泡排序 【1】Bubble_Sort.c 第二章 快速排序 【1】quick_sort.c 第三章 大数据排序 【1】calloc 【2】malloc 【3】readlloc 【4】文件IO操作 【4.1】fprintf 【4.2】fscanf 【4.3】fnprintf 【4.4】rename 和remove函数
Linux hook函数简单实践
marvel的专栏
09-27 1635
#起因 最近对hook函数比较感兴趣，希望能捕获所有某种系统调用，看网上有一篇文章（http://opensourceforu.com/2011/08/lets-hook-a-library-function/） 介绍hook malloc函数，但可能内核实现不同，4.4.0上有问题。特写一篇文章进行更新。 原文中，hook函数中调用printf，其实printf、fprintf等函数都会...
WinAPI:PrintDIg、PrintHookProc
一只奔跑的蚂蚁
11-02 863
一、PrintDIg     函数功能：该函数显示打印对话框或打印设置对话框。打印对话框使用户指定特殊的打印工作的特点。     打印设置对话框不能应用在新应用程序中，它已经被PageSetupDlg函数创建的打印设置公共对话框所替代。     函数原型：BOOL PrintDIg（LPPRINTDLG Ippd）；     参数：     Ippd：指向一个含有初始化对
游戏修改器制作教程八：D3D函数hook
热门推荐
El Psy Congroo
10-06 1万+
本章介绍怎么hook D3D函数，实现在游戏画面中显示自己的文字
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值