Go语言技术与应用（四）：网络编程之TCP端口扫描器实现

端口扫描器在网络安全和系统管理中扮演着重要角色。通过扫描目标主机的端口状态，我们可以了解系统运行的服务，发现潜在的安全漏洞。

本文将带你用Go语言实现三种不同的TCP端口扫描器：从最基础的串行版本，到高效的并发版本，再到资源可控的goroutine池版本。每种实现都有其适用场景，让我们一步步来看。

1. 基础串行扫描器

1.1 实现原理

最简单的端口扫描器就是逐个尝试连接目标端口。虽然速度慢，但逻辑清晰，适合理解端口扫描的基本原理。

package main

import (
    "fmt"
    "net"
    "time"
)

func main() {
    targetHost := "127.0.0.1"  // 目标主机地址
    startPort := 1             // 起始端口
    endPort := 1000           // 结束端口（这里只扫描前1000个端口作为示例）
    
    fmt.Printf("开始扫描主机 %s 的端口 %d-%d\n", targetHost, startPort, endPort)
    startTime := time.Now()
    
    for port := startPort; port <= endPort; port++ {
        address := fmt.Sprintf("%s:%d", targetHost, port)
        
        // 设置连接超时时间为1秒
        conn, err := net.DialTimeout("tcp", address, time.Second)
        if err == nil {
            fmt.Printf("端口 %d 开放\n", port)
            conn.Close()  // 记得关闭连接
        }
        
        // 每扫描100个端口显示一次进度
        if port%100 == 0 {
            fmt.Printf("已扫描到端口 %d\n", port)
        }
    }
    
    elapsed := time.Since(startTime)
    fmt.Printf("扫描完成，耗时: %v\n", elapsed)
}

这个版本的特点是简单直接。我们用net.DialTimeout而不是net.Dial，这样可以避免在某些端口上等待太久。

1.2 优缺点分析

优点：

• 代码简单，容易理解
• 资源占用少
• 不会对目标系统造成太大压力

缺点：

• 扫描速度慢，特别是端口范围大的时候
• 无法充分利用现代多核CPU的性能

2. 并发扫描器

2.1 goroutine并发实现

Go语言的goroutine让我们可以轻松实现并发扫描，大幅提升扫描速度。

package main

import (
    "fmt"
    "net"
    "sync"
    "time"
)

// 扫描单个端口的函数
func scanPort(host string, port int, wg *sync.WaitGroup, results chan<- int) {
    defer wg.Done()  // 确保在函数结束时通知WaitGroup
    
    address := fmt.Sprintf("%s:%d", host, port)
    conn, err := net.DialTimeout("tcp", address, time.Second)
    
    if err == nil {
        results <- port  // 将开放的端口发送到结果通道
        conn.Close()
    }
}

func main() {
    targetHost := "127.0.0.1"
    startPort := 1
    endPort := 1000
    
    fmt.Printf("并发扫描主机 %s 的端口 %d-%d\n", targetHost, startPort, endPort)
    startTime := time.Now()
    
    var wg sync.WaitGroup
    results := make(chan int, endPort-startPort+1)  // 创建缓冲通道
    
    // 启动所有扫描goroutine
    for port := startPort; port <= endPort; port++ {
        wg.Add(1)
        go scanPort(targetHost, port, &wg, results)
    }
    
    // 等待所有goroutine完成后关闭结果通道
    go func() {
        wg.Wait()
        close(results)
    }()
    
    // 收集并显示结果
    var openPorts []int
    for port := range results {
        openPorts = append(openPorts, port)
    }
    
    elapsed := time.Since(startTime)
    
    fmt.Printf("发现 %d 个开放端口:\n", len(openPorts))
    for _, port := range openPorts {
        fmt.Printf("端口 %d 开放\n", port)
    }
    fmt.Printf("扫描完成，耗时: %v\n", elapsed)
}

2.2 性能对比

并发版本的扫描速度通常比串行版本快几十倍。但是要注意，如果同时启动太多goroutine，可能会遇到以下问题：

• 系统文件描述符耗尽
• 网络连接数超限
• 目标主机可能将大量并发连接视为攻击

3. goroutine池扫描器

3.1 资源控制的重要性

当需要扫描大量端口时，无限制的并发可能导致系统资源耗尽。goroutine池可以很好地解决这个问题。

package main

