你可以打开cmd, 然后 start 命令来启动进程，这样创建的进程就会受到YASVPS的限制

附上一个头文件。。定义了相关的数据结构

#pragma once

// ucReseaon :
//
// Basic
//
#define YASVPS_CREATE_FILE     0x00

#define YASVPS_MOVE_FILE       0x01
#define YASVPS_REPLACE_FILE    0x02
#define YASVPS_RENAME_FILE     0x03
#define YASVPS_WRITE_FILE      0x04

//
//Option
//
#define YASVPS_SETFILE_BASICINFO 0x05
#define YASVPS_SETFILE_ENDINFO   0x06
#define YASVPS_SETFILE_POSINFO   0x07
#define YASVPS_SETFILE_SECINFO   0x08

//
//删除以存在文件时追踪,
//对已存在文件的删除是不可恢复的，所以这个链表跟进程的生命周期一样，而且只能添加节点不能删除。
//
typedef struct __YASVPS_DELETETRACE
{
struct __YASVPS_DELETETRACE* lpNext;
ULONG uPid;
ULONG uNew;
CHAR lpszDelFilePath[YASVPS_MAX_PATH];

}YASVPS_DELETETRACE, *PYASVPS_DELETETRACE;

//
//创建新文件时追踪,添加节点前，先判断文件是否 “删除文件追踪” 存在，若存在，则删除对应节点
//删除文件时，需要查找这个表的信息，如果发现删除的是自己创建的文件，则允许删除。并删除相关跟踪节点
//同样的任何修改文件也需要先找这张表
//外界不应该操作在YASVPS中运行进程创建的文件。
//

/*
dir 规则：
如果在枚举目录文件时， “删除以存在文件” 中有文件在对应的目录中。
如果在YASVPS_CREATEFILETRACE 没有相应节点，则过滤掉删除的文件，不显示
否则显示之
*/

/*
覆盖文件：
覆盖新创建文件： 直接允许
覆盖已存在文件： 相当于 删除原来存在的文件，再创建一个新的文件。
*/

/*
移动已存在文件： eg: c:\123.exe --->> c:\windows\123.exe --->> c:\123.exe
相当于删除文件再创建文件。
*/

//
//修改以存在文件时追踪。删除下面匹配的文件时，相应节点也要删除。
//

typedef struct __YASVPS_CREATETRACE
{

//
//任何修改文件也需要先找这张表,再根据 ucReseaon 做相应的操作
//

struct __YASVPS_CREATETRACE* lpNext;

ULONG uPid; //进程PID
HANDLE hFile;
PFILE_OBJECT lpFileObj; //保留

/*
    ucReseaon :
    #define YASVPS_CREATE_FILE     0x00
    #define YASVPS_MOVE_FILE       0x01
    #define YASVPS_REPLACE_FILE    0x02
    #define YASVPS_RENAME_FILE     0x03
    #define YASVPS_WRITE_FILE      0x04
*/

UCHAR ucReseaon;

/*
ucReseaon = YASVPS_CREATE_FILE
eg:    lpszCreatePath : C:\123.exe
重定向 lpszTracePath : C:\YasVPS\C:\123.exe
之后 修改名字为 hello.exe 则 lpszCreatePath : C:\hello.exe
对YASVPS_CREATE_FILE 文件的操作，都直接PASS， 删除文件时，需要删除lpszLinkPath,
并删除对应YASVPS_CREATETRACE节点

    “外界不应该操作在YASVPS中运行进程创建的文件！！！！！”
*/

//
//重命名/移动文件/覆盖文件/创建后后新的路径
//
CHAR lpszNewPath[YASVPS_MAX_PATH];
//
//指向的原始路径, 当该文件被写时，这个地方为TMP文件,写的文件不能超过10M(*)
//
CHAR lpszLinkPath[YASVPS_MAX_PATH];
                                    
//
//下面的暂时保留，不支持，主要是从效率和节省内存考虑
//
/* FILE_BASIC_INFORMATION stFileBasicInfo;
FILE_END_OF_FILE_INFORMATION szFileEndInfo;
*/
}YASVPS_CREATETRACE, *PYASVPS_CREATETRACE;

可执行文件下载

SHFileOperation(&lpsh);
SHELL32!MoveCopyDriver
SHELL32!DTBuild
SHELL32!DTPathToDTNode
FindFirstFileExW

