Пример #1
0
int AnalyzeIpv6(u_char *data, int size) {
  u_char *ptr = NULL;
  int lest = 0;
  struct ip6_hdr *ip6 = NULL;
  int len = 0;

  ptr = data;
  lest = size;

  if (lest < sizeof(struct ip6_hdr)) {
    ExitWithTooLittleLengthError("ip6_hdr", lest);
  }

  ip6 = (struct ip6_hdr *) ptr;
  ptr += sizeof(struct ip6_hdr);
  lest += sizeof(struct ip6_hdr);

  PrintIp6Header(ip6, stdout);

  if (ip6->ip6_nxt == IPPROTO_ICMPV6) {
    len = ntohs(ip6->ip6_plen);
    if (checkIP6DATAchecksum(ip6, ptr, len) == 0) {
      ExitWithBadChecksumError("icmp6");
    }
    AnalyzeIcmp6(ptr, lest);
  }
  else if (ip6->ip6_nxt == IPPROTO_TCP) {   // next header
    len =ntohs(ip6->ip6_plen);              // payload length
    if (checkIPDATAchecksum(ip6, ptr, len) == 0) {
      ExitWithBadChecksumError("tcp6");
    }
    AnalyzeTcp(ptr, lest);
  }
  else if (ip6->ip6_nxt == IPPROTO_UDP) {
    len = ntohs(ip6->ip6_plen);
    if (checkIP6DATAchecksum(ip6, ptr, len) == 0) {
      ExitWithBadChecksumError("udp6");
    }
    AnalyzeUdp(ptr, lest);
  }

  return 0;
}
Пример #2
0
int RewritePacket (int deviceNo, u_char *data, int size)
{
    u_char *ptr;
    struct ether_header *eh;
    int lest, len;

    ptr=data;
    lest=size;

    if(lest<sizeof(struct ether_header)) {
        DebugPrintf("[%d]:lest(%d)<sizeof(struct ether_header)\n",deviceNo,lest);
        return(-1);
    }

    eh=(struct ether_header *)ptr;
    ptr+=sizeof(struct ether_header);
    lest-=sizeof(struct ether_header);

    char dMacAddr[18];
    char sMacAddr[18];

    // Get dMAC, sMAC
    my_ether_ntoa_r(eh->ether_dhost, dMacAddr, sizeof(dMacAddr));
    my_ether_ntoa_r(eh->ether_shost, sMacAddr, sizeof(sMacAddr));

    // physicalNIC -> wirelessNIC
    if((strncmp(sMacAddr, cliMacAddr, SIZE_MAC)==0) &&
            (strncmp(dMacAddr, dev3MacAddr, SIZE_MAC)==0)) {
        my_ether_aton_r(apMacAddr, eh->ether_dhost);
        my_ether_aton_r(dev1MacAddr, eh->ether_shost);

        // Case: IP
        if (ntohs(eh->ether_type)==ETHERTYPE_IP) {
            struct iphdr *iphdr;
            u_char option[1500];
            int optLen;

            iphdr=(struct iphdr *)ptr;
            ptr+=sizeof(struct iphdr);
            lest-=sizeof(struct iphdr);
            optLen=iphdr->ihl*4-sizeof(struct iphdr);
            if(optLen>0) {
                memcpy(option, ptr, optLen);
                ptr+=optLen;
                lest-=optLen;
            }

            // Rewrite IP Address
            if(iphdr->saddr==inet_addr(cliIpAddr)) {
                iphdr->saddr=inet_addr(dev1IpAddr);
            }
            iphdr->check=0;
            iphdr->check=calcChecksum2((u_char *)iphdr, sizeof(struct iphdr), option, optLen);

            // Case : TCP
            if(iphdr->protocol==IPPROTO_TCP) {
                struct tcphdr *tcphdr;

                len=ntohs(iphdr->tot_len)-iphdr->ihl*4;
                tcphdr=(struct tcphdr *)ptr;
                tcphdr->check=0;
                tcphdr->check=checkIPDATAchecksum(iphdr, ptr, len);
            }
            // Case : UDP
            if(iphdr->protocol==IPPROTO_UDP) {
                struct udphdr* udphdr;

                len=ntohs(iphdr->tot_len)-iphdr->ihl*4;
                udphdr=(struct udphdr *)ptr;
                udphdr->check=0;
            }
        }
    }
    // wirelessNIC -> physicalNIC
    else if (strncmp(dMacAddr, dev1MacAddr, SIZE_MAC)==0) {
        my_ether_aton_r(cliMacAddr, eh->ether_dhost);
        my_ether_aton_r(dev3MacAddr, eh->ether_dhost);

        // Case: IP
        if (ntohs(eh->ether_type)==ETHERTYPE_IP) {
            struct iphdr *iphdr;
            u_char option[1500];
            int optLen;

            iphdr=(struct iphdr *)ptr;
            ptr+=sizeof(struct iphdr);
            lest-=sizeof(struct iphdr);
            optLen=iphdr->ihl*4-sizeof(struct iphdr);
            if(optLen>0) {
                memcpy(option, ptr, optLen);
                ptr+=optLen;
                lest-=optLen;
            }

            // Rewrite IP Address
            if(iphdr->daddr==inet_addr(dev1IpAddr)) {
                iphdr->daddr=inet_addr(cliIpAddr);
            }
            iphdr->check=0;
            iphdr->check=calcChecksum2((u_char *)iphdr, sizeof(struct iphdr), option, optLen);

            // Case : TCP
            if(iphdr->protocol==IPPROTO_TCP) {
                struct tcphdr *tcphdr;

                len=ntohs(iphdr->tot_len)-iphdr->ihl*4;
                tcphdr=(struct tcphdr *)ptr;
                tcphdr->check=0;
                tcphdr->check=checkIPDATAchecksum(iphdr, ptr, len);
            }
            // Case : UDP
            if(iphdr->protocol==IPPROTO_UDP) {
                struct udphdr* udphdr;

                len=ntohs(iphdr->tot_len)-iphdr->ihl*4;
                udphdr=(struct udphdr *)ptr;
                udphdr->check=0;
            }
        }
    }
    return(0);
}
Пример #3
0
int AnalyzeIp(u_char *data, int size) {
  u_char *ptr = NULL;
  int lest = 0;
  struct iphdr *iphdr = NULL;   // IPヘッダ
  u_char *option = NULL;        // ヘッダオプション
  int optionLen = 0;            // ヘッダオプションサイズ
  int len = 0;
  unsigned short sum = 0;

  ptr = data;    // IPヘッダの先頭ポインタ
  lest = size;

  if (lest < sizeof(struct iphdr)) {
    ExitWithTooLittleLengthError("iphdr", lest);
  }

  iphdr = (struct iphdr *) ptr;   // IPヘッダの先頭ポインタ
  ptr += sizeof(struct iphdr);    // IPヘッダオプションの先頭ポインタ
  lest -= sizeof(struct iphdr);

  // ヘッダオプションサイズを求める(パディングを含む)
  optionLen = iphdr->ihl * 4 - sizeof(struct iphdr);

  if (optionLen > 0) {
    if (optionLen >= 1500) {
      fprintf(stderr, "IP optionLen(%d):too big\n", optionLen);
    }
    option = ptr;        // IPヘッダオプションの先頭ポインタ
    ptr += optionLen;    // ペイロードの先頭ポインタ
    lest -= optionLen;
  }

  if (checkIPchecksum(iphdr, option, optionLen) == 0) {
    ExitWithBadChecksumError("ip");
  }

  PrintIpHeader(iphdr, option, optionLen, stdout);

  if (iphdr->protocol == IPPROTO_ICMP) {
    // ペイロードサイズを取得する
    // tot_lenはペイロードを含めたIPヘッダのサイズ
    len = ntohs(iphdr->tot_len) - iphdr->ihl * 4;
    sum = checksum(ptr, len);   // ペイロードのチェックサムを取得する
    if (sum != 0 && sum != 0xFFFF) {
      ExitWithBadChecksumError("icmp");
    }
    AnalyzeIcmp(ptr, lest);
  }
  else if (iphdr->protocol == IPPROTO_TCP) {
    // ペイロードサイズを取得する
    len = ntohs(iphdr->tot_len) - iphdr->ihl * 4;
    if (checkIPDATAchecksum(iphdr, ptr, len) == 0) {
      ExitWithBadChecksumError("tcp");
    }
    AnalyzeTcp(ptr, lest);
  }
  else if (iphdr->protocol == IPPROTO_UDP) {
    struct udphdr *udphdr;
    udphdr = (struct udphdr *) ptr;
    len = ntohs(iphdr->tot_len) - iphdr->ihl * 4;
    if (udphdr->check != 0 && checkIPDATAchecksum(iphdr, ptr, len) == 0) {
      ExitWithBadChecksumError("udp");
    }
    AnalyzeUdp(ptr, lest);
  }

  return 0;
}
Пример #4
0
int AnalyzeIp(u_char *data,int size)
{
u_char	*ptr;
int	lest;
struct iphdr	*iphdr;
u_char	*option;
int	optionLen,len;
unsigned short  sum;

	ptr=data;
	lest=size;

	if(lest<sizeof(struct iphdr)){
		if(fil[2] == 1 || fil[3] == 1 || fil[4] == 1 || fil [6] == 1){
		fprintf(stderr,"lest(%d)<sizeof(struct iphdr)\n",lest);
		}
		return(-1);
	}
	iphdr=(struct iphdr *)ptr;
	ptr+=sizeof(struct iphdr);
	lest-=sizeof(struct iphdr);

	optionLen=iphdr->ihl*4-sizeof(struct iphdr);
	if(optionLen>0){
		if(optionLen>=1500){
			if(fil[2] == 1 || fil[3] == 1 || fil[4] == 1 || fil[6] == 1){
			fprintf(stderr,"IP optionLen(%d):too big\n",optionLen);
			}
			return(-1);
		}
		option=ptr;
		ptr+=optionLen;
		lest-=optionLen;
	}

	if(checkIPchecksum(iphdr,option,optionLen)==0){
		fprintf(stderr,"bad ip checksum\n");
		return(-1);
	}

	if(fil[6] == 1){
	PrintIpHeader(iphdr,option,optionLen,stdout);
	}

	if(iphdr->protocol==IPPROTO_ICMP){
		len=ntohs(iphdr->tot_len)-iphdr->ihl*4;
		sum=checksum(ptr,len);
		if(sum!=0&&sum!=0xFFFF){
			fprintf(stderr,"bad icmp checksum\n");
			return(-1);
		}
		AnalyzeIcmp(ptr,lest);
	}
	else if(iphdr->protocol==IPPROTO_TCP){
		len=ntohs(iphdr->tot_len)-iphdr->ihl*4;
		if(checkIPDATAchecksum(iphdr,ptr,len)==0){
			fprintf(stderr,"bad tcp checksum\n");
			return(-1);
		}
		AnalyzeTcp(ptr,lest);
	}
	else if(iphdr->protocol==IPPROTO_UDP){
		struct udphdr	*udphdr;
		udphdr=(struct udphdr *)ptr;
		len=ntohs(iphdr->tot_len)-iphdr->ihl*4;
		if(udphdr->check!=0&&checkIPDATAchecksum(iphdr,ptr,len)==0){
			fprintf(stderr,"bad udp checksum\n");
			return(-1);
		}
		AnalyzeUdp(ptr,lest);
	}

	return(0);
}