import (
    "fmt"
    "net"
    "sync"
    "time"
)

// 工作者函数，从端口通道中获取任务
func worker(id int, host string, ports <-chan int, results chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    
    for port := range ports {
        address := fmt.Sprintf("%s:%d", host, port)
        conn, err := net.DialTimeout("tcp", address, time.Second)
        
        if err == nil {
            results <- port
            conn.Close()
        }
        
        // 可选：添加小延时避免过于频繁的连接
        time.Sleep(10 * time.Millisecond)
    }
}

func main() {
    targetHost := "127.0.0.1"
    startPort := 1
    endPort := 65535  // 扫描所有端口
    numWorkers := 100  // 工作者数量，可以根据系统性能调整
    
    fmt.Printf("使用 %d 个工作者扫描主机 %s 的端口 %d-%d\n", 
               numWorkers, targetHost, startPort, endPort)
    startTime := time.Now()
    
    // 创建通道
    ports := make(chan int, 1000)      // 端口任务通道
    results := make(chan int, 1000)    // 结果通道
    
    var wg sync.WaitGroup
    
    // 启动工作者goroutine
    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go worker(i, targetHost, ports, results, &wg)
    }
    
    // 发送端口任务
    go func() {
        for port := startPort; port <= endPort; port++ {
            ports <- port
        }
        close(ports)  // 关闭端口通道，通知工作者没有更多任务
    }()
    
    // 等待所有工作者完成后关闭结果通道
    go func() {
        wg.Wait()
        close(results)
    }()
    
    // 收集结果
    var openPorts []int
    for port := range results {
        openPorts = append(openPorts, port)
    }
    
    elapsed := time.Since(startTime)
    
    fmt.Printf("扫描完成！发现 %d 个开放端口:\n", len(openPorts))
    for _, port := range openPorts {
        fmt.Printf("端口 %d 开放\n", port)
    }
    fmt.Printf("总耗时: %v\n", elapsed)
}

3.2 参数调优建议

工作者数量选择：

• 本地扫描：50-200个工作者
• 远程扫描：20-100个工作者
• 生产环境：建议从小数量开始测试

超时时间设置：

• 本地网络：500ms-1s
• 互联网扫描：2-5s
• 慢速网络：5-10s

4. 实际应用考虑

4.1 扫描策略

在实际使用中，我们通常不会扫描所有65535个端口，而是重点关注常用端口：

// 常用端口列表
var commonPorts = []int{
    21, 22, 23, 25, 53, 80, 110, 111, 135, 139, 143, 443, 993, 995, 1723, 3306, 3389, 5432, 5900, 8080,
}

func scanCommonPorts(host string) {
    fmt.Printf("扫描主机 %s 的常用端口\n", host)
    
    for _, port := range commonPorts {
        address := fmt.Sprintf("%s:%d", host, port)
        conn, err := net.DialTimeout("tcp", address, 2*time.Second)
        
        if err == nil {
            fmt.Printf("端口 %d 开放\n", port)
            conn.Close()
        }
    }
}

4.2 错误处理和日志

生产环境中的端口扫描器需要更完善的错误处理：

func scanPortWithLogging(host string, port int) (bool, error) {
    address := fmt.Sprintf("%s:%d", host, port)
    
    conn, err := net.DialTimeout("tcp", address, time.Second)
    if err != nil {
        // 区分不同类型的错误
        if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
            return false, fmt.Errorf("端口 %d 连接超时", port)
        }
        return false, nil  // 端口关闭，这是正常情况
    }
    
    conn.Close()
    return true, nil  // 端口开放
}

5. 性能对比与总结

5.1 三种方案的性能对比

5.2 选择建议

• 学习阶段：从串行版本开始，理解基本原理
• 快速扫描：使用并发版本，适合扫描少量端口
• 生产环境：选择goroutine池版本，平衡性能和资源消耗

5.3 安全提醒

端口扫描是一把双刃剑。在使用时请注意：

1. 合法性：只扫描自己拥有或获得授权的系统
2. 频率控制：避免过于频繁的扫描被误认为攻击
3. 目标保护：不要对生产系统进行大规模扫描

通过这三种不同的实现方式，我们可以看到Go语言在网络编程方面的强大能力。从简单的串行处理到复杂的并发控制，Go都提供了简洁而强大的解决方案。选择哪种方式取决于你的具体需求和运行环境。