它确定文件存在不是OPENFILE，而是用 FindFirstFileExW
RtlDosPathNameToNtPathName_U ， 取得目录和 文件名。
NtOpenFile 目录，并把句柄传入 ZwQueryDirectoryFile， IN PUNICODE_STRING FileName OPTIONAL 为文件名，这个平时很少注意，这样它是根据 ZwQueryDirectoryFile来确定文件是否存在的，
在FSD中。文件名为 QUERY_DIRECTORY：：FileName，不为NULL了。
typedef struct tag_QUERY_DIRECTORY
{
ULONG Length;
PUNICODE_STRING FileName;
FILE_INFORMATION_CLASS FileInformationClass;
ULONG FileIndex;
} QUERY_DIRECTORY, *PQUERY_DIRECTORY;

提取到的FILE_OBJECT得路径也只能是目录了。

关于是什么用。。可能你做某些东西时会碰到这样的问题。。贴出来SHARE下。。

使用，用一个loader把yastr.dll注入到目标进程就可以。。。dbgview看输出信息。。
可以获取到的信息
线程的CONTEXT, 调用栈， SEH处理，栈的开始和结束。
进程堆得信息。

yastr.dll会替换掉异常处理函数，所以程序出错时会获得通知。

下图是下面xXXX代码的输出

HANDLE hHeap;
   hHeap = HeapCreate(HEAP_GENERATE_EXCEPTIONS, 0x10000, 0xfffff);

   char* buf = (char*)HeapAlloc(hHeap, 0,2);
   printf("mybuf addr = %p\n",buf);

CopyMemory( buf, mybuf, 100); // 堆问题

   CHAR sz0[6]；

   strcpy( sz0, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");//栈问题

下载

   我们要知道，EIP指向的是可执行节，否则我们可以认为这是一次恶意攻击。SHELLCODE一般是会调用一些系统调用的

，我们可以从这里入手来检测。
栈回溯： 通过HOOK常见的API，判断其返回地址来判断。
           缺点： 一些API没HOOK（没HOOK W版本，或者漏了NTDLL.DLL)，伪造EBP。
这里我们提出一种办法来检测。
首先，API是在某个模块里，一般搜索API会使用到 某个模块的基地址
1 通过PEB获取。
2 SEH获得：默认的异常处理函数时在KERNEL32.DLL里面的，SEH链最后一个异常处理函数的地址，以64K对齐向上查

找MZ标记获取基地址
3 TEB： TEB(FS:[0X18]) + 0X1C是kernel32的地址空间，接着搜MZ标记。

我们重点是针对第一种办法，后面俩中我们去掉MZ标记就可以了。
去掉MZ标记
BOOL NO_MZ_PE(ULONG pid)
{
HANDLE hModuleSnap = INVALID_HANDLE_VALUE;
MODULEENTRY32 me32;
HANDLE hProcess;
ULONG Modulebase, dwOldProtect = 0;;
USHORT ReadFromProcess=0,WriteToMemory=0;

hProcess = OpenProcess(PROCESS_ALL_ACCESS,TRUE,pid);
if(hProcess==NULL)
{
   printf("failed to open process!!\n");
   return FALSE;
}

hModuleSnap = CreateToolhelp32Snapshot( TH32CS_SNAPMODULE, pid );
if( hModuleSnap == INVALID_HANDLE_VALUE )
{
   printf("CreateToolhelp32Snapshot failed!!\n");
   return( FALSE );
}

me32.dwSize = sizeof( MODULEENTRY32 );
if( !Module32First( hModuleSnap, &me32 ) )
{
   CloseHandle( hModuleSnap );
   return( FALSE );
}
do
{
   if(!strcmpi(me32.szModule,"kernel32.dll"))
   {
    Modulebase=(DWORD)me32.modBaseAddr;
    printf("module :%s found at :%x\n","kernel32.dll",Modulebase);
    break;
   }
} while( Module32Next( hModuleSnap, &me32 ) );

VirtualProtectEx(hProcess,(PVOID)Modulebase, 2, PAGE_READWRITE, &dwOldProtect);

if(!WriteProcessMemory(hProcess,(PVOID)Modulebase, (void *)&WriteToMemory, 2, NULL))
   printf("Write MZ Failed!!\n");

ReadProcessMemory(hProcess,
           (LPCVOID)((char*)(Modulebase+0x3c)), //Offset To NT Header
      &ReadFromProcess,
      sizeof(USHORT),
      NULL);

VirtualProtectEx(hProcess,(PVOID)(Modulebase+ReadFromProcess), 2, PAGE_READWRITE, &dwOldProtect);
if(!WriteProcessMemory(hProcess,(PVOID)(Modulebase+ReadFromProcess), (void *)&WriteToMemory, 2, NULL))
   printf("Write MZ Failed!!\n");

CloseHandle(hProcess);
CloseHandle( hModuleSnap );
return( TRUE );
}

