打開我的收藏夾 --TCP篇

TCP/IP 類

[看雪2018峰會回顧] TCP的厄運，網路協議側信道分析及利用

解決CLOSE_WAIT、TIME_WAIT連接狀態過多正確姿勢

像這種啊，你現在問我我肯定是不會背的，不過讓我抽出手來拿幾個專案練練，嘿嘿，就OK了，

先來看下一臺生產環境中的各種tcp狀態的連接數：

netstat -n| awk '/^tcp/ {++S[$NF]} END {for(a in S) print a, S[a]}'

然后我們來分析下占比比較高的幾種狀態產生的原因和解決方法：

• CLOSE_WAIT
  咳咳，這就，很奇葩啊，是你的用戶量巨大嗎？不然就是服務器出問題了，如部分情況下不會執行socket的close方法，解決方法是查程式，

• TIME_WAIT
  time_wait是一個需要特別注意的狀態，他本身是一個正常的狀態，只在主動斷開那方出現，每次tcp主動斷開都會有這個狀態的，維持這個狀態的時間是2個msl周期（2分鐘），設計這個狀態的目的是為了防止我發了ack包對方沒有收到可以重發，那如何解決出現大量的time_wait連接呢？千萬不要把tcp_tw_recycle改成1，正確的姿勢應該是降低msl周期，也就是tcp_fin_timeout值，同時增加time_wait的佇列，防止滿了，

為什么不能把tcp_tw_recycle改成1？

改成1的后果是會導致一個路由器后面用戶有人能連你服務器有人telnet不通，
原因是tcp_tw_recycle改成1后會啟用tcp的tcp_timestamps功能，這個功能簡單說就是所有的通信包是時間戳遞增的，如果收到了同一個IP下時間戳小的包那就說明是個老資料包，就會丟棄這個包，
而一個路由器下每臺電腦的時間戳不是完全一致的，有的電腦的時間戳會小，導致這些電腦發出的通信包被直接丟棄了，

正確的tcp優化姿勢

（回頭做畢設的時候試一下）
修改/etc/sysctl.conf 檔案，內容如下：

net.nf_conntrack_max = 1000000
#發送keepalive的心跳
net.ipv4.tcp_keepalive_time = 1200
net.ipv4.tcp_tw_reuse = 0
#不能改成1 否則NAT后面的客戶端可能連接不上
net.ipv4.tcp_tw_recycle = 0
net.ipv4.tcp_fin_timeout = 30
#timewait佇列最大數量
net.ipv4.tcp_max_tw_buckets = 262144
#建立連接握手程序的ack重發次數從5到3
net.ipv4.tcp_synack_retries = 3
#快取syn請求數量 解決messsage日志中syn溢位日志
net.ipv4.tcp_max_syn_backlog = 8192
net.ipv4.tcp_syncookies = 1
#linux收包快取
net.core.rmem_default=262144
net.core.wmem_default=262144
net.core.rmem_max=4194304
net.core.wmem_max=4194304
net.core.somaxconn=1024
vm.overcommit_memory = 1
vm.max_map_count=262144

TCP/IP常見攻擊

了解一下哈，我哥說，我要走到那個位置，別的技術可以不用很深，但是一定要有足夠的了解，這不還有些年嘛，時間緊迫了啊！！！

1、IP欺騙，偽造某臺主機的 IP 地址的技術，我不會，不過沒事沒事，我有一個好兄弟跟我一樣的喜歡在自己的領域深耕，他就是網路安全領域的，

2、SYN Flooding，這個我知道，我給你握兩次手，第三次我不理你了嘿、、、然后你的資源就這樣被我鴿干凈了，

3、UDP Flooding，UDP 洪泛是也是一種拒絕服務攻擊，將大量的用戶資料報協議（UDP）資料包發送到目標服務器，目的是壓倒該設備的處理和回應能力，防火墻保護目標服務器也可能因 UDP 泛濫而耗盡，從而導致對合法流量的拒絕服務，

大多數作業系統部分限制了 ICMP 報文的回應速率，以中斷需要 ICMP 回應的 DDoS 攻擊，這種緩解的一個缺點是在攻擊程序中，合法的資料包也可能被過濾，如果 UDP Flood 的容量足夠高以使目標服務器的防火墻的狀態表飽和，則在服務器級別發生的任何緩解都將不足以應對目標設備上游的瓶頸，

