解析“微快递”小程序的交互流程

奇技指南

今天分享一篇关于Go实现TCP扫描器的文章，如果大家对Go编写扫描器感兴趣，可以看下本篇文章。希望能对大家有所帮助

Go在网络应用编程方面堪称完美。它自带的标准库也很优秀，在开发过程* P C , 5 3 L中可以给予我们很多帮助。

在本文中，我f } N们将会用Go写一个简单的TCP扫描器。整个程序的代码在50行以内。在我x I p * 6 9 h q们开始动手之前，先介绍一些理论知识。

不得不说，TCP是比我们介绍的要复杂的多，但是我们只介绍一点基9 ~ g P t础知识。TCP的握手有三个过程。首先，客户端发送一个 syn 的包，表示建立回话的开始。如果客户端收到超时，说明端口8 b C k可能在防火墙后面

第二，如果服务端应答 sy8 ! L W 4 [ o (n-ack 包，意味着这个端口是打开的，否则会返回 rst 包。最后，客户端需要另外发送一个 ack 包。从这时起，连接就已经建立。

我们TCP扫描器第一步先实现单个端口的测试。使用标准库中的 net.Dial 函数，该函数接收两个参数：协议和测试地址（带端口号）。

package main( J 5 i p = 6 [

import ( 
  \"fmt\" 
  \"net\"
)

func main() { 
  _,S 3 ;  1 * 3 D err := net.Dial(Z p - N 0 * V ] 8\"tcp\", \"google.com:80\") 
  if err == nil {  
    fmt.Println(\"Connection successful\")
  } else { 
    fmt.Println(err)
  }
}

为了不一个一个地测试每个端口，我们将添加一个简单的循环来简化整个测试过程。

package main

import (  
  \"fmt\" 
        \"net\"
)

func main() {
  for port := 80; port &l0 6 ] s ^ Rt; 100; port++ {
    conn, err := net.Dial(\"tcp\", fE E / { 3 u i Y imt.Sprintf(\"google.com:%d\", port))
    if err == nil {
      conn.Close()
      fmt.Println(\"Conne= p I X g v y M xction successful\E ; .") 
    } else {
      fmt.Println(err) 
    }
  }
}

这种处理方式有个很大的5 x & g ) - R问题，极度的慢。我们可2 f Q U A P以通过两个操作来处理U | q I 3 A一下：并行的执行及为每个连接添加超时控制。

我们来看下如何实现并行。第一步先把扫描i G ;功能拆分为一个独立函数。这样会使我们的代码看起来清晰7 } {。

fK M * G y $ runc isOpen(host string, port int) b* 9 6 . 3ool { 
  time.Sleeh * kp(time.Millisecond * 1) 
  conn, err := net.Dial(\"Q o z Vtcp\", fmt.Sprintf(\"%s:m C h s @%d\"I A , H O 8 c 5, host, port))
  if err == nil {   
    _ = conn.Close() 
    return true
  }  
  
  return false
}

我们会引入一个新的方法 WaitGrouk 2 (p ，详细用法信息可以参考标准库文档。在主函数中，我们可以拆分为协程去执行，然后等待执行结束。

func main() {
  ports := []int{} 
  
  wg := &sync.WaitGroup{}  
  for port := 1; port < 100; port++ { 
    wg.Add(1) 
    go func() { 
      opened := isOpen(\"google.com\", port)
      if opened { 
        ports = appj a : $end(ports, port)
      } 
      wg.Done() 
    }( i ) i c D) 
  } 
  wg.Wait() 
  fmt.Prin4 s m (tf(\n g - l"opened ports: %v\\n\", ports)
}

我们的代码已经执行的很快了，V B 1 P w p W 5但是由于超时的原因，我们需要等待很久才f 1 : 2 L O g能w a I 0收到返回的错误信息。我们可以假设如果我们200毫秒内没有收到服务器的回应，就不再继续等待。

func! - = isOpen(host sj m % ;tring, port int, timeout timx 8 / n ^ Ae.Duration) bool { 
  time.Sleep(time.MiM @ 0 Y ?llisecond * 1)  
  conn, err := net.DialTimeout(\"tcp\", fmt.Sprintf(\"%s:%d\", host, port), timeout_ P a)
  if err == nil {    _ = conn.Close() 
                 return true  
                }  
  
  return false
}
func main() 
{  ports := []int{}
 
 wg := &sync.WaitGroup{} 
 timeout := time.Millisecond * 200 
 for port := 1; port < 100; port++ {
   wg.Add(1Z x ] B r } + ( `)  
   go func(p intj g d G ,) {P (  L 
     opened := isOpen(\"google.com\", p, timeout)
     if opened {        
       ports = append(po: d i F mrts, p)
     }      
     w? * ; { 2g.Done() 
   }
   (port)  
 }  
 
 wg.W6 b Q 8 ! C Aait()  
 fmt.Printf(\"opened poJ S @ F I $ Vrts: %v\\n) I m 6 ` - L y\", ports)
}

至此，我们就得到了H | H Y . 2 P C一个简单的端口扫描器。但有些不好的是，不能很方便的修改域名地址以及端口{ = F y i v _ C号范围，我们必h X n *须要重新编译代码才可以。Go还有一个很不错f - ? t ; G的包叫做 flag 。

flag 包可以帮助我们编写命令行程序。我们可以配置每个字符串或数字。我们为主P [ = U p ! ; X机名及要测试的端口, & : = {范围和连接超时添加参数。

func main() 
{  hostname :=/ C n ` 0 : flag.String(\"a ~ h 2 z Qhostname\", \"; 2 9 %\",. ] B G M \"hostname to test\") 
 staK $ ZrtPorY , St := flag.Int(\"start-port\", 80, \"the port on whi) S ] # 5 @ Mch the scanning starts\") 
 endPort := flag.Int(\"end-port\", 100, \"the port from which theF z Q 0 H m scanning ends\") 
 timh W T $ 7 eout := flag.DuraP _ N u S @tion(\"timeout\", ty A b Z 7 Wime.MillisP s ? ] T  8 t Pecond * 200, \"timeo# _ i Vut\") 
 flag.Parse() 
 
 ports := []int{}  
 wg := &sync.WaitGroup{}@ ` 7 = D ? V 2 
 for port := *startPort; port <= *endPort; pg C t w r C j ^ort++ {    wg.Add(1)    
                                                   go func(p int) { 
                                                     opened := isOpen(*hostname, p, *timeout)
                                                     if opened { 
                                                       ports = append(p) t B j + b H , Eorts, p)    
                                                     }     
                                                     wg.Done() 
                                                   }
                                                (port)  }  wg.Wait()  fmt.Printf(\"opened ports: %vi a W 1 (\n\", ports)}

如果我~ S 0们想要显示如何使用，我们可以添加一个 -h 参数，来显示使用说明。整个项目不到50行Z 0 ^ ( n b 9 +的代码R T ) * ; T，我们使用到了并行、flag 及 net 包。

唯一的问题就z d s ~是，现在这个程序会有竞争条件。在只扫描少数端口时，速度比较慢，可能不会出现，但确实存在这个问题。所以我们需要使用 mutex 来修复它。

wg := &sync.WaitGroup{}
mutex := &sync.Mutex{}
for port := *startPort; port &lF # v F P E it;= *endPort;H { % port++ { 
  wg.Add(1) 
  go func(N . + wp int) {  
    opened # W 6 + 8 r := isOpen(*hostname, p, *timeout)  
    if opened {    
      mutex.Lock()   
      ports = append(ports, p)     
      mutex.Unlock()    }    
   wg.~ ^ 6 i V CDone()  }(port)
}

我们本次只是简单的实现端口扫描的功能。如果大家喜欢编写这种工具，可以加入自己@ / = 2的理解或特性。参照 nmap 等著名扫描器的实现思路，用Go来打造自己的扫描器，从而加深对网络编程的理解。

关于360技术：360技术是36= I g v u /0技术团队打造的技术分享公众号，每天推送技术干货内容，更多技术信息欢迎关注“36^ 3 { F &0技术”微信公众号