通过PEB获取基地址比较简单，很多SHELLCODE都用。
返回地址异常的判断
1 根据 NT_TIB中的栈信息： 不可靠，可被修改
2 根据EBP+X来得到返回地址判断所在模块，不可靠，因为SHELLCODE可能复制到.DATA段

我们简单的这么认为： EIP不是在已知的模块内，或者在可读可写（非.TEXT之类的），栈内就是可能的溢出

为了定位API，SHELLCODE会访问PEB来获取模块基地址
一般会有如下的代码
mov eax, fs:0x30
mov eax,[eax+0xc]
mov esi,[eax+0x1c]
lodsd
mov eax,[eax+0x08] /// kernel32地址

只要我们对 eax+0x08 下一个读类型的硬件断点就可以了。这样 mov eax,[eax+0x08] 就会符合条件断下来，我们通

过挂接INT 1，分析EIP就可以了。
DR0-DR3是设置断点的地址 ，我们可以吧剩余的断在常见API上。
可能在多线程的环境下，我们需要 DR7的 GD，全局检测启用，位13,防止线程切换时，DRX被切换。
R/W位（21,20)，11表示读写
LEN 一般是双字对齐吧，11就可以
DR7中，将保留位15,14,12,11填0，10填1

   这些天的因为某些事情，心思不放在电脑上，上网，习惯性的花上点时间，看下空间，逛下论坛。。然后就开始无聊了。。。有时候人要去维持些东西是很辛苦的，比如有人称赞你，你就得继续努力对得起别人的膜拜？？？？其实退出这个很小的圈子，谁还认识你。一个人一旦把某些东西当做自己的全部，那心态多少变得有点偏激，别人如果对你在意的东西进行东西否定，也许是很哀伤，也许是奋力反击。

   我是很自卑的，自卑的俩中症状： 不敢表达 和 疯狂表达 。。这些东西下面隐藏的是不安的心灵。路人的心态是很不错的。

   有时候我觉得称赞一个人是好事，但有时候却成了麻烦的事，我总觉了一下，如果你觉得你跟一个人是同一等级的，就不要去称赞他。比如你可以称赞你的师弟，师兄，就是不要去称赞你的同学。。中国人的等级观念太强了。。。一旦处在同一级别，人们往往是只要求平等，不要求公平。。。所以在一个集体里，如果你不是领导，就不要太高调了。。。。其实这点我觉得很纳闷，人之间讲究公平不好吗，干嘛死要面子？

   你可以认为别人是真的对你好，但不要认为只对你一个人好，从同学的恋爱经历中，我总觉出这条，事实上这些的实际事基本都会发生，我也被纳闷了一下。不说也罢，一开始的心态是最重要的，你可以预想最坏的结果，但觉不能老想着美好的东西，因为很多东西，最后你会发现，很难是你能控制的。

每个人不是承受不了失败，而是没准备好失败。。。只有在主动上寻求被拒绝的机会，才能从心里上成熟

最近的确是太多的事情了，有时候觉得活着真累，压力有点大，学业上的，找工作上的，自己本身的。。但睡觉后，觉得又充满了希望。。。我发现每天饭堂都是鸡肉多，我也基本只能吃鸡。。鸡吃多了，也许下辈子要做鸡了。人们说做人难，你们说做鸡就容易吗？？

#include "windows.h"
#include <stdio.h>

//
//一般是可执行节，我们不能仅根据 .TEXT / .CODE来确定。
//
typedef struct __section_info
{
unsigned int uistart; //// map
unsigned int uiend; // map
}section_info;

#define MAX_SECTION 4

typedef struct __mapfile_info
{
unsigned int uisection_num;
section_info arr_sectioninfo[MAX_SECTION];

HANDLE hFile;
HANDLE hMapping;
PVOID lpMapbase;
}mapfile_info,*pmapfile_info;