4、TCP 重置攻擊
問題不大，對長連接還有點用，短鏈接，等他破譯了我的序列號，我早自己斷開了，，

5、中間人攻擊
開頭那鏈接里有，
攻擊中間人攻擊英文名叫 Man-in-the-MiddleAttack，簡稱「MITM攻擊」，指攻擊者與通訊的兩端分別創建獨立的聯系，并交換其所收到的資料，使通訊的兩端認為他們正在通過一個私密的連接與對方 直接對話，但事實上整個會話都被攻擊者完全控制，

6、DDOS
分布式拒絕服務，指的是處于不同位置的多個攻擊者同時向一個或數個目標發動攻擊，是一種分布的、協同的大規模攻擊方式，

粘包

不扯那些虛的，直接上代碼，然后專案里面做基準測驗便知：

C

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <errno.h>

#define MAX_BUF  1024
//自定義封包的結構體
typedef struct _my_pkt
{
  int len;//自定義的包頭，包含了包的大小
  char buf[MAX_BUF];//包存放的資料
}my_pkt;

void handle(int sig)
{
  printf("recv : %d\n",sig);
  exit(0);
}

//@ssize_t：回傳讀的長度 若ssize_t<count 讀失敗
//@buf：接受資料記憶體首地址
//@count：接受資料長度
ssize_t readn(int fd,void *buf,size_t cnt)
{
  size_t nleft = cnt;//定義剩余沒有讀取的個數
  ssize_t nread = 0;//讀取的個數
  char * bufp = (char *)buf;//將引數接過來

  while(nleft > 0)//當剩余需要讀取的個數>0
  {
    if((nread  = read(fd,bufp,nleft)) < 0)//成功讀取的個數小于0,則判斷出錯的原因
    {
      //如果errno被設定為EINTR為被信號中斷，如果是被信號中斷繼續，
//不是信號中斷則退出，
      if(errno == EINTR)
      {
        continue;
      }  
      perror("write");
      exit(-1);
    }
    else if(nread == 0)//若對方已關閉
    {
      return cnt - nleft;
    }

    bufp += nread;//將 字串指標向后移動已經成功讀取個數的大小，
    nleft -= nread;//需要讀取的個數=需要讀取的個數-以及成功讀取的個數
  }

  return cnt;
}


//@ssize_t：回傳寫的長度 -1失敗
//@buf：待寫資料首地址
//@count：待寫長度
ssize_t writen(int fd,const void *buf,size_t cnt)
{
  size_t nleft = cnt;//需要寫入的個數
  ssize_t nwritten = 0;//已經成功寫入的個數
  char * bufp = (char *)buf;//接引數

  while(nleft > 0)//如果需要寫入的個數>0
  {
    //如果寫入成功的個數<0 判斷是否是被信號打斷
    if((nwritten  = write(fd,bufp,nleft)) < 0)
    {
      if(errno == EINTR)//信號打斷，則繼續
      {
        continue;
      }  
      perror("write");
      exit(-1);
    }
    //需要寫入的資料個數>0
        //如果成功寫入的個數為0 則繼續
    else if(nwritten == 0)
    {
      continue;
    }

    bufp += nwritten;//將bufp指標向后移動已經
    nleft -= nwritten;//剩余個數
  }

  return cnt;
}

