1. TCP扫描器

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

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

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

TCP扫描器 - 图1

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

TCP扫描器 - 图2 TCP扫描器 - 图3

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

  1. package main
  3. import (
  4.     "fmt"
  5.     "net"
  6. )
  8. func main() {
  9.     _, err := net.Dial("tcp", "google.com:80")
  10.     if err == nil {
  11.         fmt.Println("Connection successful")
  12.     } else {
  13.         fmt.Println(err)
  14.     }
  15. }

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

  1. package main
  3. import (
  4.     "fmt"
  5.     "net"
  6. )
  8. func main() {
  9.     for port := 80; port < 100; port++ {
  10.         conn, err := net.Dial("tcp", fmt.Sprintf("google.com:%d", port))
  11.         if err == nil {
  12.             conn.Close()
  13.             fmt.Println("Connection successful")
  14.         } else {
  15.             fmt.Println(err)
  16.         }
  17.     }
  18. }
  19. 这种处理方式有个很大的问题，极度的慢。我们可以通过两个操作来处理一下：并行的执行及为每个连接添加超时控制。
  21. 我们来看下如何实现并行。第一步先把扫描功能拆分为一个独立函数。这样会使我们的代码看起来清晰。
  23. func isOpen(host string, port int) bool {
  24.   time.Sleep(time.Millisecond * 1)
  25.   conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", host, port))
  26.   if err == nil {
  27.      _ = conn.Close()
  28.      return true
  29.   }
  31.   return false
  32. }

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

  1. func main() {
  2.   ports := []int{}
  4.   wg := &sync.WaitGroup{}
  5.   for port := 1; port < 100; port++ {
  6.      wg.Add(1)
  7.      go func() {
  8.         opened := isOpen("google.com", port)
  9.         if opened {
  10.            ports = append(ports, port)
  11.         }
  12.         wg.Done()
  13.      }()
  14.   }
  16.   wg.Wait()
  17.   fmt.Printf("opened ports: %v\n", ports)
  18. }

我们的代码已经执行的很快了，但是由于超时的原因，我们需要等待很久才能收到返回的错误信息。我们可以假设如果我们200毫秒内没有收到服务器的回应，就不再继续等待。

  1. func isOpen(host string, port int, timeout time.Duration) bool {
  2.     time.Sleep(time.Millisecond * 1)
  3.     conn, err := net.DialTimeout("tcp", fmt.Sprintf("%s:%d", host, port), timeout)
  4.     if err == nil {
  5.         _ = conn.Close()
  6.         return true
  7.     }
  9.     return false
  10. }
  12. func main() {
  13.     ports := []int{}
  15.     wg := &sync.WaitGroup{}
  16.     timeout := time.Millisecond * 200
  17.     for port := 1; port < 100; port++ {
  18.         wg.Add(1)
  19.         go func(p int) {
  20.             opened := isOpen("google.com", p, timeout)
  21.             if opened {
  22.                 ports = append(ports, p)
  23.             }
  24.             wg.Done()
  25.         }(port)
  26.     }
  28.     wg.Wait()
  29.     fmt.Printf("opened ports: %v\n", ports)
  30. }

至此，我们就得到了一个简单的端口扫描器。但有些不好的是，不能很方便的修改域名地址以及端口号范围，我们必须要重新编译代码才可以。Go还有一个很不错的包叫做 flag 。

flag 包可以帮助我们编写命令行程序。我们可以配置每个字符串或数字。我们为主机名及要测试的端口范围和连接超时添加参数。

  1. func main() {
  2.     hostname := flag.String("hostname", "", "hostname to test")
  3.     startPort := flag.Int("start-port", 80, "the port on which the scanning starts")
  4.     endPort := flag.Int("end-port", 100, "the port from which the scanning ends")
  5.     timeout := flag.Duration("timeout", time.Millisecond * 200, "timeout")
  6.     flag.Parse()
  8.     ports := []int{}
  10.     wg := &sync.WaitGroup{}
  11.     for port := *startPort; port <= *endPort; port++ {
  12.         wg.Add(1)
  13.         go func(p int) {
  14.             opened := isOpen(*hostname, p, *timeout)
  15.             if opened {
  16.                 ports = append(ports, p)
  17.             }
  18.             wg.Done()
  19.         }(port)
  20.     }
  22.     wg.Wait()
  23.     fmt.Printf("opened ports: %v\n", ports)
  24. }

如果我们想要显示如何使用，我们可以添加一个 -h 参数，来显示使用说明。整个项目不到50行的代码，我们使用到了并行、flag 及 net 包。

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

  1. wg := &sync.WaitGroup{}
  2. mutex := &sync.Mutex{}
  3. for port := *startPort; port <= *endPort; port++ {
  4.     wg.Add(1)
  5.     go func(p int) {
  6.         opened := isOpen(*hostname, p, *timeout)
  7.         if opened {
  8.             mutex.Lock()
  9.             ports = append(ports, p)
  10.             mutex.Unlock()
  11.         }
  12.         wg.Done()
  13.     }(port)
  14. }

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

本文转自：https://mp.weixin.qq.com/s/OhS_RQZojJbkenOSS_tEng