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