int main()
{

  int clt_fd;
  struct sockaddr_in serv_addr;

  char addr_dst[INET_ADDRSTRLEN] = {0};
  ssize_t ret;

  my_pkt sendbuf;
    my_pkt recvbuf;
  int num = 0;

  memset(&sendbuf,0,sizeof(sendbuf));//清空結構體
  memset(&recvbuf,0,sizeof(recvbuf));//清空結構體

  signal(SIGUSR1,handle);

  clt_fd = socket(AF_INET,SOCK_STREAM,0);
  if(-1 == clt_fd)
  {
    perror("socket");
    exit(-1);
  } 

  serv_addr.sin_family = AF_INET;
  serv_addr.sin_port = htons(8001);
  serv_addr.sin_addr.s_addr = inet_addr("192.168.1.110");

  if(connect(clt_fd,(struct sockaddr*)&serv_addr,sizeof(serv_addr)) == -1)
  {
    perror("connect");
    exit(-1);
  }
  printf("Connect successfully\t%s at PORT %d\n",inet_ntop(AF_INET,&serv_addr.sin_addr,addr_dst,sizeof(addr_dst)),ntohs(serv_addr.sin_port));

  while(fgets(sendbuf.buf,sizeof(sendbuf.buf),stdin) != NULL)
  {
    num = strlen(sendbuf.buf);
    sendbuf.len = htonl(num);

    writen(clt_fd,&sendbuf,sizeof(sendbuf.len)+num);


    ret = readn(clt_fd,&(recvbuf.len),sizeof(recvbuf.len));//讀包頭 4個位元組
    if(-1 == ret)
    {
      perror("readn for len");
      exit(-1);
    }
    else if(ret < 4)//如果讀取的個數小于4,則對方已經關閉
    {
      printf("client close");
      break;
    }

    num = ntohl(recvbuf.len);//將網路資料轉換為本地資料結構，比如網路資料為大端，而本地資料為小端
    ret = readn(clt_fd,recvbuf.buf,num);//根據包頭里包含的大小讀取資料
    if(-1 == ret)
    {
      perror("readn for buf");
      exit(-1);
    }
    else if(ret < num)//如果讀取的資料的大小小于封包包頭中包的大小，那么對方已經關閉
    {
      printf("client close");
      break;
    }
    fputs(recvbuf.buf,stdout);//將資料列印出

    memset(&sendbuf,0,sizeof(sendbuf));//清空結構體
    memset(&recvbuf,0,sizeof(recvbuf));//清空結構體
  }

  return 0;
}

S

/*server04*/

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <errno.h>

#define MAX_CLIENT 10
#define MAX_BUF  1024

//自定義封包的結構體
typedef struct _my_pkt
{
  int len;//自定義的包頭，包含了包的大小
  char buf[MAX_BUF];//包存放的資料
}my_pkt;

void handle(int sig)//輔助殺死子行程或者父行程
{
  printf("recv : %d\n",sig);
  exit(0);
}

//@ssize_t：回傳讀的長度 若ssize_t<count 讀失敗
//@buf：接受資料記憶體首地址
//@count：接受資料長度
ssize_t readn(int fd,void *buf,size_t cnt)
{
  size_t nleft = cnt;//定義剩余沒有讀取的個數
  ssize_t nread = 0;//讀取的個數
  char * bufp = (char *)buf;//將引數接過來

  while(nleft > 0)//當剩余需要讀取的個數>0
  {
    if((nread  = read(fd,bufp,nleft)) < 0)//成功讀取的個數小于0,則判斷出錯的原因
    {
      //如果errno被設定為EINTR為被信號中斷，如果是被信號中斷繼續，
//不是信號中斷則退出，
      if(errno == EINTR)
      {
        continue;
      }  
      perror("write");
      exit(-1);
    }
    else if(nread == 0)//若對方已關閉
    {
      return cnt - nleft;
    }

    bufp += nread;//將 字串指標向后移動已經成功讀取個數的大小，
    nleft -= nread;//需要讀取的個數=需要讀取的個數-以及成功讀取的個數
  }

  return cnt;
}


//@ssize_t：回傳寫的長度 -1失敗
//@buf：待寫資料首地址
//@count：待寫長度
ssize_t writen(int fd,const void *buf,size_t cnt)
{
  size_t nleft = cnt;//需要寫入的個數
  ssize_t nwritten = 0;//已經成功寫入的個數
  char * bufp = (char *)buf;//接引數

  while(nleft > 0)//如果需要寫入的個數>0
  {
    //如果寫入成功的個數<0 判斷是否是被信號打斷
    if((nwritten  = write(fd,bufp,nleft)) < 0)
    {
      if(errno == EINTR)//信號打斷，則繼續
      {
        continue;
      }  
      perror("write");
      exit(-1);
    }
    //需要寫入的資料個數>0
        //如果成功寫入的個數為0 則繼續
    else if(nwritten == 0)
    {
      continue;
    }

    bufp += nwritten;//將bufp指標向后移動已經
    nleft -= nwritten;//剩余個數
  }

  return cnt;
}