BOOLEAN   MAPFILE_INIT(LPCSTR szFileName, pmapfile_info lpMapFileInfo)
{

if( lpMapFileInfo == NULL)
{
return FALSE;
}

ZeroMemory( lpMapFileInfo, sizeof( mapfile_info ));

if (( lpMapFileInfo->hFile = CreateFile(szFileName, GENERIC_READ,
                              FILE_SHARE_READ,0,OPEN_EXISTING,
         FILE_FLAG_SEQUENTIAL_SCAN,0 )) == INVALID_HANDLE_VALUE)
{

        printf("Can't open file ! err 0x%08x \n",GetLastError() );

return FALSE;
}

if (!( lpMapFileInfo->hMapping = CreateFileMapping( lpMapFileInfo->hFile ,0,PAGE_READONLY|SEC_COMMIT, 0,0,0)))
{
printf("Mapping failed.\n");

CloseHandle( lpMapFileInfo->hFile );

return FALSE;
}

    if (!( lpMapFileInfo->lpMapbase = MapViewOfFile( lpMapFileInfo->hMapping ,FILE_MAP_READ,0,0,0)))

    {
printf("View failed.\n");

CloseHandle( lpMapFileInfo->hMapping );

CloseHandle( lpMapFileInfo->hFile );

return FALSE;
}

IMAGE_DOS_HEADER *dosHeader;
   
IMAGE_NT_HEADERS *ntHeader;
   
IMAGE_SECTION_HEADER *SectionHeader;

    int NumOfSections,test=0;

dosHeader=(IMAGE_DOS_HEADER*)lpMapFileInfo->lpMapbase;
   
ntHeader=(IMAGE_NT_HEADERS*)((BYTE*)lpMapFileInfo->lpMapbase+dosHeader->e_lfanew);
   
NumOfSections=ntHeader->FileHeader.NumberOfSections;

SectionHeader=(IMAGE_SECTION_HEADER*)((BYTE*)lpMapFileInfo->lpMapbase+dosHeader->e_lfanew+sizeof(IMAGE_NT_HEADERS));

lpMapFileInfo->uisection_num = 0;

for (int i=0;i<NumOfSections;i++)
{
        SectionHeader=(IMAGE_SECTION_HEADER*)((BYTE*)lpMapFileInfo->lpMapbase+
   dosHeader->e_lfanew+sizeof(IMAGE_NT_HEADERS))+i;

if( (SectionHeader->Characteristics&0x20000020)!=0 ) /// executable section
{
   if( lpMapFileInfo->uisection_num < MAX_SECTION )
   {
    //
    //RVA相对虚地址,VirtualAddress 本节的RVA(相对虚拟地址)。
    //
   
    lpMapFileInfo->arr_sectioninfo[lpMapFileInfo->uisection_num].uistart =
     SectionHeader->VirtualAddress;

    //
    // SizeOfRawData >=VirtualSize   ,VirtualSize   是节在内存中的长度
    // SizeOfRawData   则是VirtualSize经文件对齐后的尺寸。
    // 你的.text的代码段长是0x110但是文件对齐尺寸是0x400,那.text的SizeOfRawData   就是0x400,
    // 而virtualSize就是0x110
    //

    lpMapFileInfo->arr_sectioninfo[lpMapFileInfo->uisection_num].uiend =
     SectionHeader->SizeOfRawData;
   
    lpMapFileInfo->uisection_num++;
   
    printf("-%s 0x%x\n",SectionHeader->Name,SectionHeader->VirtualAddress);
   }
   
  
}
}

return TRUE;

}

void MAPFILE_CLEANUP( pmapfile_info lpMapFileInfo )
{
UnmapViewOfFile( lpMapFileInfo->lpMapbase );

CloseHandle( lpMapFileInfo->hMapping );

CloseHandle( lpMapFileInfo->hFile );
}

unsigned int Find_strncpy(unsigned int start , unsigned int end) ///// VC 6 sp6
{
unsigned char *ucptr = (unsigned char *)start ;
unsigned int uic = end - start;

if( end < start)
{
return 0;
}

while( uic != 0)
{
if( ((unsigned char*)ucptr)[0] == 0x8b &&
   ((unsigned char*)ucptr)[1] == 0x4c &&
   ((unsigned char*)ucptr)[2] == 0x24 &&
   ((unsigned char*)ucptr)[3] == 0x0c &&
   ((unsigned char*)( (int)ucptr+0xd ))[0] == 0x8b &&
   ((unsigned char*)( (int)ucptr+0xd ))[1] == 0x74 &&
   ((unsigned char*)( (int)ucptr+0xd ))[2] == 0x24 &&
   ((unsigned char*)( (int)ucptr+0xd ))[3] == 0x14 )
  

{
   printf("--find xx 0x%x\n",ucptr);
   return (unsigned int)ucptr ;
}
ucptr++;
uic--;
}

return 0;
}

