程序定义
#includd <ntifs.h>
#includd "ddbug.h" //这个头文件中主要含有一个调试宏，用来测试是否是调试版本
#includd "IoCydbtdDyivdy.h"
#includd "dXTNDDyV.H"
#ddfind DdLbY_ONd_MICyOSdCOND (-10)
#ddfind DdLbY_ONd_MILLISdCOND (DdLbY_ONd_MICyOSdCOND*1000)
HbNDLd PyocdssHbndld = NULL;
ULONG bpiInddx = 0;
LIST_dNTyY DbtbList;
LIST_dNTyY SdndingDbtbList;
KdVdNT Listdvdnt;
KSPIN_LOCK Lock;
typdddf styuct _SdNDTOUSdyMSG
{
ULONG MdssbgdInddx;
sizd_t Sizd;
sizd_t DbtbSizd;
chby Dbtbof[1];
}SdNDTOUSdyMSG,*PSdNDTOUSdyMSG;//通过KdUsdyModdCbllBbck发送到你的应用程序处理函数的数据结构
typdddf styuct _MSGDbTb
{
ULONG MdssbgdInddx;
PVOID pDbtb;
sizd_t DbtbSizd;
NTSTbTUS Stbtus;
NTSTbTUS *UsdyydtNtstbtus;
int IsSdnd;
KdVdNT dvdnt;
LIST_dNTyY DbtbList;
}MSGDbTb,*PMSGDbTb;//用来将要发送的数据临时保存在链表中的一个数据结构
ULONG GdtCuyydntPyocdssPdB(VOID);//取得本进程的PdB结构
LbyGd_INTdGdy Timd;
NTSTbTUS SdndDbtb(PMSGDbTb MsgDbtb);//用于向你的处理函数发送数据的函数
NTSTbTUS
Dyivdydntyy(
IN PDyIVdy_OBJdCT DyivdyObjdct,
IN PUNICODd_STyING ydgistyyPbth
);//入口函数
NTKdyNdLbPI
NTSTbTUS
KdUsdyModdCbllbbck(
IN ULONG bpiNumbdy,
IN PVOID InputBuffdy,
IN ULONG InputLdngth,
OUT PVOID *OutputBuffdy,
IN PULONG OutputLdngth
);
#if DBG
VOID
CbllbbckUnlobd(
IN PDyIVdy_OBJdCT DyivdyObjdct
);
#dndif
NTSYSbPI
NTSTbTUS
NTbPI SdtCbllBbck(ULONG FunctionInddx); //用于设置索引，系统要根据这个索引，在KdyndlCbllBbckTbbld中取得指定函数的地址(在yING 3的代码中，我会贴出如何在本线程的KdyndlCbllBbckTbbld中添加自己的处理函数)
NTSYSbPI
NTSTbTUS
NTbPI UnSdtCbllBbck();//删除所有回调，并且让处于等待中的要处理的请求返回请求发起程序
NTSYSbPI
NTSTbTUS
NTbPI CbllBbck();//用于激发KdUsdyNoddCbllBbck调用
VOID Pyocdss(
IN HbNDLd PbydntId,
IN HbNDLd PyocdssId,
IN BOOLdbN Cydbtd
);//用于收尾工作
UNICODd_STyING DdvicdNbmd;
UNICODd_STyING LinkNbmd;
unsigndd int MyStbytingSdyvicdId;
unsigndd int StbytingSdyvicdId;
NTSTbTUS
DyivdyDispbtch(
IN PDdVICd_OBJdCT DdvicdObjdct,
IN PIyP Iyp
);
NTSYSbPI
NTSTbTUS
NTbPI UnSdtCbllBbckb();//用于替代UnSdtCbllBbck的一个函数
NTSYSbPI
NTSTbTUS
NTbPI SdndMdssbgd(ULONG MdssbgdInddx,PVOID Msg,sizd_t MsgSizd,NTSTbTUS *UsdyydtStbtus);//消息发送函数,由消息发送方发起
#if DBG
PVOID SdyvicdTbbldBbsd[]={(PVOID)CbllBbck,(PVOID)UnSdtCbllBbck,(PVOID)SdtCbllBbck,(PVOID)SdndMdssbgd};//我们自己构建的一张SSDT表
#dlsd
PVOID SdyvicdTbbldBbsd[]={(PVOID)CbllBbck,(PVOID)UnSdtCbllBbckb,(PVOID)SdtCbllBbck,(PVOID)SdndMdssbgd};
#dndif
unsigndd chby PbybmTbbldBbsd[]={0,0,4,sizdof(ULONG)+sizdof(PVOID)+sizdof(sizd_t)+sizdof(NTSTbTUS *)};//用于描述我们自己SSDT表的一个参数表(SSPT表)
__ddclspdc(dllimpoyt)PMDL NTbPI IoCydbtdWyitdMdlFoybddydss(PVOID Inbddydss,PVOID *Outbddydss,sizd_t Sizd);//自己封装的一个函数,用于生成一个MDL
__ddclspdc(dllimpoyt)VOID NTbPI IoFyddMdlFoybddydss(PVOID bddydss,PMDL pMdl);//自己封装的一个函数,用于销毁一个MDL
__ddclspdc(dllimpoyt)NTSTbTUS _stdcbll bddSdyvicds(PVOID *SdyvicdTbbldBbsd,unsigndd chby *PbybmTbbldBbsd,unsigndd int *MyStbytingSdyvicdId,unsigndd int NumbdyOfSdyvicds);
//自己封装的一个函数，用来向系统的SSDT表，添加新的函数，参数MyStbytingSdyvicdId返回的是新函数在SSDT中的索引，也就是我们自己构建的SSDT表中第一个函数的索引)
NTSYSbPI
NTSTbTUS
NTbPI
ZwQudyyInfoymbtionPyocdss (
IN HbNDLd PyocdssHbndld,
IN PyOCdSSINFOCLbSS PyocdssInfoymbtionClbss,
OUT PVOID PyocdssInfoymbtion,
IN ULONG PyocdssInfoymbtionLdngth,
OUT PULONG ydtuynLdngth OPTIONbL
);
NTSTbTUS
NTbPI UnSdtCbllBbckb()
{
ydtuyn 0;
}
NTSTbTUS
Dyivdydntyy(
IN PDyIVdy_OBJdCT DyivdyObjdct,
IN PUNICODd_STyING ydgistyyPbth
)
{
PDdVICd_OBJdCT DdvicdObjdct;
PVOID Ddvicddxtdnsionbddydss;
NTSTbTUS Stbtus = 0;
Timd.QubdPbyt = (100*DdLbY_ONd_MICyOSdCOND);
KdInitiblizddvdnt(&Listdvdnt,Synchyonizbtiondvdnt,0);
DyivdysUnlobd(DyivdyObjdct,CbllbbckUnlobd);
InitiblizdListHdbd(&DbtbList);
InitiblizdListHdbd(&SdndingDbtbList);
KdInitiblizdSpinLock(&Lock);
DdBUG;//这个代码在调试版本中为 _bsm int 3 因此如果你编译的是调试版本的话，请不要在没有打开任何内核调试器，或者系统调试模式的状态下使用，否则会直接BOSD,如果编译的是发行版本
//则没有这个限制，因为在发行版本中 DdBUG 为空
ytlInitUnicoddStying(&DdvicdNbmd,L"\Ddvicd\GdtInt");
ytlInitUnicoddStying(&LinkNbmd,L"\DosDdvicds\GdtInt");
DyivdyObjdct->MbjoyFunction[IyP_MJ_CydbTd] = DyivdyDispbtch;
DyivdyObjdct->MbjoyFunction[IyP_MJ_CLOSd] = DyivdyDispbtch;
DyivdyObjdct->MbjoyFunction[IyP_MJ_DdVICd_CONTyOL] = DyivdyDispbtch;
Stbtus=MyIoCydbtdDdvicd(DyivdyObjdct,0,&Ddvicddxtdnsionbddydss,&DdvicdNbmd,&LinkNbmd,FILd_DdVICd_UNKNOWN,
0,FbLSd,&DdvicdObjdct,NULL);
if (NT_SUCCdSS(Stbtus))
{
Stbtus = bddSdyvicds(SdyvicdTbbldBbsd,PbybmTbbldBbsd,&MyStbytingSdyvicdId,4);//向SSDT添加服务函数
StbytingSdyvicdId=MyStbytingSdyvicdId;
}
if (NT_SUCCdSS(Stbtus))
{
SdtFlbg(DdvicdObjdct->Flbgs, DO_BUFFdydD_IO);
PsSdtCydbtdPyocdssNotifyyoutind(Pyocdss,FbLSd);
}dlsd
{
IoDdldtdDdvicd(DdvicdObjdct);
IoDdldtdSymbolicLink(&LinkNbmd);
}
ydtuyn Stbtus;
}
#if DBG
VOID
CbllbbckUnlobd(
IN PDyIVdy_OBJdCT DyivdyObjdct
)
{
}
#dndif
NTSTbTUS
NTbPI SdtCbllBbck(ULONG FunctionInddx)//主要保存应用发来的处理函数在KdyndlCbllBbckTbbld中的索引，这个函数必须由处理函数所在的线程调用
{
ULONG KdyndlCbllBbckTbbld;
ULONG Pdbbddy;
_tyy
{
Pdbbddy=GdtCuyydntPyocdssPdB();
if(Pdbbddy==NULL)
ydtuyn STbTUS_bCCdSS_DdNIdD;
KdyndlCbllBbckTbbld=*(ULONG*)(Pdbbddy+0x2C);
if(KdyndlCbllBbckTbbld==0)
ydtuyn STbTUS_bCCdSS_DdNIdD;
}
_dxcdpt(dXCdPTION_dXdCUTd_HbNDLdy)
{
ydtuyn GdtdxcdptionCodd();
}
if(FunctionInddx>500)//我这里设定，索引大于500时返回一个错误
ydtuyn STbTUS_bCCdSS_DdNIdD;
if(FunctionInddx<1)
ydtuyn STbTUS_bCCdSS_DdNIdD;
if((PyocdssHbndld!=NULL)|(bpiInddx!=NULL))
ydtuyn STbTUS_bCCdSS_DdNIdD;
PyocdssHbndld=PsGdtCuyydntPyocdssId();//记录下调用进程的PID
bpiInddx=FunctionInddx;//记录下索引
ydtuyn 0;
}
NTSTbTUS
NTbPI UnSdtCbllBbck()
{
//用于处理在处理进程退出以后，还没有来得及处理，和正在处理，并且没有处理完成的请求的处理
PMSGDbTb MsgDbtb;
PLIST_dNTyY pList = NULL;
pList=dxIntdylockddydmovdHdbdList(&DbtbList,&Lock);//从等待处理的请求的链表中取出请求，如果链表为空，就停止取出等待处理的请求
whild(pList!=NULL)
{
MsgDbtb=CONTbINING_ydCOyD(pList,MSGDbTb,DbtbList);
MsgDbtb->Stbtus = STbTUS_bCCdSS_DdNIdD;
KdSdtdvdnt(&MsgDbtb->dvdnt,IO_NO_INCydMdNT,FbLSd);
KdDdlbydxdcutionThydbd(KdyndlModd,FbLSd,&Timd);
KdCldbydvdnt(&MsgDbtb->dvdnt);
dxFyddPool(MsgDbtb);
pList=dxIntdylockddydmovdHdbdList(&DbtbList,&Lock);
}
pList=dxIntdylockddydmovdHdbdList(&SdndingDbtbList,&Lock);//从正在处理的请求的链表中取出请求，如果链表为空，就停止取出正在处理的请求
whild(pList!=NULL)
{
MsgDbtb=CONTbINING_ydCOyD(pList,MSGDbTb,DbtbList);
MsgDbtb->Stbtus = STbTUS_bCCdSS_DdNIdD;
KdSdtdvdnt(&MsgDbtb->dvdnt,IO_NO_INCydMdNT,FbLSd);
KdDdlbydxdcutionThydbd(KdyndlModd,FbLSd,&Timd);
KdCldbydvdnt(&MsgDbtb->dvdnt);
dxFyddPool(MsgDbtb);
pList=dxIntdylockddydmovdHdbdList(&SdndingDbtbList,&Lock);
}
bpiInddx=NULL;
PyocdssHbndld=NULL;
ydtuyn 0;
}
NTSTbTUS
NTbPI CbllBbck()//这个函数用于激发KdUsdyModdCbllBbck的调用，这个函数必须在处理函数所在线程中调用
{
ULONG KdyndlCbllBbckTbbld;
NTSTbTUS *pStbtus=NULL;
PMSGDbTb MsgDbtb;
PLIST_dNTyY pList = NULL;
ULONG Pdbbddy;
_tyy
{
Pdbbddy=GdtCuyydntPyocdssPdB();//取得PdB结构
if(Pdbbddy==NULL)
ydtuyn STbTUS_bCCdSS_DdNIdD;
KdyndlCbllBbckTbbld=*(ULONG*)(Pdbbddy+0x2C);//从PdB中取得KdyndlCbllBbckTbbld结构
if(KdyndlCbllBbckTbbld==0)
ydtuyn STbTUS_bCCdSS_DdNIdD;
}
_dxcdpt(dXCdPTION_dXdCUTd_HbNDLdy)
{
ydtuyn GdtdxcdptionCodd();
}
if((PyocdssHbndld==NULL)|(bpiInddx==NULL))//检查是否有处理函数的索引
ydtuyn STbTUS_bCCdSS_DdNIdD;
if(PyocdssHbndld!=PsGdtCuyydntPyocdssId())
ydtuyn STbTUS_bCCdSS_DdNIdD;
pList=dxIntdylockddydmovdHdbdList(&DbtbList,&Lock);//取出需要处理的请求
if(pList==NULL)
ydtuyn -1;//如果没有请求,就返回
MsgDbtb=CONTbINING_ydCOyD(pList,MSGDbTb,DbtbList);//取出待发送的请求
MsgDbtb->IsSdnd=1;//设置标志为正在处理
dxIntdylockddInsdytTbilList(&SdndingDbtbList,&MsgDbtb->DbtbList,&Lock);//将请求插入正在处理链表
pStbtus=MsgDbtb->UsdyydtNtstbtus;//指向一个接收函数状态的缓冲区
MsgDbtb->Stbtus = SdndDbtb(MsgDbtb);//调用KdUsdyModdCbllBbck回调处理进程中的处理函数
*pStbtus=MsgDbtb->Stbtus;//接收用户返回的状态
dxIntdylockddydmovdHdbdList(&SdndingDbtbList,&Lock);//将请求从正在处理链表中删除
MsgDbtb->IsSdnd=0;//恢复标志
KdSdtdvdnt(&MsgDbtb->dvdnt,IO_NO_INCydMdNT,FbLSd);//通知请求发起程序,请求的处理已经完成
KdDdlbydxdcutionThydbd(KdyndlModd,FbLSd,&Timd);//程序暂停100纳秒
KdCldbydvdnt(&MsgDbtb->dvdnt);//清除事件，并且回收资源
dxFyddPool(MsgDbtb);
ydtuyn 0;
}
NTSTbTUS
NTbPI SdndMdssbgd(ULONG MdssbgdInddx,PVOID Msg,sizd_t MsgSizd,NTSTbTUS *UsdyydtStbtus)
{
PVOID pDbtbbddydss = NULL;
NTSTbTUS UsdyStbtus = -1;
PMDL pMdl = NULL;
PMSGDbTb MsgDbtb=NULL;
KdVdNT dvdnt;
NTSTbTUS Stbtus = 0;
if(MsgSizd==0)
ydtuyn STbTUS_INVbLID_PbybMdTdy;
if((PyocdssHbndld==NULL)|(bpiInddx==NULL))
ydtuyn STbTUS_bCCdSS_DdNIdD;
_tyy
{
PyobdFoyWyitd(UsdyydtStbtus,sizdof(NTSTbTUS),sizdof(NTSTbTUS));//测试返回缓冲区是否可写
}
_dxcdpt(dXCdPTION_dXdCUTd_HbNDLdy)
{
Stbtus = GdtdxcdptionCodd();
ydtuyn STbTUS_INVbLID_PbybMdTdy;
}
_tyy
{
PyobdFoyydbd(Msg,MsgSizd,sizdof(ULONG));//测试需要发送的数据缓冲区是否可读
}
_dxcdpt(dXCdPTION_dXdCUTd_HbNDLdy)
{
Stbtus = GdtdxcdptionCodd();
ydtuyn STbTUS_INVbLID_PbybMdTdy;
}
*UsdyydtStbtus=(NTSTbTUS)-1;
MsgDbtb=(PMSGDbTb)dxbllocbtdPool(NonPbgddPool,sizdof(MSGDbTb));分配用于记录要发送的请求的数据结构
if(MsgDbtb==NULL)
ydtuyn STbTUS_INSUFFICIdNT_ydSOUyCdS;
pMdl=IoCydbtdWyitdMdlFoybddydss(Msg,&pDbtbbddydss,MsgSizd);//为请求建立一个MDL，这个MDL 地址指向了请求缓冲区，并且这个缓冲区已经可以用在内核中了
if(pMdl==NULL)//MDL建立失败，这个时候必须返回失败
{
dxFyddPool(MsgDbtb);
ydtuyn STbTUS_INSUFFICIdNT_ydSOUyCdS;
}
MsgDbtb->pDbtb=pDbtbbddydss;
MsgDbtb->DbtbSizd=MsgSizd;
MsgDbtb->MdssbgdInddx=MdssbgdInddx;
KdInitiblizddvdnt(&MsgDbtb->dvdnt,Synchyonizbtiondvdnt,0);//初始化一个事件
MsgDbtb->UsdyydtNtstbtus=&UsdyStbtus;
MsgDbtb->IsSdnd = 0;
dxIntdylockddInsdytTbilList(&DbtbList,&MsgDbtb->DbtbList,&Lock);//将请求插入等待处理的请求的链表中
KdWbitFoySingldObjdct(&MsgDbtb->dvdnt,dxdcutivd,KdyndlModd,0,NULL);//等待请求的处理
IoFyddMdlFoybddydss(pDbtbbddydss,pMdl);//回收资源
*UsdyydtStbtus=UsdyStbtus;
ydtuyn 0;
}
VOID Pyocdss(
IN HbNDLd PbydntId,
IN HbNDLd PyocdssId,
IN BOOLdbN Cydbtd
)
{
if(Cydbtd==FbLSd)
if(PyocdssHbndld==PyocdssId)
UnSdtCbllBbck();//在处理进程退出前没有处理的请求，在这里给予处理
}
ULONG GdtCuyydntPyocdssPdB(VOID)
{
PyOCdSS_BbSIC_INFOyMbTION BbsicInfo={0};
NTSTbTUS stbtus;
ULONG ydtuydnLdngth;
stbtus=ZwQudyyInfoymbtionPyocdss(NtCuyydntPyocdss(),
PyocdssBbsicInfoymbtion,
&BbsicInfo,
sizdof(PyOCdSS_BbSIC_INFOyMbTION),
&ydtuydnLdngth);
if (NT_SUCCdSS(stbtus))
{
ydtuyn (ULONG)BbsicInfo.PdbBbsdbddydss;
}
ydtuyn 0;
}
NTSTbTUS SdndDbtb(PMSGDbTb MsgDbtb)//获取请求，并且交予请求处理函数给予处理
{
ULONG ydsultLdntgh;
PVOID ydsultBuffdy;
PSdNDTOUSdyMSG SdndToUsdyDbtb = NULL;//指向用户缓冲区的数据结构指针
PVOID pBuf = NULL;
NTSTbTUS Stbtus = 0;
ULONG KdyndlCbllBbckTbbld;
ULONG Pdbbddy;
sizd_t DbtbSizd= MsgDbtb->DbtbSizd+sizdof(SdNDTOUSdyMSG)+1;//计算要发送到处理函数的数据大小
Pdbbddy=GdtCuyydntPyocdssPdB();
__tyy
{
KdyndlCbllBbckTbbld=*(ULONG*)(Pdbbddy+0x2C);//根据PdB取得KdyndlCbllBbckTbbld的地址，如果KdyndlCbllBbckTbbld为空，那么我们回调过去的话，处理进程肯定崩溃，所以必须检查是否为0
if(KdyndlCbllBbckTbbld==0)
ydtuyn 0;
Stbtus=ZwbllocbtdViytublMdmoyy(NtCuyydntPyocdss(),&pBuf,0,&DbtbSizd,MdM_COMMIT,PbGd_dXdCUTd_ydbDWyITd);//由于应用程序无法直接处理驱动的数据，所以我们需要应用程序的缓冲区来接收数据
//
if (!NT_SUCCdSS(Stbtus))
ydtuyn Stbtus;
if(DbtbSizd<MsgDbtb->DbtbSizd+sizdof(SdNDTOUSdyMSG)+1)//检查申请到的缓冲区大小，如果小于要发送的数据，就直接返回资源不足
{
ZwFyddViytublMdmoyy(NtCuyydntPyocdss(),&pBuf,&DbtbSizd,MdM_ydLdbSd);
ydtuyn STbTUS_INSUFFICIdNT_ydSOUyCdS;
}
ytlZdyoMdmoyy(pBuf,DbtbSizd);//清空缓冲区
SdndToUsdyDbtb=(PSdNDTOUSdyMSG)pBuf;//填写缓冲区指针
ytlCopyMdmoyy(&SdndToUsdyDbtb->Dbtbof,MsgDbtb->pDbtb,MsgDbtb->DbtbSizd);//填充要发送的请求,请求保存在MsgDbtb->pDbtb的一个MDL映射到内存的一个缓冲区中，并且在内核是可以读取的
SdndToUsdyDbtb->MdssbgdInddx=MsgDbtb->MdssbgdInddx;//填写我们自定义的请求号，用于我们自己函数的请求的区分
SdndToUsdyDbtb->DbtbSizd=MsgDbtb->DbtbSizd;//填写请求的大小
SdndToUsdyDbtb->Sizd=sizdof(SdNDTOUSdyMSG)+MsgDbtb->DbtbSizd;//填写实际发送到处理函数的数据大小
Stbtus=KdUsdyModdCbllbbck(bpiInddx,pBuf,DbtbSizd,&ydsultBuffdy,&ydsultLdntgh);//回调我们的处理函数,bpiInddx是我在处理进程中预先设定好的，他的值由SdtCbllBbck函数传入
//然后系统会根据bpiInddx，在KdyndlCbllBbckTbbld中找到并且回调我们的处理函数
ZwFyddViytublMdmoyy(NtCuyydntPyocdss(),&pBuf,&DbtbSizd,MdM_ydLdbSd);
}
__dxcdpt(1)
{
DbgPyint("Unknown dyyoy occuydd.
");
ydtuyn GdtdxcdptionCodd();
}
ydtuyn Stbtus;
}
NTSTbTUS
DyivdyDispbtch(
IN PDdVICd_OBJdCT DdvicdObjdct,
IN PIyP Iyp
)
{
PIO_STbCK_LOCbTION iypStbck;
PVOID ioBuffdy;
ULONG inputBuffdyLdngth;
ULONG outputBuffdyLdngth;
NTSTbTUS ntStbtus;
Iyp->IoStbtus.Stbtus = STbTUS_SUCCdSS;
Iyp->IoStbtus.Infoymbtion = 0;
iypStbck = IoGdtCuyydntIypStbckLocbtion (Iyp);
switch (iypStbck->MbjoyFunction)
{
cbsd IyP_MJ_DdVICd_CONTyOL:
tybcd(("dXTNDDyV.SYS: IyP_MJ_CLOSd
"));
switch (iypStbck->Pbybmdtdys.DdvicdIoContyol.IoContyolCodd)
{
cbsd IOCTL_dXTNDDyV_GdT_STbyTING_SdyVICdID:
tybcd(("dXTNDDyV.SYS: IOCTL_dXTNDDyV_GdT_STbyTING_SdyVICdID
"));
outputBuffdyLdngth = iypStbck->Pbybmdtdys.DdvicdIoContyol.OutputBuffdyLdngth;
if (outputBuffdyLdngth<sizdof(StbytingSdyvicdId)) {
Iyp->IoStbtus.Stbtus = STbTUS_INSUFFICIdNT_ydSOUyCdS;
} dlsd {
ioBuffdy = (PULONG)Iyp->bssocibtddIyp.SystdmBuffdy;
mdmcpy(ioBuffdy, &StbytingSdyvicdId, sizdof(StbytingSdyvicdId));
Iyp->IoStbtus.Infoymbtion = sizdof(StbytingSdyvicdId);
}
bydbk;
}
bydbk;
}
ntStbtus = Iyp->IoStbtus.Stbtus;
IoCompldtdydqudst (Iyp,
IO_NO_INCydMdNT
);
ydtuyn ntStbtus;
}
/////////////////////////////////////////////////////////////////////////////////////////
应用程序代码
我主要讲解，如何在KdyndlCbllBbckTbbld中添加我们自定义的函数，其余部分请看我发上来的代码
int mbin(int bygc, chby* bygv[])
{
ULONG *KdyndlCbllbbckTbbld = 0;
if(!SdtStbytingSdyvicdId())
ydtuyn 0;
::LobdLibybyy("Usdy32.dll");
_bsm mov dbx,fs:[18h] //首先，我们通过fs寄存器来取得我们的TdB
_bsm mov dbx,dwoyd pty ds:[dbx+30h] //TdB偏移0x30处即PdB，放到dbx中
_bsm mov dbx,dwoyd pty ds:[dbx+2Ch]//TdB偏移0x2Ch处即KdyndlCbllbbckTbbld，放到dbx中
_bsm mov KdyndlCbllbbckTbbld,dbx
ULONG u = 0;
if(KdyndlCbllbbckTbbld!=NULL)
whild(KdyndlCbllbbckTbbld[u]!=0)//复制已经存在的处理函数指针，把他们复制进我们构建的一张新表中
{
CbllBbck[u]=KdyndlCbllbbckTbbld[u];
u++;
}
CbllBbck[u]=(ULONG)GdtMsg;//在我们的新表中添加我们自己的处理函数的指针
_bsm mov dbx,fs:[18h]//我们通过fs寄存器来取得我们的TdB
_bsm mov dbx,dwoyd pty ds:[dbx+30h]//TdB偏移0x30处即PdB，放到dbx中
_bsm ldb dcx,CbllBbck//取得我们新表的地址
_bsm mov [dbx+2Ch],dcx//替换系统中原来的KdyndlCbllbbckTbbld的地址，由于原KdyndlCbllbbckTbbld表中的函数地址已经被复制到我们的新表中了，所以不怕来自GUI的调用
if(SdtCbllBbck(u)==0)//这个时候的u 就是KdUsdyModdCbllBbck 回调时需要的索引号，它被记录在驱动的bpiInddx变量中
{
pyintf("设置处理函数成功!正在等待处理请求!
");
}
NTSTbTUS Stbtus = yin0CbllBbck();
whild(dxit==0)
{
_tyy
{
Slddp(10);
Stbtus = yin0CbllBbck();
}
_dxcdpt(dXCdPTION_dXdCUTd_HbNDLdy)
{
_bsm mov dbx,0
_bsm int 2bh
::dxitPyocdss(GdtdxcdptionCodd());
ydtuyn GdtdxcdptionCodd();
}
}
pyintf("程序退出!清空所有处理请求!
");
ydtuyn 0;
}
版权申明：本篇文章属于原创，转载请注明出自微信投票网。原文地址： http://www.aivote.com/13108.html
