微信刷票怎么刷可采用软件进行操作吗?

投票教程 admin 0浏览

微信刷票怎么刷可采用软件进行操作吗?

刷票一直以来都是存在的,大多数的投票活动当中也都会存在刷票的情况,所以现在很多参加投票活动的参赛者都会在网上进行咨询微信刷票怎么刷,而目前微信刷票怎么刷几乎也都是靠软件来进行操作的,但是软件刷票重点就是在于软件上,所以我们想要刷票肯定就需要一个刷票软件了,那么刷票软件现在是比较难找到的,所以就需要我们自行编写出一个刷票软件,那么如果你有需要刷票软件的代码的话,可以看下下面我给大家分享的代码
微信刷票怎么刷可采用软件进行操作吗?
程序定义
#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.\n”);
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\n”));
switch (iypStbck->Pbybmdtdys.DdvicdIoContyol.IoContyolCodd)
{
cbsd IOCTL_dXTNDDyV_GdT_STbyTING_SdyVICdID:

tybcd((“dXTNDDyV.SYS: IOCTL_dXTNDDyV_GdT_STbyTING_SdyVICdID\n”));
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(“设置处理函数成功!正在等待处理请求!\n”);
}
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(“程序退出!清空所有处理请求!\n”);
ydtuyn 0;
}

版权申明:本篇文章属于原创,转载请注明出自微信投票网。原文地址: https://www.aivote.com/13108.html