BOOLEAN IsCallMatch( unsigned int uiAddress, unsigned int uiNorAddress)
/*
测试 uiAddress 地址 的指令是不是 call uiNorAddress
*/
{
__try
{
*(unsigned char*)uiAddress;

}__except(1)
{
return FALSE;
}

if( *(unsigned char*)uiAddress != 0xe8 ) ///// now just sp e8
{
return FALSE;
}

unsigned int uiasc = 0;
unsigned int uiTmpptr = *(unsigned int*)( (unsigned char*)uiAddress+1);

if( uiTmpptr & 0x10000000 )
{
uiasc = uiTmpptr + uiAddress -0xFFFFFFFB;
}else
{
uiasc = uiTmpptr+ uiAddress +5;
}

return uiasc == uiNorAddress ? TRUE : FALSE ;

}

unsigned int FucAddress(unsigned int uiAddress, unsigned int uimaylen)
{
unsigned char *ucptr = (unsigned char *)uiAddress;

if( uimaylen != 0)
{
while( uimaylen != 0 )
{
   if( IsBadReadPtr( ucptr+5, 5) == 0 &&
    ( ucptr[0] == 0xcc && ucptr[1] == 0xcc && ucptr[2] == 0xcc &&
      ucptr[3] == 0xcc && ucptr[4] == 0xcc ))
   {
   
    return (unsigned int)( ucptr+5 );
   }
   ucptr--;
   uimaylen--;
}
}

return 0;

}

void ________test()
{
char cbuf[16];

ZeroMemory( cbuf, 16 );

//ENABLE_L __asm int 3
char* testpath = "F:\\SysFilter\\.sys\\i386\\YasBoxFilter.sys";
//"C:\\溢出测试\\Debug\\溢出测试.exe";

if( strncpy( cbuf, "hello" , 6) == NULL )
{

}

/*
//// E8 C8 85 FF FF
///E8 D2 7B FF FF 0x39BEE9 0x393ac0
unsigned int xxx = Find_strncpy( (unsigned int)0x400000 ,(unsigned int)0x404005);

printf("--%d\n",IsCallMatch( 0x40bbd3 ,xxx) );

printf("--%x\n",FucAddress);

printf("--%x\n",FucAddress(0x40bbd3,0x1000));
*/
unsigned int xxx = 0;

mapfile_info mapfilexfo;

MAPFILE_INIT( testpath , &mapfilexfo);

for( unsigned int i=0; i<mapfilexfo.uisection_num; i++)
{
xxx = Find_strncpy( (unsigned int)mapfilexfo.lpMapbase+(unsigned int)mapfilexfo.arr_sectioninfo[i].uistart ,
   (unsigned int)mapfilexfo.lpMapbase+ (unsigned int)mapfilexfo.arr_sectioninfo[i].uiend);
if( xxx != 0x0)
{
   break;
}
}

//xxx-=(unsigned int)mapfilexfo.lpMapbase;

printf("--0x%x\n",mapfilexfo.lpMapbase);

unsigned int uissize = (unsigned int)mapfilexfo.arr_sectioninfo[i].uiend -
(unsigned int)mapfilexfo.arr_sectioninfo[i].uistart;

printf("s --0x%x\n",(unsigned int)mapfilexfo.lpMapbase+(unsigned int)mapfilexfo.arr_sectioninfo[i].uistart);

for( unsigned int j = (unsigned int)mapfilexfo.lpMapbase+(unsigned int)mapfilexfo.arr_sectioninfo[i].uistart ;
      uissize-->0 ; j++ )
{
    if( IsCallMatch( j ,xxx) != 0 )
printf("RVA--%x\n", j - (unsigned int)mapfilexfo.lpMapbase);
}

//printf("e --0x%x\n",)

}

/*
---------------------------------------------------
*/
DWORD RVAToOffset(LPVOID lpBase,DWORD VirtualAddress)
{
    IMAGE_DOS_HEADER *dosHeader;
    IMAGE_NT_HEADERS *ntHeader;
    IMAGE_SECTION_HEADER *SectionHeader;
    int NumOfSections;
    dosHeader=(IMAGE_DOS_HEADER*)lpBase;
    ntHeader=(IMAGE_NT_HEADERS*)((BYTE*)lpBase+dosHeader->e_lfanew);
    NumOfSections=ntHeader->FileHeader.NumberOfSections;
    for (int i=0;i<NumOfSections;i++)
    {
        SectionHeader=(IMAGE_SECTION_HEADER*)((BYTE*)lpBase+dosHeader->e_lfanew+sizeof(IMAGE_NT_HEADERS))+i;
        if(VirtualAddress>=SectionHeader->VirtualAddress&&VirtualAddress<=SectionHeader->VirtualAddress+SectionHeader->SizeOfRawData)
        {
            DWORD AposRAV=VirtualAddress-SectionHeader->VirtualAddress;
            DWORD Offset=SectionHeader->PointerToRawData+AposRAV;
            return Offset;
        }
    }
return 0;
   
}