void do_service(int fd)
{
  my_pkt rcv_pkt;//定義了封包結構體
  int num = 0;//資料包長度--封包的包頭
  int ret = 0;
  while(1)
  {
    memset(&rcv_pkt,0,sizeof(rcv_pkt));//清空結構體
    ret = readn(fd,&(rcv_pkt.len),sizeof(rcv_pkt.len));//讀包頭 4個位元組
    if(-1 == ret)
    {
      perror("readn for len");
      exit(-1);
    }
    else if(ret < 4)//如果讀取的個數小于4,則對方已經關閉
    {
      printf("client close");
      break;
    }

    num = ntohl(rcv_pkt.len);//將網路資料轉換為本地資料結構，比如網路資料為大端，而本地資料為小端
    ret = readn(fd,rcv_pkt.buf,num);//根據包頭里包含的大小讀取資料
    if(-1 == ret)
    {
      perror("readn for buf");
      exit(-1);
    }
    else if(ret < num)//如果讀取的資料的大小小于封包包頭中包的大小，那么對方已經關閉
    {
      printf("client close");
      break;
    }
    fputs(rcv_pkt.buf,stdout);//將資料列印出
    //將接受到的資料再直接發出去，
    writen(fd,&rcv_pkt,sizeof(rcv_pkt.len)+num);  //注意寫資料的時候，多加包頭長度（len）部分 
  }

}

int main()
{

  int serv_fd,con_fd;//服務器端至少要有兩個套接字檔案描述符--一個用來監聽，一個/其余多個用來和客戶端通信
  struct sockaddr_in serv_addr;//IPV4套接字結構體--服務器
  struct sockaddr_in clt_addr;//IPV4套接字結構體--客戶端

  int optvar;//地址復用使用的引數
  pid_t pid;//子行程PID

  socklen_t addr_len;

  signal(SIGUSR1,handle);//注冊新號和處理函式

  serv_fd = socket(AF_INET,SOCK_STREAM,0);//建立套接字
  if(-1 == serv_fd)
  {
    perror("socket");
    exit(-1);
  }

  if(setsockopt(serv_fd, SOL_SOCKET,SO_REUSEADDR,&optvar,sizeof(optvar))  == -1 )//地址復用
  {
    perror("setsockopt");
    exit(-1);
  }

  /*設定地址*/
  bzero(&serv_addr,sizeof(serv_addr));
  serv_addr.sin_family = AF_INET;
  serv_addr.sin_port = htons(8001);
  serv_addr.sin_addr.s_addr = htons(INADDR_ANY);

  if(bind(serv_fd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)) == -1)//系結埠
  {
    perror("bind");
    exit(-1);
  }

  /*一旦呼叫listen函式--套接字就會變成被動套接字--用來監聽客戶端，讓客戶端連接他
  被動套接字--只能接受連接，不能主動發送連接
  做了兩個佇列：
          一個已經完成三次握手，建立連接的佇列--客戶端發connect請求被回應，已經成功完成連接
          一個是未完成成三次握手的佇列--正在握手
  */
  if(listen(serv_fd,MAX_CLIENT)== -1)//開始監聽
  {
    perror("listen");
    exit(-1);
  }

  addr_len = sizeof(clt_addr);

  printf("Accepting connections ...\n");

  while(1)
  {
    if((con_fd = accept(serv_fd,(struct sockaddr *)&clt_addr,&addr_len)) == -1)//可以支持多并發訪問
    {
      perror("accept");
      exit(-1);
    }

    printf("received from %s at PORT %d\n",inet_ntoa(clt_addr.sin_addr),ntohs(clt_addr.sin_port));

    pid = fork();//創建子行程

    if(pid == -1)
    {
      perror("fork");
      close(serv_fd);
      exit(-1);
    }
    else if(pid == 0)//子行程負責接收客戶端資料
    {
      close(serv_fd);
      do_service(con_fd);
      close(con_fd);
      kill(getppid(),SIGUSR1);
      exit(1);
    }
    else//父行程負責監聽客戶端連接請求
    {
      close(con_fd);
    }
  }

  return 0;
}

篇幅有點長了哈，本來還有HTTP和DNS的，下次，下次哈，