Go黑帽子（第二章）

原创

已于 2024-01-26 18:20:46 修改 · 1.3k 阅读

11 ·

CC 4.0 BY-SA版权

文章标签：

#golang #开发语言 #后端

于 2024-01-26 18:20:34 首次发布

2.0 第二章 TCP、扫描器和代理

文章目录

- - 2.0 第二章 TCP、扫描器和代理

2.1 TCP握手机制

这部分内容就不详细说了，百度讲的会更详细，如果看不懂请移步到哔哩哔哩大学。

2.2 通过端口转发绕过防火墙

说白了就是防火墙不允许访问的网站，通过访问允许访问的网站将流量进行代理到目标网站上。

2.3 编写一个TCP扫描器

2.3.1 测试端口可用性

单个端口扫描器

package main

import (
	"fmt"
	"net"
)

func main() {
   
   
	_, err := net.Dial("tcp", "scanme.nmap.org:80")
	if err == nil {
   
   
		fmt.Println("Connection successful")
	}
}

2.3.2 执行非并发扫描

说白了就是循环检测，看看能不能脸上，我觉得这个效率极低。

package main

import (
	"fmt"
	"net"
)

func main() {
   
   
	for i := 1; i <= 1024; i++ {
   
   
		address := fmt.Sprintf("scanme.nmap.org:%d", i)
		conn, err := net.Dial("tcp", address)
		if err == nil {
   
   
			fmt.Println("Connection successful")
		} else {
   
   
			//端口已关闭或已过滤
			continue
		}
		conn.Close()
		fmt.Printf("%d opne\n", i)
	}
}

2.3.3 执行并发扫描

这个时候用到go语言的独有的goroutine

package main

import (
	"fmt"
	"net"
)

func main() {
   
   
	for i := 1; i <= 1024; i++ {
   
   
		go func(j int) {
   
   
			address := fmt.Sprintf("scanme.nmap.org:%d", j)
			conn, err := net.Dial("tcp", address)
			if err != nil {
   
   
				return
			}
			conn.Close()
			fmt.Printf("%d open\n", j)
		}(i)
	}
}
//这里给大家对这个程序进行解释
在这个代码片段中，i 被传递给了匿名函数作为参数 j。这是为了避免在并发的情况下出现竞态条件。
在Go语言中，使用 go 关键字启动一个 goroutine 时，它会在一个新的 goroutine 中执行指定的函数。由于 goroutines 是并发执行的，它们可能会在同一时间访问和修改相同的变量。在这个例子中，i 是在 for 循环中定义的，如果直接在匿名函数中使用 i，会导致竞态条件，因为 i 的值在 goroutines 中可能会被不同的 goroutines 修改。
通过将 i 作为参数传递给匿名函数，确保每个 goroutine 都使用了 for 循环中当前迭代的 i 值的副本，而不是共享相同的 i 变量。这有助于避免竞态条件和确保正确的结果。
所以，i 在后面是为了确保在 go 关键字创建的 goroutine 中使用当前迭代的 i 的正确副本。
             

竞态条件（Race Condition）是指在多线程或多进程的程序中，由于执行顺序不确定性导致的程序行为异常的情况。竞态条件发生在多个线程或进程同时访问共享资源，并且其中至少一个是写操作时。
竞态条件的发生通常需要满足以下几个条件：
并发访问： 两个或多个线程（或进程）同时访问相同的共享资源。
至少一个写操作： 其中至少有一个线程执行写操作，修改共享资源的状态。
无同步机制： 缺乏适当的同步机制，导致多个线程之间的执行顺序不确定。

以上代码在for循环结束后就会直接退出程序，说明这样做是有问题的，因为for循环完成的时间可能会小于完成连接所需要的时间，因此我们需要使用sync包中的waitgroup，这是一种控制并发的线程的安全的方法。

修改后的代码如下：

package main

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

func main() {
   
   
	var wg sync.WaitGroup
	for i := 1; i <= 1024; i++ {
   
   
		wg.Add(1)//递增计数器
		go func(j int) {
   
   
			defer wg.Done()
			address := fmt.Sprintf("scanme.nmap.org:%d", j)
			conn, err := net.Dial("tcp", address)
			if err != nil {
   
   
				return
			}
			conn.Close()
			fmt.Printf("%d open\n", j)
		}(i)
	}
	wg.Wait()
}

defer 是 Go 语言中的一个关键字，用于延迟（defer）函数或方法的执行，通常用于确保在函数执行结束时（无论是正常返回还是发生异常）执行一些清理操作。（个人理解就是，只有当函数执行结束之前执行的语句，也就是最后一个执行的语句）

这里可以简单了解一下defer和WaitGroup的用法，这里就不做详细解释。

以上代码还存在蛮多的问题比如：并发量太大，可能导致网络或系统限制、网络超时之后的操作等并没有给出。

因此代码可以进行进一步的优化：

使用goroutine池管理真正进行的并发工作

package main

import (
	"fmt"
	"sync"
)

func worker(ports chan int, wg *sync.WaitGroup) {
   
   
	for p := range ports {
   
   
		fmt.Println(p)
		wg.Done()
	}
}

func main() {
   
   
	ports := make(chan int, 100)
	var wg sync.WaitGroup
    //cap测量通道的容量大小
	for i := 0; i < cap(ports); i++ {
   
   
		go worker(ports, &wg)
	}
	for i := 1; i <= 1024; i++ {
   
   
		wg.Add(1)
		ports <- i
	}
	wg.</