unsigned int getiat_funcaddress(unsigned int lpmap_base,
         const char* szfucname,
         const char* szModuleName)
{

    PIMAGE_DOS_HEADER       dosHeader;
    PIMAGE_NT_HEADERS       ntHeader;
    PIMAGE_IMPORT_BY_NAME   ImportName;
PIMAGE_THUNK_DATA       pThunk;
PIMAGE_IMPORT_DESCRIPTOR ImportDec;
char* pDllName = NULL;
unsigned int i = 0;

dosHeader=(IMAGE_DOS_HEADER*)lpmap_base;
   
ntHeader=(IMAGE_NT_HEADERS*)((BYTE*)lpmap_base+dosHeader->e_lfanew);

ImportDec=(IMAGE_IMPORT_DESCRIPTOR*)((BYTE*)lpmap_base+
RVAToOffset((LPVOID)lpmap_base,ntHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress));
   
while(ImportDec->FirstThunk)
    {
   
pDllName=(char*)((BYTE*)lpmap_base+RVAToOffset((LPVOID)lpmap_base,ImportDec->Name));

if (strcmpi(pDllName,szModuleName)==0)
{
   if(ImportDec->OriginalFirstThunk)
   {
    pThunk=(PIMAGE_THUNK_DATA)((BYTE*)lpmap_base+
     RVAToOffset((LPVOID)lpmap_base,ImportDec->OriginalFirstThunk));

   }
   else
   {
    pThunk=(PIMAGE_THUNK_DATA)((BYTE*)lpmap_base+
     RVAToOffset((LPVOID)lpmap_base,ImportDec->FirstThunk));

   }
       
   while(pThunk->u1.Function)
   {
    if(pThunk->u1.Ordinal& IMAGE_ORDINAL_FLAG32)
    {
     //printf("EX_number：%x\n",pThunk->u1.Ordinal&0xFFFF);
    }
    else
    {

     ImportName=(IMAGE_IMPORT_BY_NAME*)((BYTE*)lpmap_base+
      RVAToOffset((LPVOID)lpmap_base,(DWORD)pThunk->u1.AddressOfData));

     if( strcmpi( (const char *)ImportName->Name,szfucname )==0 )
     {
      return (unsigned int)(ImportDec->FirstThunk + i*4);
     }
    
     //printf("--%s 0x%x \n",ImportName->Name, ImportDec->FirstThunk + i*4);
     i++;
    }
   
    pThunk++;
   }
}

ImportDec++;

}
   
return 0;

}
/*
text:000111F5                 call    ds:__imp__strncpy

FF 15 20 C0 01 00

text:00014D40                 call    ds:__imp__strncpy
FF 15 20 C0 01 00

.idata:0001C020 ; char *__cdecl _strncpy(char *, const char *, size_t)
.idata:0001C020                 extrn __imp__strncpy:dword

*/

BOOLEAN IsCallMatch_IAT( unsigned int uiAddress, unsigned int uiNorAddress)
{
__try
{
*(unsigned char*)uiAddress;

}__except(1)
{
return FALSE;
}

if( *(unsigned char*)uiAddress != 0xff || *(unsigned char*)( (unsigned char*)uiAddress + 1) != 0x15)
{
return FALSE;
}

return ( *(unsigned int*)( (unsigned char*)uiAddress + 2) == uiNorAddress ) ? TRUE : FALSE;

}

void _____testIMPORT()
{
char* testpath = "F:\\SysFilter\\.sys\\i386\\YasBoxFilter.sys";

mapfile_info mapfilexfo;

MAPFILE_INIT( testpath , &mapfilexfo);

unsigned int ui_strncpy_addr =
getiat_funcaddress( (unsigned long)mapfilexfo.lpMapbase,
(const char*)"strncpy",(const char*)"ntoskrnl.exe" );

printf("--0x%x\n",ui_strncpy_addr);
}
void main()
{
// ________test();
_____testIMPORT();

printf("xxxxxxxxx");

}

HANDLE hC;

下载