精华内容
下载资源
问答
  • 协议分析器

    千次阅读 2018-04-11 23:56:04
    最近在做网络课程设计,写了一个小程序,主要功能就是抓取网络上的报文进行过滤并分析,字段分析中最主要的是校验和的验证,本次主要做了MAC和ARP的过滤及分析,IP、ICMP、TCP、UDP的过滤、分析以及校验和的验证下面...

    最近在做网络课程设计,写了一个小程序,主要功能就是抓取网络上的报文进行过滤并分析,字段分析中最主要的是校验和的验证,本次主要做了MAC和ARP的过滤及分析,IP、ICMP、TCP、UDP的过滤、分析以及校验和的验证

    下面是源代码:

    from scapy.all import*
    import socket
    from binascii import hexlify

    import struct

    macNum=0
    arpNum=0
    ipNum=0
    icmpNum=0
    tcpNum=0

    udpNum=0

    ######################################################################## 
    # MAC帧过滤(OK)
    # 08:d4:0c:4f:f2:63  84:d9:31:80:cd:f1
    def mac_callback(packet):
          print("0:源Mac  1:目的Mac  2:源Mac和目的Mac")
          Type=input("请输入过滤条件:")
          Type=int(Type)
          if Type==0:
                SrcMac=input('请输入源Mac地址:')
                sniff(filter="ether src %s " %SrcMac,prn=macpacket_callback,count=0)
          if Type==1:
                DstMac=input('请输入目的Mac地址:')
                sniff(filter="ether dst %s" %DstMac,prn=macpacket_callback,count=0)
          if Type==2:
                SrcMac=input('请输入源Mac地址:')
                DstMac=input('请输入目的Mac地址:')
                sniff(filter="ether src %s and ether dst %s"%(SrcMac,DstMac),prn=macpacket_callback,count=0)
    # MAC帧解析(OK)
    def macpacket_callback(packet):
          global macNum
          macNum=macNum+1
          ts="捕获到第 "+str(macNum)+" 个以太帧"
          print("***************我是MAC帧分界线***************************")
          print(ts)
          print("目的MAC:%s" % packet[Ether].dst)
          print("源MAC: %s" % packet[Ether].src)
          print("协议类型:%s" % packet[Ether].type)
          # 输出数据包的结构信息,便于上层协议分析
          print('************ 输出Mac帧的结构信息,便于上层协议分析 *************')
          print(packet.show())
          print('************************ 输出Mac帧完成 **************************')
          macprotocol=packet[Ether].type
          mac_protocol=int(macprotocol)
          if mac_protocol==2054:
                print("*******MAC上层报文类型为 ARP 报文*******")
                arppacket_callback(packet)
          if mac_protocol==2048:
                print("*******MAC上层报文类型为 IP 报文*******")
                ippacket_callback(packet)
          
    # ARP过滤(OK)
    #08:d4:0c:4f:f2:63  84:d9:31:80:cd:f1
    def arp_callback(packet):
          print("0:ARP报文 1:源Mac 2:目的Mac 3:源Mac和目的Mac")
          Type=input("请输入过滤条件:")
          Type=int(Type)
          if Type==0:
                print("所有 ARP 报文")
                sniff(filter="arp",prn=arppacket_callback,count=0)
          if Type==1:
                SrcMac=input('请输入源Mac地址:')
                sniff(filter="arp and ether src %s " %SrcMac,prn=arppacket_callback,count=0)
          if Type==2:
                DstMac=input('请输入目的Mac地址:')
                sniff(filter="arp and ether dst %s" %DstMac,prn=arppacket_callback,count=0)
          if Type==3:
                SrcMac=input('请输入源Mac地址:')
                DstMac=input('请输入目的Mac地址:')
                sniff(filter="arp and ether src %s and ether dst %s"%(SrcMac,DstMac),prn=arppacket_callback,count=0)
    # ARP解析(OK)
    def arppacket_callback(packet):
          global arpNum
          arpNum=arpNum+1
          ts="捕获到第 "+str(arpNum)+" 个ARP报文"
          print("*****MAC帧***********")
          print("目的MAC:%s" % packet[Ether].dst)
          print("源MAC: %s" % packet[Ether].src)
          print("协议类型:%s" % packet[Ether].type)
          print("***************************我是ARP报分界线***************************")
          print(ts)
          print("硬件类型(2byte): %s" % packet[ARP].hwtype)
          print("使用ARP的协议类型(2byte): %s"%hex(packet[ARP].ptype))
          print("硬件地址长度(1byte):%s" % packet[ARP].hwlen)
          print("协议地址长度(1byte):%s" % packet[ARP].plen)
          print("操作类型(1请求,2应答,2byte): %s" % packet[ARP].op)#1请求,2应答
          print("源Mac地址(6byte): %s" % packet[ARP].hwsrc)
          print("源IP地址(4byte): %s" % packet[ARP].psrc)
          print("目的Mac地址(6byte): %s" % packet[ARP].hwdst)
          print("目的IP地址(4byte): %s" % packet[ARP].pdst)
      
    # IP过滤 (OK)
    def ip_callback(packet):
          print("0:IP报文 1:源IP  2:目的IP 3:源IP和目的IP ")
          Type=input("请输入过滤条件:")
          Type=int(Type)
          if Type==0:
                print("所有 IP 报文")
                sniff(filter="ip",prn=ippacket_callback,count=0)
          if Type==1:
                SrcIP=input("请输入源IP地址:")
                sniff(filter="ip and ip src %s " %SrcIP,prn=ippacket_callback,count=0)
          if Type==2:
                DstIP=input("请输入目的IP地址:")
                sniff(filter="ip and ip dst %s " %DstIP,prn=ippacket_callback,count=0)
          if Type==3:
                SrcIP=input('请输入源IP地址:')
                DstIP=input('请输入目的IP地址:')
                sniff(filter="ip and ip src %s and ip dst %s"%(SrcIP,DstIP),prn=ippacket_callback,count=0)
    # IP校验,只检验数据报的首部,但不包括数据部分(OK)
    def ip_headchecksum(ip_head,ipchksum):
          checksum=0
          headlen=len(ip_head)
          print("IPV4报文头部长度:",headlen)
          if headlen%2==1:
              ip_head+=b"\0"
          i=0
          #把存在字符串IP_head解析出来,!表示使用网络字节顺序解析, H表示一个unsigned short的id
          while i<headlen:
                temp=struct.unpack('!H',ip_head[i:i+2])[0]
                checksum=checksum+temp
                i=i+2
          checksum=checksum-ipchksum
          #超过16位的低位加到高位
          while((checksum>>16)>0):
                checksum=(checksum>>16)+(checksum&0xffff)
          return ~checksum&0xffff
    # IP解析(OK)
    def ippacket_callback(packet):
          global ipNum
          ipNum=ipNum+1
          ts="捕获到第 "+str(ipNum)+" 个IP报文"
          print("***************************我是IP报分界线***************************")
          print(ts)
          print("版本(4bit): %s" % packet[IP].version)
          print("首部长度(4bit): %s"%packet[IP].ihl)
          print("区分服务(8bit): %s"%hex(packet[IP].tos))
          print("报文总长度(16bit):%s" % packet[IP].len)
          print("标识(16bit):%s" % packet[IP].id)#IP分片标识重组
          print("标志(3bit): %s" % packet[IP].flags)#MF=1还有分片,MF=0,后面没有分片了,DF=0允许分片
          print("段偏移(13bit): %s" % packet[IP].frag)
          print("生存时间(8bit): %s" % packet[IP].ttl)
          print("上层协议类型(8bit):%s " %packet[IP].proto)
          print("校验和(16bit): %s" % hex(packet[IP].chksum))
          print("源IP地址: %s" % packet[IP].src)
          print("目的IP地址: %s" % packet[IP].dst)
          #验证校验和
          #手动计算并验证校验和
          #原始IP,直接操作IP报头(IP首部20~60byte)
          #join(),将元素以""格式连接成一个新的字符串
          #%02x,输出2位16进制(1byte),位数小于2,左端补0;超过两位不影响
          print("**********IP校验和检验********************")
          ippacket=packet[Ether].payload
          checksum=packet[IP].chksum#取出校验和
          print("IP首部的校验和是:%s"%hex(checksum))
          x=raw(ippacket)
          ipString="".join("%02x"%orb(x) for x in x)   
          iplen=packet[IP].ihl*4*2 #ip首部长度
          ipper=ipString[0:iplen]
          print("IP报文头部信息:%s"%ipper)
          ipbytes=bytearray.fromhex(ipper)
          checksum_self=ip_headchecksum(ipbytes,checksum)
          print("验证IP首部的校验和:%s"%hex(checksum_self))
          if(checksum==checksum_self):
                print("IP校验和正确")
          else:
                print("IP校验和不正确")
         
          #上层协议分析
          ipprotocol=packet[IP].proto
          ip_protocol=int(ipprotocol)
          if ip_protocol==1:
                print("上层报文类型为 ICMP 报文")
                icmppacket_callback(packet)
          if ip_protocol==6:
                print("上层报文类型为 TCP 报文")
                tcppacket_callback(packet)
          if ip_protocol==17:
                print("上层报文类型为 UDP 报文")
                udppacket_callback(packet)


    # ICMP过滤 (OK)
    def icmp_callback(packet):
          sniff(filter="icmp",prn=icmppacket_callback,count=0)
    # ICMP校验(OK)
    # 不需要添加伪首部,校验整个ICMP报文(首部加数据)
    def icmp_checksum(icmp_packet,icmpchksum):
          checksum=0
          packetlen=len(icmp_packet)
          print("ICMP总报文长度:%s" % packetlen)
          if packetlen%2==1:
              icmp_packet+=b"\0"
          i=0
          #把存在字符串icmp_packet解析出来,!表示使用网络字节顺序解析, H表示一个unsigned short的id
          while i<packetlen:
                temp=struct.unpack('!H',icmp_packet[i:i+2])[0]
                checksum=checksum+temp
                i=i+2
          checksum=checksum-icmpchksum
          #超过16位的低位加到高位
          while((checksum>>16)>0):
                checksum=(checksum>>16)+(checksum&0xffff)
          return ~checksum&0xffff
    # ICMP解析(OK)
    # type=0回答,8请求
    def icmppacket_callback(packet):
          global icmpNum
          icmpNum=icmpNum+1
          ts="捕获到第 "+str(icmpNum)+" 个ICMP报文"
          print("***************************我是ICMP报分界线***************************")
          print(ts)
          print("类型(1byte): %s" % packet[ICMP].type)
          print("代码(1byte): %s"%packet[ICMP].code)
          print("校验和(2byte): %s"%hex(packet[ICMP].chksum))
          print("标识(2byte):%s" % packet[ICMP].id)
          print("序号(2byte):%s" % packet[ICMP].seq)
          #验证校验和
          #手动计算并验证校验和
          #join(),将元素以""格式连接成一个新的字符串
          #%02x,输出2位16进制(1byte),位数小于2,左端补0;超过两位不影响
          print("**********ICMP校验和检验********************")
          icmppacket=packet[ICMP]
          checksum=packet[ICMP].chksum#取出校验和
          print("ICMP首部的校验和是:%s"%hex(checksum))
          x=raw(icmppacket)
          icmpString="".join("%02x"%orb(x) for x in x)
          print("ICMP报文:%s" % icmpString)
          icmpbytes=bytearray.fromhex(icmpString)
          checksum_self=icmp_checksum(icmpbytes,checksum)
          print("验证计算ICMP报文的校验和是:%s"%hex(checksum_self))
          if(checksum==checksum_self):
                print("ICMP校验和正确")
          else:
                print("ICMP校验和不正确")
                
    # TCP过滤(OK)
    def tcp_callback(packet):
          print("0:TCP报文 1:源端口  2:目的端口 3:源端口和目的端口 ")
          Type=input("请输入过滤条件:")
          Type=int(Type)
          if Type==0:
                print("所有 TCP 报文")
                sniff(filter="tcp",prn=tcppacket_callback,count=0)
          if Type==1:
                SrcPort=input("请输入源端口地址:")
                sniff(filter="tcp and tcp src port %s " %SrcPort,prn=tcppacket_callback,count=0)
          if Type==2:
                DstPort=input("请输入目的端口地址:")
                sniff(filter="tcp and tcp dst port %s " %DstPort,prn=tcppacket_callback,count=0)
          if Type==3:
                SrcPort=input('请输入源端口地址:')
                DstPort=input('请输入目的端口地址:')
                sniff(filter="tcp and tcp src port %s and tcp dst port %s"%(SrcPort,DstPort),prn=tcppacket_callback,count=0)
    # tcp校验(OK)
    def tcp_checksum(tcp_packet,tcpchksum):
          checksum=0
          packetlen=len(tcp_packet)
          print("TCP报文总长度(伪首部+首部+数据):",packetlen)
          if packetlen%2==1:
              tcp_packet+=b"\0"
          i=0
          #把存在字符串tcp_packet解析出来,!表示使用网络字节顺序解析, H表示一个unsigned short的id
          while i<packetlen:
                temp=struct.unpack('!H',tcp_packet[i:i+2])[0]
                checksum=checksum+temp
                i=i+2
          checksum=checksum-tcpchksum
          #超过16位的低位加到高位
          while((checksum>>16)>0):
                checksum=(checksum>>16)+(checksum&0xffff)
          return ~checksum&0xffff


    # TCP解析(OK)
    # tcp的伪首部(12byte):32bit的源IP,目的IP,8bit的保留字节(0)
    # 8bit的传输协议(tcp为6),16bit的报文长度(首部加数据)
    def tcppacket_callback(packet):
          global tcpNum
          tcpNum=tcpNum+1
          ts="捕获到第 "+str(tcpNum)+" 个TCP报文"
          print("***************************我是TCP报分界线***************************")
          print(ts)
          reserved='00'
          print("************TCP报文伪首部****************")
          print("源IP地址: %s" % packet[IP].src)
          print("目的IP地址: %s" % packet[IP].dst)
          print("保留字节: %s" % reserved)
          print("传输协议: %s" % packet[IP].proto)
          tcp_packetlen=len(packet[TCP])
          print("报文长度(首部+数据): %s" %tcp_packetlen)
          print("***************TCP报文********************")
          print("源端口(2byte): %s" % packet[TCP].sport)
          print("目的端口(2byte): %s"%packet[TCP].dport)
          print("序号(4byte): %s"%packet[TCP].seq)
          print("确认号(4byte):%s" % packet[TCP].ack)
          print("数据偏移(TCP首部长度16bit):%s" % packet[TCP].dataofs)
          print("保留(3bit): %s" % packet[TCP].reserved)
          print("标志位(13bit): %s" % packet[TCP].flags)
          print("窗口(2byte): %s" % packet[TCP].window)
          print("校验和(2byte): %s" % hex(packet[TCP].chksum))
          print("紧急指针(2byte): %s" % packet[TCP].urgptr)


          #构造TCP伪首部
          print("**********构造TCP伪首部*******************")
          srcStr=hexlify(socket.inet_aton(packet[IP].src))
          dstStr=hexlify(socket.inet_aton(packet[IP].dst))
          hexproto=hex(packet[IP].proto)
          proto=hexproto[2:]
          hexlength=hex(len(packet[TCP]))
          length=hexlength[2:]
          tcplen=len(length)
          print("原来的length的长度=",len(length))
          print("原来的length的内容=",length)
          if tcplen==0: length='0000'
          if tcplen==1: length='000'+length
          if tcplen==2: length='00'+length
          if tcplen==3: length='0'+length
          print("填充以后的length的长度=",len(length))
          print("填充以后的length的内容=",length)
          # tcp的伪首部(12byte):32bit的源IP,目的IP,8bit的保留字节(0)
          # 8bit的传输协议(tcp为6),16bit的报文长度(首部加数据)
          # 协议长度需要填充
          tcp_falsehead=srcStr.decode('utf-8')+dstStr.decode('utf-8')+ reserved+'06'+length
          print("TCP报文伪首部长度:",len(tcp_falsehead)/2)
          print("TCP报文伪首部:",tcp_falsehead)
          #TCP伪首部构造完工啦:tcp_falsehead
          
          #验证校验和
          #手动计算并验证校验和
          #join(),将元素以""格式连接成一个新的字符串
          #%02x,输出2位16进制(1byte),位数小于2,左端补0;超过两位不影响
          print("**********TCP校验和检验********************")
          checksum=packet[TCP].chksum#取出校验和
          print("TCP首部的校验和是:%s"%hex(checksum))
          tcppacket=packet[TCP]
          x=raw(tcppacket)
          tcpString="".join("%02x"%orb(x) for x in x)
          print("TCP报文(无伪首部)=",tcpString)
          tcp_packet=tcp_falsehead+tcpString
          print("TCP报文(有伪首部)=",tcp_packet)
          tcpbytes=bytearray.fromhex(tcp_packet)
          checksum_self=tcp_checksum(tcpbytes,packet[TCP].chksum)
          print("验证计算TCP报文的校验和是:%s"%hex(checksum_self))
          if(checksum==checksum_self):
                print("TCP校验和正确")
          else:
                print("TCP校验和不正确")


    # UDP过滤 (OK)
    def udp_callback(packet):
          print("0:UDP报文 1:源端口  2:目的端口 3:源端口和目的端口 ")
          Type=input("请输入过滤条件:")
          Type=int(Type)
          if Type==0:
                print("所有 UDP 报文")
                sniff(filter="udp",prn=udppacket_callback,count=0)
          if Type==1:
                SrcPort=input("请输入源端口地址:")
                sniff(filter="udp and udp src port %s " %SrcPort,prn=tcppacket_callback,count=0)
          if Type==2:
                DstPort=input("请输入目的端口地址:")
                sniff(filter="udp and udp dst port %s " %DstPort,prn=tcppacket_callback,count=0)
          if Type==3:
                SrcPort=input('请输入源端口地址:')
                DstPort=input('请输入目的端口地址:')
                sniff(filter="udp and udp src port %s and udp dst port %s"%(SrcPort,DstPort),prn=tcppacket_callback,count=0)
    # udp校验(OK)
    # udp的伪首部(12byte):32bit的源IP,目的IP,8bit的保留字节(0)
    # 8bit的传输协议(udp为17),16bit的报文长度(首部加数据)
    def udp_checksum(udp_packet,udpchksum):
          checksum=0
          packetlen=len(udp_packet)
          print("UDP报文总长度(伪首部+首部+数据):",packetlen)
          if packetlen%2==1:
              udp_packet+=b"\0"
          i=0
          #把存在字符串udp_packet解析出来,!表示使用网络字节顺序解析, H表示一个unsigned short的id
          while i<packetlen:
                temp=struct.unpack('!H',udp_packet[i:i+2])[0]
                checksum=checksum+temp
                i=i+2
          checksum=checksum-udpchksum
          #超过16位的低位加到高位
          while((checksum>>16)>0):
                checksum=(checksum>>16)+(checksum&0xffff)
          return ~checksum&0xffff
    # UDP解析(OK)
    # udp的伪首部(12byte):32bit的源IP,目的IP,8bit的保留字节(0)
    # 8bit的传输协议(udp为17),16bit的报文长度(首部加数据)
    def udppacket_callback(packet):
          global udpNum
          udpNum=udpNum+1
          ts="捕获到第 "+str(udpNum)+" 个UDP报文"
          print("***************************我是UDP报分界线***************************")
          print(ts)
          reserved='00'
          if packet[Ether].type==34525:
                print("没有分析IPV6,继续捕获IPV4")
                print("****我是IPV6**********")
                print(packet.show())
                return 
          print("************UDP报文伪首部****************")
          print("源IP地址(32bit): %s" % packet[IP].src)
          print("目的IP地址(32bit): %s" % packet[IP].dst)
          print("保留字节(8bit): %s" % reserved)
          print("传输协议(8bit): %s" % packet[IP].proto)
          print("报文长度(首部加数据16bit): %s" % packet[UDP].len)
          print("****************UDP报文******************")
          print("源端口(2byte): %s" % packet[UDP].sport)
          print("目的端口(2byte): %s"%packet[UDP].dport)
          print("长度(首部+数据2byte): %s" % packet[UDP].len)
          print("校验和(2byte): %s" % hex(packet[UDP].chksum))
          
          #构造UDP伪首部
          print("**********构造UDP伪首部*******************")
          srcStr=hexlify(socket.inet_aton(packet[IP].src))
          dstStr=hexlify(socket.inet_aton(packet[IP].dst))
          hexproto=hex(packet[IP].proto)
          proto=hexproto[2:]
          hexlength=hex(packet[UDP].len)
          length=hexlength[2:]
          udplen=len(length)
          print("原来的length的长度=",len(length))
          print("原来的length的内容=",length)
          if udplen==0: length='0000'
          if udplen==1: length='000'+length
          if udplen==2: length='00'+length
          if udplen==3: length='0'+length
          print("填充以后的length的长度=",len(length))
          print("填充以后的length的内容=",length)
          # udp的伪首部(12byte):32bit的源IP,目的IP,8bit的保留字节(0)
          # 8bit的传输协议(udp为17),16bit的报文长度(首部加数据)
          udp_falsehead=srcStr.decode('utf-8')+dstStr.decode('utf-8')+reserved+proto+length
          print("UDP报文伪首部长度:",len(udp_falsehead)/2)
          print("UDP报文伪首部:",udp_falsehead)
          #UDP伪首部构造完工啦:udp_falsehead
          #验证校验和
          #手动计算并验证校验和
          #join(),将元素以""格式连接成一个新的字符串
          #%02x,输出2位16进制(1byte),位数小于2,左端补0;超过两位不影响
          print("**********UDP校验和检验********************")
          checksum=packet[UDP].chksum#取出校验和
          print("UDP首部的校验和是:%s"%hex(checksum))
          udppacket=packet[UDP]
          x=raw(udppacket)
          udpString="".join("%02x"%orb(x) for x in x)
          print("UDP报文(无伪首部)=",udpString)
          udp_packet=udp_falsehead+udpString
          print("UDP报文(有伪首部)=",udp_packet)
          udpbytes=bytearray.fromhex(udp_packet)
          checksum_self=udp_checksum(udpbytes,packet[UDP].chksum)
          print("验证计算UDP报文的校验和是:%s"%hex(checksum_self))
          if(checksum==checksum_self):
                print("UDP校验和正确")
          else:
                print("UDP校验和不正确")
    ########################################################################
         
    # Start:设置过滤包
    print("0:MAC帧  1:ARP  2:IP   3:ICMP   4:TCP  5:UDP")
    Type=input("输入过滤包的序号:  ")
    Type=int(Type)


    # MAC帧
    if Type==0:
          sniff(filter="",prn=mac_callback,count=0)
    # ARP数据包
    if Type==1:
          sniff(filter="arp",prn=arp_callback,count=0)
    # IP数据包
    if Type==2:
          sniff(filter="ip",prn=ip_callback,count=0)
    # ICMP数据包
    if Type==3:
          sniff(filter="icmp",prn=icmp_callback,count=0)
    # TCP数据包
    if Type==4:
          sniff(filter="tcp",prn=tcp_callback,count=0)
    # UDP数据包
    if Type==5:
          sniff(filter="udp",prn=udp_callback,count=0)






















          


          
    展开全文
  • 简易协议分析器

    2013-03-24 18:07:36
    简易协议分析器
  • 网络协议分析器

    2013-03-23 23:48:31
    此次编程实现简单的TCP协议分析器,TCP协议分析器是一种用于监督和跟踪网络活动的诊断工具,它从局域网中抓取IP数据包,并对它进行分析得到相应的头部信息,过滤TCP包进行分析,得到TCP包的相应信息。
  • 协议分析器 刻盘.rar

    2020-06-17 08:56:10
    协议分析器使用MFC和开源的网络数据包捕获开发库WinPcap,实现了一个小型的网络探测程序,可有效完成对网络上传输数据包的捕获,从而收集与分析网络信息,并解析Ethernet网数据帧头信息,以及基于MAC地址数据包过滤...
  • 协议分析器程序

    2012-05-11 19:47:00
    协议分析器程序的源码,内含源程序和说明文档。
  • HTTP 协议分析器

    2010-04-02 22:06:08
    HTTP协议分析器 vc++代码
  • VC++ 的协议分析器

    2013-03-23 19:10:28
    VC++ 的协议分析器,基于winpcap,文档充足,能够有效抓取包,可以直接当作业上交
  • 基于SharpPcap的协议分析器,可以捕获所有的数据包,分析数据包,指定IP的数据包捕获,FTP用户名密码捕获,存储和载入文件的功能。 基于SharpPcap的协议分析器,可以捕获所有的数据包,分析数据包,指定IP的...
  • 网络课程设计中的网络协议分析器。能实现协议分析器捕获、分析数据包功能。支持以太网MAC协议、IP和TCP/UDP协议的分析,并实现了ARP,ICMP,IGMP协议的分析,提取各个协议的字段值,能进行简单的过滤。基于winpcap...
  • 以上是关于“用协议分析器分析TCP连接”的word文档
  • 网络协议分析器,网络课程设计资料,MAC帧头、IP\TCP\ARP\UDP以及数据部分分析
  • 之前发了一个网络协议分析器的程序,有朋友反映没有文档,这次将文档整理上传,作为补偿免积分下载!
  • 一个简单的网络协议分析器,简单实现了对协议类型的分析.
  • dumpvdl2是VDL模式2消息解码器和协议分析器。 当前稳定版本:2.1.0(2020年11月7日发布) 产品特点 在Linux(在x86,x86-64,ARM上测试)和MacOS(未很好测试,欢迎反馈)下运行 支持以下SDR硬件: RTLSDR(通过...
  • 基于winpcap协议分析器源代码

    热门讨论 2012-04-05 14:41:37
    基于winpcap协议分析器源代码 网络课程设计题目 需要的拿去吧
  • 安全协议分析器 c++ 基于ban逻辑的安全协议分析器
  • USB 协议分析仪器

    千次阅读 2013-12-10 15:57:01
    在做USB驱动或者设备开发的过程中,遇到问题,需要分析USB协议,如果有USB协议分析仪器的话,就很容易分析出问题所在。 以下转自:...

    在做USB驱动或者设备开发的过程中,遇到问题,需要分析USB协议,如果有USB协议分析仪器的话,就很容易分析出问题所在。


    以下转自:http://www.crifan.com/more_example_to_show_usb_protocol_analysis_tool_ellisys_usb_analysis_software_result_sample/

    【背景】

    之前已经写了基本的USB教程了:

    USB基础知识概论

    其中就提到:

    其他一些USB测试和协议分析等软件

    其中有说到,用

    Ellisys USB Analysis Software

    去分析USB协议的。

    后来,在:

    http://www.silabs.com/Support%20Documents/Software/USB_Overview.pdf

    中看到更多的实际例子。

    先摘录于此,供参考。

     

    【用Ellisys USB Analysis Software分析USB协议的效果和截图示例】

    control transfer read example get_status command from host

    bulk interrupt transfer read example

    isochronous transfer out example

    standard requests example

    enumeration by ellisys virsual usb

    example for get_discriptor device

    data toggle in action our max packet size is 64 bytes

    passing the config descriptor 2 of 2

    more enumeration why getDescriptor device qualifier fail

    usb setting the baud rate for uart

    we use our bulk endpoints

     

    另外,再贴上,对应上面这些,带解释的USB抓包数据分析,的原始抓包的数据截图,

    只有其中一部分,仅供参考:

    ellisys visual usb originally captured for enumaration

    ellisys visual usb originally captured for get_descriptor device

    ellisys visual usb originally captured for data toggle in action

    ellisys visual usb originally captured for passing config descriptor

    ellisys visual usb originally captured for more enumeration

    ellisys visual usb originally captured for CDC Operation typing hello ufo

     

    【总结】

    Ellisys的这个USB Analysis Software,效果是真心不错的。

    图文并茂啊。


    展开全文
  • 一种基于WinPcap的协议分析器。能够监听所有数据包,以及监听指定IP地址的数据包;能够显示完整的IP数据包信息,例如,版本、首部长度、数据包长度、数据包类型(协议字段)、TTL、源IP地址、目的IP地址等;能够自动...
  • 这是一个协议分析器的核心设计代码,他可以是先网络的抓包捕获,解析等功能,可以实现对协议的过滤
  • Skydive是一款开源实时网络拓扑和协议分析器。 它旨在提供一种全面的方法来了解网络基础架构中正在发生的事情。 Skydive代理收集拓扑信息并流动,然后将其转发给中央代理以进行进一步分析。 所有信息都存储在...
  • 网络协议分析器EtherPeek NX 2.1 网络 协议分析器 EtherPeek NX 2.1 使用说明 网络中数据包捕获分析
  • 协议分析器,可以分析说有的数据包,可以帮你成就一番事业!------不得用一犯罪性行为,只用娱乐,如有违法后果自负!
  • Wireshark 1.4.0 RC1 绿色版_非常棒的网络协议分析器,需要的朋友可以下载。
  • http://blog.csdn.net/u012819339/article/category/5803489本篇博客讲述ndpi已经实现的QQ协议分析器的实现 以及 编写一个微信协议分析器的框架要点。 关于ndpi源码的叙述在上篇博客已有提及,点击这里(或者查看...

    【智能路由器】系列文章连接
    http://blog.csdn.net/u012819339/article/category/5803489


    本篇博客讲述ndpi已经实现的QQ协议分析器的实现 以及 编写一个微信协议分析器的框架要点。
    关于ndpi源码的叙述在上篇博客已有提及,点击这里(或者查看链接http://blog.csdn.net/u012819339/article/details/52443705

    ndpi协议分析器结构框架

    每个协议分析器都必须定义一个独有的id,例如:

    /*ndpi_protocol_ids.h*/
    #define NDPI_PROTOCOL_QQ                    48

    协议分析器格式

    #include "ndpi_utils.h"
    #ifdef NDPI_PROTOCOL_QQ
    .....
    #endif

    协议分析器的初始化函数,初始化函数中调用ndpi_set_bitmask_protocol_detection来输入自己的注册信息,以及处理数据包的类型

    void init_qq_dissector(struct ndpi_detection_module_struct *ndpi_struct, u_int32_t *id, NDPI_PROTOCOL_BITMASK *detection_bitmask)
    {
      ndpi_set_bitmask_protocol_detection("QQ", ndpi_struct, detection_bitmask, *id,
                          NDPI_PROTOCOL_QQ,
                          ndpi_search_qq,
                          NDPI_SELECTION_BITMASK_PROTOCOL_V4_V6_UDP_WITH_PAYLOAD,
                          SAVE_DETECTION_BITMASK_AS_UNKNOWN,
                          ADD_TO_DETECTION_BITMASK);
    
      *id += 1;
    }
    

    一个回调函数,用来处理数据包,这个函数就是初始化中注册的函数,这个函数将细分情况,然后交给实际的分析函数,这里分别是ndpi_search_qq_udpndpi_search_qq_tcp。虽然也可以直接在这里分析处理,但这样会显得层次结构不清晰

    void ndpi_search_qq(struct ndpi_detection_module_struct *ndpi_struct, struct ndpi_flow_struct *flow)
    {
      struct ndpi_packet_struct *packet = &flow->packet;
    
      if (packet->udp != NULL && flow->detected_protocol_stack[0] != NDPI_PROTOCOL_QQ)
        ndpi_search_qq_udp(ndpi_struct, flow);
    
      if (packet->tcp != NULL && flow->detected_protocol_stack[0] != NDPI_PROTOCOL_QQ)
        ndpi_search_qq_tcp(ndpi_struct, flow);
    }

    协议分析器的框架就到此为止,然后将初始化函数添加到ndpi_main.c文件的ndpi_init_protocol_defaults函数中,像这样:

    static void ndpi_init_protocol_defaults(struct ndpi_detection_module_struct *ndpi_mod) {
    
      int i;
      ndpi_port_range ports_a[MAX_DEFAULT_PORTS], ports_b[MAX_DEFAULT_PORTS];
      u_int16_t no_master[2] = { NDPI_PROTOCOL_NO_MASTER_PROTO, NDPI_PROTOCOL_NO_MASTER_PROTO },
        custom_master[2];
    
        /* Reset all settings */
        memset(ndpi_mod->proto_defaults, 0, sizeof(ndpi_mod->proto_defaults));
    
    //......
        ndpi_set_proto_defaults(ndpi_mod, NDPI_PROTOCOL_FUN, NDPI_PROTOCOL_QQ,
                        no_master,
                        no_master, "QQ",
                        ndpi_build_default_ports(ports_a, 0, 0, 0, 0, 0) /* TCP */,
                        ndpi_build_default_ports(ports_b, 0, 0, 0, 0, 0) /* UDP */);
    
    
    //......
    }

    宏定义NDPI_PROTOCOL_LONG_STRINGNDPI_PROTOCOL_SHORT_STRING中添加协议名称字符串。
    协议分析器的结构框架大概如此了

    ndpi协议分析中QQ协议分析器的代码概要

    根据packet是tcp还是udp将探测过程被分为两中情况:

    void ndpi_search_qq(struct ndpi_detection_module_struct *ndpi_struct, struct ndpi_flow_struct *flow)
    {
      struct ndpi_packet_struct *packet = &flow->packet;
    
      if (packet->udp != NULL && flow->detected_protocol_stack[0] != NDPI_PROTOCOL_QQ)
        ndpi_search_qq_udp(ndpi_struct, flow);
    
      if (packet->tcp != NULL && flow->detected_protocol_stack[0] != NDPI_PROTOCOL_QQ)
        ndpi_search_qq_tcp(ndpi_struct, flow);
    }

    看一下qq的udp报文是怎么探测的,在下面这个函数中

    
    static void ndpi_search_qq_udp(struct ndpi_detection_module_struct *ndpi_struct, struct ndpi_flow_struct *flow)
    {
      struct ndpi_packet_struct *packet = &flow->packet;
    
      static const u_int16_t p8000_patt_02[13] =    // maybe version numbers
        { 0x1549, 0x1801, 0x180d, 0x0961, 0x01501, 0x0e35, 0x113f, 0x0b37, 0x1131, 0x163a, 0x1e0d, 0x3619,};
      u_int16_t no_of_patterns = 12, index = 0;
    
    
      NDPI_LOG(NDPI_PROTOCOL_QQ, ndpi_struct, NDPI_LOG_DEBUG, "search qq udp.\n");
    
    
      if (flow->qq_stage <= 3) {
        if ((packet->payload_packet_len == 27 && ntohs(get_u_int16_t(packet->payload, 0)) == 0x0300
         && packet->payload[2] == 0x01)
        || (packet->payload_packet_len == 84 && ((ntohs(get_u_int16_t(packet->payload, 0)) == 0x000e
                              && packet->payload[2] == 0x35)
                             || (ntohs(get_u_int16_t(packet->payload, 0)) == 0x0015
                                 && packet->payload[2] == 0x01)
                             || (ntohs(get_u_int16_t(packet->payload, 0)) == 0x000b
                                 && packet->payload[2] == 0x37)
                             || (ntohs(get_u_int16_t(packet->payload, 0)) == 0x0015
                                 && packet->payload[2] == 0x49)))
        || (packet->payload_packet_len > 10
            && ((get_u_int16_t(packet->payload, 0) == htons(0x000b) && packet->payload[2] == 0x37)
            || (get_u_int32_t(packet->payload, 0) == htonl(0x04163a00)
                && packet->payload[packet->payload_packet_len - 1] == 0x03
                && packet->payload[4] == packet->payload_packet_len)))) {
          /*
        if (flow->qq_stage == 3 && flow->detected_protocol == NDPI_PROTOCOL_QQ) {
        if (flow->packet_direction_counter[0] > 0 && flow->packet_direction_counter[1] > 0) {
        flow->protocol_subtype = NDPI_PROTOCOL_QQ_SUBTYPE_AUDIO;
        return;
        } else if (flow->packet_counter < 10) {
        return;
        }
        } */
          flow->qq_stage++;
          if (flow->qq_stage == 3) {
        NDPI_LOG(NDPI_PROTOCOL_QQ, ndpi_struct, NDPI_LOG_DEBUG,
             "found qq udp pattern 030001 or 000e35 four times.\n");
        ndpi_int_qq_add_connection(ndpi_struct, flow);
        return;
          }
          return;
        }
        if (packet->payload_packet_len > 2 && (packet->payload[0] == 0x02 || packet->payload[0] == 0x04)) {
          u_int16_t pat = ntohs(get_u_int16_t(packet->payload, 1));
          for (index = 0; index < no_of_patterns; index++) {
        if (pat == p8000_patt_02[index] && packet->payload[packet->payload_packet_len - 1] == 0x03) {
          flow->qq_stage++;
          // maybe we can test here packet->payload[4] == packet->payload_packet_len
          if (flow->qq_stage == 3) {
            NDPI_LOG(NDPI_PROTOCOL_QQ, ndpi_struct, NDPI_LOG_DEBUG,
                 "found qq udp pattern 02 ... 03 four times.\n");
            /*
              if (packet->payload[0] == 0x04) {
              ndpi_int_qq_add_connection(ndpi_struct, flow, NDPI_REAL_PROTOCOL);
              return;
              } */
            ndpi_int_qq_add_connection(ndpi_struct, flow);
            return;
          }
          return;
        }
          }
        }
        if (packet->payload_packet_len == 84 && (packet->payload[0] == 0 || packet->payload[0] == 0x03)) {
          u_int16_t pat = ntohs(get_u_int16_t(packet->payload, 1));
          for (index = 0; index < no_of_patterns; index++) {
        if (pat == p8000_patt_02[index]) {
          flow->qq_stage++;
          /*
            if (flow->qq_stage == 3 && flow->packet_direction_counter[0] > 0 &&
            flow->packet_direction_counter[1] > 0) {
            NDPI_LOG(NDPI_PROTOCOL_QQ, ndpi_struct, NDPI_LOG_DEBUG, "found qq udp pattern four times.\n");
            ndpi_int_qq_add_connection(ndpi_struct, flow, NDPI_REAL_PROTOCOL);
            return;
            } else */ if (flow->qq_stage == 3) {
            NDPI_LOG(NDPI_PROTOCOL_QQ, ndpi_struct, NDPI_LOG_DEBUG, "found qq udp pattern four times.\n");
            ndpi_int_qq_add_connection(ndpi_struct, flow);
            return;
          }
          return;
        }
          }
        }
        if (packet->payload_packet_len > 2 && packet->payload[0] == 0x04
        && ((ntohs(get_u_int16_t(packet->payload, 1)) == 0x1549
             || ntohs(get_u_int16_t(packet->payload, 1)) == 0x1801 || ntohs(get_u_int16_t(packet->payload, 1)) == 0x0961)
            ||
            (packet->payload_packet_len > 16
             && (ntohs(get_u_int16_t(packet->payload, 1)) == 0x180d || ntohs(get_u_int16_t(packet->payload, 1)) == 0x096d)
             && ntohl(get_u_int32_t(packet->payload, 12)) == 0x28000000
             && ntohs(get_u_int16_t(packet->payload, 3)) == packet->payload_packet_len))
        && packet->payload[packet->payload_packet_len - 1] == 0x03) {
          flow->qq_stage++;
          if (flow->qq_stage == 3) {
        NDPI_LOG(NDPI_PROTOCOL_QQ, ndpi_struct, NDPI_LOG_DEBUG,
             "found qq udp pattern 04 1159 ... 03 four times.\n");
        ndpi_int_qq_add_connection(ndpi_struct, flow);
        return;
          }
          return;
        }
        if (packet->payload_packet_len > 2 && (packet->payload[0] == 0x06 || packet->payload[0] == 0x02)
        && ntohs(get_u_int16_t(packet->payload, 1)) == 0x0100
        && (packet->payload[packet->payload_packet_len - 1] == 0x00
            || packet->payload[packet->payload_packet_len - 1] == 0x03)) {
          flow->qq_stage++;
          if (flow->qq_stage == 3) {
        NDPI_LOG(NDPI_PROTOCOL_QQ, ndpi_struct, NDPI_LOG_DEBUG,
             "found qq udp pattern 02/06 0100 ... 03/00 four times.\n");
        ndpi_int_qq_add_connection(ndpi_struct, flow);
        return;
          }
          return;
        }
    
        if (packet->payload_packet_len > 2 && (packet->payload[0] == 0x02)
        && ntohs(get_u_int16_t(packet->payload, 1)) == 0x1131 && packet->payload[packet->payload_packet_len - 1] == 0x03) {
          flow->qq_stage++;
          if (flow->qq_stage == 3) {
        NDPI_LOG(NDPI_PROTOCOL_QQ, ndpi_struct, NDPI_LOG_DEBUG,
             "found qq udp pattern 02 1131 ... 03 four times.\n");
        ndpi_int_qq_add_connection(ndpi_struct, flow);
        return;
          }
          return;
        }
    
        if (packet->payload_packet_len > 5 && get_u_int16_t(packet->payload, 0) == htons(0x0203) &&
        ntohs(get_u_int16_t(packet->payload, 2)) == packet->payload_packet_len &&
        get_u_int16_t(packet->payload, 4) == htons(0x0b0b)) {
          flow->qq_stage++;
          if (flow->qq_stage == 3) {
        NDPI_LOG(NDPI_PROTOCOL_QQ, ndpi_struct, NDPI_LOG_DEBUG,
             "found qq udp pattern 0203[packet_length_0b0b] three times.\n");
        ndpi_int_qq_add_connection(ndpi_struct, flow);
        return;
          }
          return;
        }
    
        if (packet->udp->dest == htons(9000) || packet->udp->source == htons(9000)) {
          if (packet->payload_packet_len > 3
          && ntohs(get_u_int16_t(packet->payload, 0)) == 0x0202
          && ntohs(get_u_int16_t(packet->payload, 2)) == packet->payload_packet_len) {
        flow->qq_stage++;
        if (flow->qq_stage == 3) {
          NDPI_LOG(NDPI_PROTOCOL_QQ, ndpi_struct, NDPI_LOG_DEBUG,
               "found qq udp pattern 02 02 <length> four times.\n");
          ndpi_int_qq_add_connection(ndpi_struct, flow);
          return;
        }
        return;
          }
    
        }
      }
    
      if (ndpi_is_valid_qq_packet(packet)) {
        flow->qq_stage++;
        if (flow->qq_stage == 3) {
          NDPI_LOG(NDPI_PROTOCOL_QQ, ndpi_struct, NDPI_LOG_DEBUG, "found qq over udp.\n");
          ndpi_int_qq_add_connection(ndpi_struct, flow);
          return;
        }
        NDPI_LOG(NDPI_PROTOCOL_QQ, ndpi_struct, NDPI_LOG_DEBUG, "found qq packet stage %d\n", flow->qq_stage);
        return;
      }
    
      if (ndpi_is_valid_qq_ft_packet(packet)) {
        flow->qq_stage++;
        if (flow->qq_stage == 3) {
          NDPI_LOG(NDPI_PROTOCOL_QQ, ndpi_struct, NDPI_LOG_DEBUG, "found qq ft over udp.\n");
          ndpi_int_qq_add_connection(ndpi_struct, flow);
          return;
        }
        return;
      }
    
      if (flow->qq_stage && flow->packet_counter <= 5) {
        return;
      }
    
      NDPI_LOG(NDPI_PROTOCOL_QQ, ndpi_struct, NDPI_LOG_DEBUG, "QQ excluded\n");
      NDPI_ADD_PROTOCOL_TO_BITMASK(flow->excluded_protocol_bitmask, NDPI_PROTOCOL_QQ);
    }

    该函数有点长,不过基本都是属于探测OICQ协议的报头,oicq协议是qq用于即时通信的协议,数据流经8000端口,具体oicq协议头的解释可参看arvik的另一篇博客http://blog.csdn.net/u012819339/article/details/50374252

    得到payload头指针后起始可以直接强制指针类型转换成 oicqhdr *,就比较方便啦

    typedef struct _oicqhdr {
        uint8_t flag;
        uint16_t ver;
        uint16_t command;
        uint16_t sequence;
        uint32_t qq;
    } __attribute__((packed)) oicqhdr;

    tcp检测就不叙述了,总之都是先抓包分析QQ报文头的结构特征,然后拿到协议分析器中做匹配。

    ndpi协议分析中编写一个微信协议分析器的方法指导

    协议分析器框架见上文所述,可以参照QQ协议分析器依葫芦画瓢,
    这里主要是弄清微信协议的格式,这需要自己抓包分析,arvik已经做好了一部分微信抓包分析的过程,见我的博客微信数据包(链接地址http://blog.csdn.net/u012819339/article/details/52588288),微信客户端有很多模块,比如发红包,漂流瓶,摇一摇,传图片,发语音,发短视频等等,每个模块都可能会有一种协议格式,arvik并没有完全对这些模块进行分析,需要开发者自行抓包。


    好了,本文到此结束,作者arvik。
    【智能路由器】系列文章连接
    http://blog.csdn.net/u012819339/article/category/5803489

    展开全文
  • TCP/IP 网络协议分析器

    2011-06-23 13:37:08
    网络协议分析器。 先安装Winpcap 软驱动(中间层驱动),再配置Winpcap 库文件目录。
  • Cuishark一个在CUI/TUI中的协议分析器类似于一个wireshark
  • USB协议分析器

    2016-07-28 17:50:50
    由于分析USB接口传输的数据
  • Bus Hound是一个超级软件总线协议分析器,用于捕捉来自设备的协议包和输入输出操作,其优良特性如下: 支持所有版本的IDE,SCSI,USB,1394总线 支持各类设备如硬盘库,DVD,鼠标,扫描仪,网络照相机等 捕捉数据...
  • http协议分析器,用VC写的,用到了winpcap

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,991
精华内容 1,996
关键字:

协议分析器