Go 语言开发简单代理工具,适合安全工程师入门

golang实现正向代理和反向代理 正向代理和反向代理都是进行请求和转发的代理方式,但为了区分,后者被称为反向代理。生活中最常见的例子是正向代理类似于卖票的黄牛,而反向代理类似于出租房的二手东。 阅读详情

Go 语言开发简单代理工具,适合安全工程师入门

免责声明:本文所讲解的代理工具开发、网络编程知识,仅用于内网安全演练、企业授权安全测试、个人编程学习。禁止使用本文代码在未获得授权的网络环境中进行流量转发、端口转发、代理访问等操作。未经授权的流量代理、内网穿透、流量劫持行为,会触犯网络安全相关法律法规,由此产生的一切法律责任由使用者自行承担。本文所有代码仅做学习演示,不建议直接用于生产环境。

前言

作为安全工程师,日常工作中经常会和代理、端口转发打交道。内网渗透、横向移动、流量中转、绕过防火墙、隧道搭建,几乎都离不开代理工具。很多同学平时都是直接使用现成工具:socat、nc、frp、reGeorg、chisel 等工具,拿来即用。但很多人只知道怎么用,不知道底层原理。一旦遇到特殊场景,现有工具不满足需求,就束手无策。

Go 语言(Golang)非常适合安全工具开发。它编译简单,单文件静态编译,编译之后直接生成可执行程序,不需要依赖运行环境,丢到 Linux、Windows 服务器直接运行,交叉编译也很方便。这也是大量红队工具选择 Go 开发的核心原因。

本文面向安全工程师入门,从零开始,使用 Go 语言一步步实现TCP 端口转发、正向代理、简单 HTTP 代理,讲解底层网络编程知识,剖析代理的原理。从基础的 Socket 编程入手,循序渐进,先写最简单端口转发,再实现正向 TCP 代理,最后实现简易 HTTP 代理,附带代码逐行讲解、编译方法、靶场测试、踩坑点、工具扩展思路。

文章不会堆砌复杂语法,不会深入 Go 协程底层复杂原理,重点聚焦网络编程 + 代理原理。适合有基础 Go 语法基础,或者安全从业者想入门 Go 安全工具开发的读者。读完本文,你能理解代理底层原理,独立写出简单 TCP 转发工具,并且可以基于本文代码继续扩展成自己的简易隧道工具。

全文所有代码都可以直接复制到本地测试,配套讲解每一段代码的作用、安全场景用途、存在的缺陷,以及后续优化方向。

一、前置知识准备

1.1 为什么安全工程师推荐学习 Go 开发工具?

  1. 静态编译,无依赖:Go 编译后生成单个二进制文件,不需要安装 lib、python 环境。渗透拿到服务器,直接上传二进制就能运行,这是安全场景巨大优势。
  2. 原生协程 Goroutine:轻量级协程,处理并发连接非常方便。写代理工具,每一条客户端连接起一个协程,代码简单,并发性能不错。对比 C 语言需要手动处理多线程,Python 多线程 GIL 锁限制并发,Go 写网络工具非常顺手。
  3. 标准库强大:net包内置 TCP、UDP、HTTP 网络相关库,不需要额外安装第三方库,写网络工具只依赖标准库,编译出来的程序体积可控。
  4. 跨平台交叉编译:一行命令,在 Windows 上编译 Linux 可执行文件,Linux 编译 Windows 程序,适配靶场多操作系统环境。
  5. 语法简洁:相比 C/C++,语法简单,上手门槛低,不用花大量时间处理内存管理。

劣势:Go 生成的二进制文件体积偏大;不适合底层内核级工具开发。但对于应用层代理、端口转发、爬虫、简单扫描器这类安全工具,Go 是首选。

1.2 代理基础概念区分(安全面试高频)

很多新手容易混淆端口转发、正向代理、反向代理,这里一次性区分清楚。

  1. 端口转发(TCP 转发):监听本地端口,收到流量之后,原样转发到目标 IP: 端口。属于底层 TCP 流量转发,不解析上层协议。典型场景:内网机器 A 无法直连机器 B,在中间跳板机做端口转发,访问跳板机端口,流量转发到 B。
  2. 正向代理:客户端明确指定代理服务器,代理代替客户端去访问目标地址。比如 HTTP 代理,浏览器配置代理服务器,由代理去访问外网网站。客户端知道代理存在。
  3. 反向代理:用户访问代理,代理把流量分发到后端多台服务器。用户不知道后端真实服务器,Nginx 反向代理属于这类。红队渗透很少用到反向代理。

本文实现顺序:

  1. 基础 TCP Socket 编程(Go net 包基础)
  2. TCP 端口转发工具(最简单,无协议解析)
  3. TCP 正向代理(支持多并发连接)
  4. 简易 HTTP 正向代理(解析 HTTP 请求头)

注意:SOCKS5 代理相对复杂,本文作为入门文章不实现 SOCKS5,理解 HTTP 代理和 TCP 转发之后,可以自行扩展 SOCKS5。

1.3 Go 开发环境搭建

1.3.1 Go 安装

官网下载:https://go.dev/dl/
Windows / Linux 都可以安装。安装完成验证版本:

go version

推荐版本:Go1.18 及以上,新版本对 net 库兼容性更好。

1.3.2 基础编译命令

直接编译当前目录代码,生成二进制:

go build main.go
  • Windows:编译后得到 main.exe
  • Linux:编译得到 main,chmod +x main 即可执行

交叉编译(重点,安全工具必备)
在 Linux 环境编译 Windows 程序:

CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -o proxy.exe main.go

在 Windows 环境编译 Linux amd64 程序:

SET CGO_ENABLED=0
SET GOOS=linux
SET GOARCH=amd64
go build -o proxy main.go

CGO_ENABLED=0:关闭 CGO,实现纯静态编译,编译出来的二进制不依赖系统库,上传到服务器直接运行。安全工具编译必加参数。

1.4 Go net 包核心知识点

net包是本次开发的核心,两个核心函数:

  1. net.Listen("tcp", "0.0.0.0:8888"):监听 TCP 端口,开启服务,等待客户端连接。
  2. net.Dial("tcp", "127.0.0.1:8080"):主动发起 TCP 连接,连接远端目标地址。

TCP 连接本质是双向字节流。代理的核心逻辑:

客户端 <-> 代理本地监听 Socket <-> 代理主动 Dial 目标服务端
把客户端发来的数据原样转发给目标;目标返回的数据原样转发回客户端。

数据转发,需要双向拷贝,使用io.Copy。io.Copy(dst, src),把 src 的数据流拷贝写入 dst,阻塞直到连接关闭。

io.Copy 是阻塞 IO,所以每一条转发链路,必须放到独立 Goroutine 协程中运行,否则一次连接就会阻塞整个程序,无法处理新客户端。

二、入门第一步:Go 基础 TCP 通信演示

在写代理之前,先写最简单 TCP 服务端和客户端,理解 Socket 通信。这是代理开发的基础。

2.1 TCP 服务端代码

package main

import (
	"fmt"
	"net"
)

func handleConn(conn net.Conn) {
	defer conn.Close()
	fmt.Printf("收到客户端连接:%s\n", conn.RemoteAddr().String())

	buf := make([]byte, 1024)
	for {
		n, err := conn.Read(buf)
		if err != nil {
			fmt.Println("客户端断开连接:", err)
			return
		}
		fmt.Printf("收到客户端数据:%s\n", string(buf[:n]))
		// 回写数据给客户端
		_, err = conn.Write([]byte("server receive your message\n"))
		if err != nil {
			return
		}
	}
}

func main() {
	listener, err := net.Listen("tcp", "0.0.0.0:9999")
	if err != nil {
		fmt.Println("监听失败:", err)
		return
	}
	defer listener.Close()
	fmt.Println("TCP服务端监听 0.0.0.0:9999")

	for {
		conn, err := listener.Accept()
		if err != nil {
			fmt.Println("接受连接失败", err)
			continue
		}
		// 开启协程处理连接,支持多客户端并发
		go handleConn(conn)
	}
}
代码逐行讲解
  1. net.Listen 在本机 9999 端口监听 TCP,0.0.0.0 代表监听本机所有网卡。
  2. 无限循环listener.Accept(),阻塞等待新客户端 TCP 连接。
  3. 一旦收到连接,立刻开启 goroutine go handleConn(conn),单独协程处理这个客户端,主循环继续等待下一个连接,实现并发。
  4. conn.Read读取客户端发来的字节流;conn.Write向客户端发送数据。
  5. defer conn.Close()函数退出时自动关闭连接,避免 socket 句柄泄露。

测试方式:运行程序,使用 nc 客户端连接 nc 127.0.0.1 9999,发送字符串,观察服务端输出。

2.2 TCP 客户端代码

package main

import (
	"fmt"
	"net"
)

func main() {
	conn, err := net.Dial("tcp", "127.0.0.1:9999")
	if err != nil {
		fmt.Println("连接失败:", err)
		return
	}
	defer conn.Close()

	_, err = conn.Write([]byte("hello from go client"))
	if err != nil {
		fmt.Println("发送失败", err)
		return
	}

	buf := make([]byte, 1024)
	n, err := conn.Read(buf)
	if err != nil {
		fmt.Println("读取失败", err)
		return
	}
	fmt.Println("收到服务端返回:", string(buf[:n]))
}

客户端使用net.Dial主动发起 TCP 连接,发送数据,读取返回。

理解这两段代码,就掌握了 TCP 通信基础。代理本质就是同时充当服务端(接收客户端)和客户端(连接目标服务)。

三、实战开发 1:TCP 端口转发工具(最简单代理)

端口转发是安全工程师最常用工具。场景举例:
跳板机 IP:192.168.1.100,内网有一台数据库 192.168.1.200:3306。我们本地无法直接访问 192.168.1.200:3306,但是可以访问跳板机。在跳板机上运行端口转发程序,监听跳板机 8888 端口,所有访问跳板机 8888 的流量转发到 192.168.1.200:3306。本地访问跳板机:8888,等价访问内网数据库 3306。

3.1 完整 TCP 端口转发代码

package main

import (
	"flag"
	"fmt"
	"io"
	"net"
)

// 转发单向流量:src -> dst
func transfer(src, dst net.Conn) {
	defer src.Close()
	defer dst.Close()
	_, err := io.Copy(dst, src)
	if err != nil {
		fmt.Printf("流量转发中断 %v\n", err)
	}
}

// 处理每一条客户端连接
func handleClient(clientConn net.Conn, targetAddr string) {
	fmt.Printf("新客户端连接 %s,目标转发地址:%s\n", clientConn.RemoteAddr(), targetAddr)
	// 代理作为客户端,主动连接目标服务
	targetConn, err := net.Dial("tcp", targetAddr)
	if err != nil {
		fmt.Printf("连接目标地址失败:%v\n", err)
		clientConn.Close()
		return
	}

	// 双向转发,两个协程分别处理两个方向流量
	go transfer(clientConn, targetConn)
	transfer(targetConn, clientConn)
}

func main() {
	// 命令行参数
	listenAddr := flag.String("l", "0.0.0.0:8888", "本地监听地址,例:0.0.0.0:8888")
	targetAddr := flag.String("t", "127.0.0.1:80", "转发目标地址,例:192.168.1.10:8080")
	flag.Parse()

	listener, err := net.Listen("tcp", *listenAddr)
	if err != nil {
		fmt.Printf("监听端口失败:%v\n", err)
		return
	}
	defer listener.Close()
	fmt.Printf("TCP端口转发启动,监听 %s,转发目标 %s\n", *listenAddr, *targetAddr)

	for {
		clientConn, err := listener.Accept()
		if err != nil {
			fmt.Printf("接收连接失败:%v\n", err)
			continue
		}
		go handleClient(clientConn, *targetAddr)
	}
}

3.2 逐行解析核心逻辑

  1. transfer函数:io.Copy(dst, src),把 src 的数据流全部拷贝写入 dst。TCP 是双向流,客户端发往目标、目标返回客户端,两个方向,需要两个 transfer。
  2. handleClient:收到客户端连接后,代理使用net.Dial建立到目标服务的 TCP 连接。
  3. 开启协程 go transfer(clientConn, targetConn):客户端流量转发给目标。主线程执行transfer(targetConn, clientConn),目标返回流量转发回客户端。

关键点:io.Copy 是阻塞调用,一旦连接断开,io.Copy 返回,defer 自动关闭两个连接。

  1. 使用 flag 包,支持命令行参数,不用修改代码,启动时指定监听地址和目标地址。

3.3 编译与测试

编译:

go build -o tcpforward main.go

启动,监听 0.0.0.0:8888,流量转发到 127.0.0.1:80:

./tcpforward -l 0.0.0.0:8888 -t 127.0.0.1:80

测试:浏览器访问 http://127.0.0.1:8888,等价访问本机 80 端口 web 服务。

3.4 安全场景使用场景

  1. 内网跳板端口转发,访问内网无法直连端口;
  2. 流量中转,简单流量中继;
  3. 渗透测试中,绕过网络 ACL,把内网端口暴露到跳板机。

3.5 当前版本缺陷(重点,安全工具开发要清楚局限性)

  1. 无日志,无流量打印,无法查看转发了什么流量;
  2. 没有超时控制,长时间空闲连接不会自动断开,容易积累大量 socket 句柄;
  3. 没有连接数限制,大量并发连接会耗尽服务器资源;
  4. 纯 TCP 转发,不解析上层协议,只能转发 TCP 流量,不能做 HTTP 代理;
  5. 没有身份认证,任何人访问监听端口都能使用转发,存在安全风险;
  6. 没有加密,流量明文传输,抓包直接看到全部数据。

这就是入门工具的特点,功能简单,适合学习,生产 / 实战需要继续增加功能。

四、实战开发 2:增加日志、超时、连接数限制,优化 TCP 转发

上一版基础版本缺陷较多,我们迭代第二版,增加:流量打印日志、读写超时、最大并发连接限制,增强工具健壮性。

package main

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

var (
	connCount int
	maxConn   int
	mu        sync.Mutex
)

func transfer(src, dst net.Conn, direction string) {
	defer src.Close()
	defer dst.Close()
	buf := make([]byte, 4096)
	for {
		src.SetReadDeadline(time.Now().Add(30 * time.Second))
		n, err := src.Read(buf)
		if err != nil {
			fmt.Printf("[%s] 流量读取结束: %v\n", direction, err)
			return
		}
		fmt.Printf("[%s] 流量长度:%d bytes\n", direction, n)
		_, err = dst.Write(buf[:n])
		if err != nil {
			fmt.Printf("[%s] 写入失败:%v\n", direction, err)
			return
		}
	}
}

func handleClient(clientConn net.Conn, targetAddr string) {
	mu.Lock()
	connCount++
	current := connCount
	mu.Unlock()
	fmt.Printf("新连接,当前连接数:%d\n", current)

	defer func() {
		mu.Lock()
		connCount--
		mu.Unlock()
		fmt.Printf("连接关闭,当前连接数:%d\n", connCount)
	}()

	targetConn, err := net.DialTimeout("tcp", targetAddr, 5*time.Second)
	if err != nil {
		fmt.Printf("连接目标失败 %v\n", err)
		clientConn.Close()
		return
	}

	go transfer(clientConn, targetConn, "CLIENT->TARGET")
	transfer(targetConn, clientConn, "TARGET->CLIENT")
}

func main() {
	listenAddr := flag.String("l", "0.0.0.0:8888", "本地监听地址")
	targetAddr := flag.String("t", "127.0.0.1:80", "转发目标地址")
	max := flag.Int("m", 10, "最大并发连接数")
	flag.Parse()
	maxConn = *max

	listener, err := net.Listen("tcp", *listenAddr)
	if err != nil {
		fmt.Println("监听失败:", err)
		return
	}
	defer listener.Close()
	fmt.Printf("TCP转发启动,监听:%s,目标:%s,最大连接数:%d\n", *listenAddr, *targetAddr, maxConn)

	for {
		mu.Lock()
		if connCount >= maxConn {
			mu.Unlock()
			fmt.Println("达到最大连接限制,拒绝新连接")
			// 短暂等待,避免死循环
			time.Sleep(100 * time.Millisecond)
			continue
		}
		mu.Unlock()
		clientConn, err := listener.Accept()
		if err != nil {
			fmt.Println("Accept错误", err)
			continue
		}
		go handleClient(clientConn, *targetAddr)
	}
}

4.1 新增功能讲解

  1. 连接计数 + 最大并发限制:使用sync.Mutex互斥锁保护全局连接计数器,防止并发修改变量引发竞态问题。超过最大连接数直接拒绝新连接,防止服务器资源耗尽。
  2. 读写超时 SetReadDeadline:30 秒无数据,自动断开连接,释放 socket 资源,防止僵死连接。
  3. DialTimeout:连接目标地址 5 秒超时,不会无限阻塞。
  4. 自定义 buffer 读取流量,打印流量字节长度,简单日志输出。

注意:这里只是打印流量大小,没有打印原始流量内容。如果需要打印原始流量,可以打印 string (buf [:n]),但二进制流量会乱码,实际工具一般只打印长度,或者保存到日志文件。

五、实战开发 3:简易 HTTP 正向代理(解析 HTTP 请求)

TCP 转发不需要解析协议,直接转发字节流。而 HTTP 正向代理不一样:客户端发送 HTTP 请求,请求头里面包含完整目标地址。代理程序需要解析 HTTP 请求,提取目标 Host 和端口,代理主动访问目标网站,拿到响应,返回给客户端。

浏览器配置 HTTP 代理,访问网页,走的就是这个逻辑。

5.1 HTTP 代理原理

客户端发送 HTTP 请求行类似:

GET http://www.baidu.com/ HTTP/1.1
Host: www.baidu.com
...

普通直接访问网站,请求行是GET /index.html HTTP/1.1;
HTTP 代理模式下,请求行写完整 URL。代理读取请求,解析 URL,提取域名、端口,代理去访问这个网站,拿到响应,原样返回浏览器。

注意:本文实现的是普通 HTTP 代理,不支持 HTTPS CONNECT 隧道,HTTPS 网站无法访问,这是入门版本的限制。CONNECT 方法实现 HTTPS 代理会复杂很多,作为入门我们只处理 HTTP。

5.2 简易 HTTP 正向代理完整代码

package main

import (
	"bufio"
	"flag"
	"fmt"
	"io"
	"net"
	"net/http"
)

func handleHttpProxy(conn net.Conn) {
	defer conn.Close()
	reader := bufio.NewReader(conn)
	// 读取HTTP请求
	req, err := http.ReadRequest(reader)
	if err != nil {
		fmt.Printf("读取HTTP请求失败: %v\n", err)
		return
	}
	fmt.Printf("收到代理请求,目标地址:%s\n", req.URL.String())

	// 代理发起请求访问目标网站
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		fmt.Printf("访问目标网站失败: %v\n", err)
		return
	}
	defer resp.Body.Close()

	// 把目标网站响应写回客户端
	err = resp.Write(conn)
	if err != nil {
		fmt.Printf("写回客户端失败 %v\n", err)
		return
	}
}

func main() {
	listenAddr := flag.String("l", "0.0.0.0:8080", "HTTP代理监听地址")
	flag.Parse()

	listener, err := net.Listen("tcp", *listenAddr)
	if err != nil {
		fmt.Printf("监听失败:%v\n", err)
		return
	}
	defer listener.Close()
	fmt.Printf("简易HTTP正向代理启动,监听 %s\n", *listenAddr)

	for {
		clientConn, err := listener.Accept()
		if err != nil {
			fmt.Println("接受连接失败", err)
			continue
		}
		go handleHttpProxy(clientConn)
	}
}

5.3 代码讲解

  1. http.ReadRequest直接解析客户端发来的 HTTP 请求,Go 标准库 http 包内置 HTTP 解析,不用手动解析字符串,极大简化开发。
  2. http.DefaultClient.Do(req):代理客户端发起 HTTP 请求,访问目标网站。
  3. resp.Write(conn):将目标服务器返回的 HTTP 响应,直接写入客户端连接,返回浏览器。

5.4 测试方法

  1. 编译运行
go build -o httpproxy main.go
./httpproxy -l 0.0.0.0:8080
  1. 浏览器设置 HTTP 代理,代理地址为本机 127.0.0.1:8080,访问 http 网站。

限制:仅支持 HTTP,HTTPS 网站无法访问,因为没有实现 CONNECT 隧道。

5.5 扩展思路:实现 CONNECT,支持 HTTPS 代理

HTTPS 代理客户端会发送 CONNECT 请求,建立 TCP 隧道。

CONNECT www.baidu.com:443 HTTP/1.1

代理解析 CONNECT 请求,和目标 443 端口建立 TCP 连接,然后双向转发流量,后续 TLS 握手在客户端和目标网站之间直接完成,代理只转发字节流,不解析 TLS 内容。
这就是 HTTP 代理支持 HTTPS 的原理。读者可以基于 TCP 转发代码,结合 HTTP 请求解析自行实现 CONNECT。

六、安全工具开发踩坑大全(安全工程师重点看)

6.1 协程泄漏问题

Go 协程如果没有退出条件,会无限堆积。比如 io.Copy 阻塞,连接僵死,协程不会释放。
解决方法:设置读写超时SetReadDeadline、SetWriteDeadline,超时自动断开连接,协程退出。

6.2 竞态条件(并发修改全局变量)

多个 goroutine 同时修改全局变量(连接计数),会出现数据错乱。必须使用sync.Mutex互斥锁保护共享变量。

6.3 连接忘记 Close,句柄耗尽

网络连接不关闭,会占用系统文件描述符。大量连接之后,程序无法新建 socket。
最佳实践:每个 net.Conn 都加上defer conn.Close()。

6.4 缓冲区大小选择

4096、8192 是常用 buffer 大小。buffer 太小转发效率低;太大占用内存。安全工具一般 4096 字节足够。

6.5 编译忘记 CGO_ENABLED=0

不关闭 CGO,编译出来的 Linux 二进制,依赖系统 glibc。放到老版本服务器,会报找不到库,无法运行。安全工具静态编译必须加 CGO_ENABLED=0。

6.6 防火墙与端口监听

监听 0.0.0.0 代表监听所有网卡;127.0.0.1 只能本机访问。内网靶场测试,要确认服务器防火墙放行监听端口。

6.7 代理工具的流量明文风险

本文写的 TCP 转发、HTTP 代理全部明文传输。中间人抓包可以直接看到全部流量。如果需要加密隧道,需要在流量之上增加 TLS 加密。

七、工具扩展方向(安全工程师进阶开发思路)

基于本文代码,你可以继续扩展功能,把简单代理升级为渗透可用的隧道工具:

  1. 增加账号密码认证:TCP 代理握手阶段,客户端先发认证包,认证失败直接断开,防止未授权访问。
  2. 增加 TLS 加密:客户端和代理之间流量 TLS 加密,规避 IDS 明文流量检测。
  3. 实现 CONNECT 方法,支持 HTTPS 代理,完善 HTTP 代理。
  4. 实现 SOCKS5 代理,红队最常用代理协议。
  5. 增加流量日志保存,把转发流量保存到 pcap 或者日志文件。
  6. 增加流量混淆、自定义数据包编码,绕过 WAF、IDS 特征检测。
  7. 增加断线重连,反向代理(反向隧道),类似 frp。
  8. 增加 UDP 转发,本文只实现 TCP,DNS 转发等场景需要 UDP。
  9. 增加限速功能,防止流量打满带宽。
  10. 增加命令行彩色输出,格式化日志。

开发思路:先实现最小可用版本,逐步迭代增加功能,不要一次性写大量复杂代码。这是安全工具开发推荐的开发方式。

八、安全开发规范:安全工程师写工具的注意事项

很多安全同学写工具,只追求功能,忽略代码安全,这里列出规范:

  1. 输入校验:所有命令行参数、网络读取的数据,做好校验,防止异常输入导致程序 panic 崩溃。比如目标地址不可为空,端口范围合法。
  2. 日志脱敏:日志中不要打印明文密码、密钥等敏感信息。
  3. 资源限制:最大连接数、内存限制,防止工具被攻击触发 DoS。
  4. 不要硬编码 IP、密码,代码中禁止写死密钥,通过命令行参数传入。
  5. 错误处理:不能忽略 err,很多新手写代码直接_, _ := net.Dial(...)丢弃错误,出问题无法排查。
  6. 最小权限运行:工具运行尽量不用 root,除非端口 < 1024 需要 root 监听。

重要:自己开发的工具,在客户环境、企业网络使用,必须提前获得书面授权。

九、面试 & 红队安全开发高频问题汇总

  1. TCP 端口转发的原理是什么?
    答:代理监听本地端口,收到客户端 TCP 连接后,代理主动建立到目标服务的 TCP 连接。开启双向 IO 拷贝,客户端流量转发给目标,目标返回流量转发回客户端。TCP 是字节流,不关心上层应用协议。
  2. Go 为什么适合安全工具开发?
    答:静态编译,单二进制无依赖;原生 Goroutine 轻量级协程,并发网络处理简单;标准库 net/http 完善,跨平台交叉编译方便。
  3. Goroutine 并发开发,全局计数器为什么需要 sync.Mutex?
    答:多个协程同时读写同一个全局变量,会出现竞态条件,数据错乱。Mutex 互斥锁保证同一时间只有一个协程修改变量。
  4. io.Copy 的作用?
    答:io.Copy 会持续从源 reader 读取数据,写入到 writer,直到流关闭或者出错,阻塞执行。代理双向转发依赖 io.Copy。
  5. HTTP 正向代理和 TCP 端口转发的区别?
    TCP 转发:直接转发原始 TCP 字节流,不解析 HTTP 协议。HTTP 正向代理需要解析 HTTP 请求,从请求行提取完整目标 URL,再访问目标网站。普通 HTTP 代理默认不支持 HTTPS,需要实现 CONNECT 隧道。
  6. 静态编译参数 CGO_ENABLED=0 作用?
    关闭 CGO,不链接 C 语言库,编译得到纯 Go 静态二进制,不依赖系统 glibc,上传到 Linux 服务器直接运行。
  7. 代理工具常见缺陷有哪些?
    无身份认证、无超时导致僵死连接、无连接限制导致资源耗尽、流量明文传输、缺少日志、没有异常处理容易 panic 崩溃。
  8. HTTP 代理 CONNECT 方法作用?
    客户端发送 CONNECT 请求,请求和目标网站 IP: 端口建立 TCP 隧道。代理建立 TCP 连接,之后双向转发原始流量,TLS 握手在客户端和远端服务器之间完成,实现 HTTPS 代理。

十、总结

本文从零使用 Go 语言,完成 TCP 端口转发、优化版 TCP 转发、简易 HTTP 正向代理。从 Socket 底层原理,到代码逐行讲解,再到编译、测试、踩坑、扩展思路完整覆盖。

对于安全工程师来说,掌握 Go 网络编程,自己写代理工具,最大价值不是写出一个可以替代 frp 的强大隧道,而是理解代理底层网络原理。当遇到复杂内网环境,理解流量转发原理,你可以快速判断工具是否适用,甚至修改代码适配特殊场景。

很多安全从业者长期只会使用现成工具,底层原理不清晰,遇到非常规环境就卡住。学会 Go 网络编程,你可以自己开发端口转发、扫描器、简单隧道、流量处理工具,极大提升红队、应急响应工作效率。

学习建议:先把本文代码本地跑通,理解每一行作用;然后尝试迭代增加功能,比如增加认证、增加 CONNECT 支持 HTTPS 代理。遇到报错,学会看 Go 的错误信息,逐步调试。

安全工具开发不是一蹴而就,先从简单 TCP 转发这种最小 demo 入手,循序渐进,再去开发 SOCKS5、反向隧道这类更复杂的工具。


最后

关于网络安全技术储备

学好网络安全不论是就业还是做副业赚钱都不错,但要学会网络安全还是要有一个学习规划。最后大家分享一份全套的网络安全学习资料,给那些想学习网络安全的小伙伴们一点帮助!

对于0基础小白入门:

如果你是零基础小白,想快速入门网络安全是可以考虑的。

一方面是学习时间相对较短,学习内容更全面更集中。

二方面是可以找到适合自己的学习方案

包括:网安成长学习路线图、SRC&黑客文档、护网行动、黑客必读书单、面试题、学习视频等教程。带你从零基础系统性的学好网络安全!

需要的可以微信扫描下方优快云官方认证二维码免费领取【保证100%免费】

img

👉1.成长路线图&学习规划👈
要学习一门新的技术,作为新手一定要先学习成长路线图,方向不对,努力白费。

对于从来没有接触过网络安全的同学,我们帮你准备了详细的学习成长路线图&学习规划。可以说是最科学最系统的学习路线,大家跟着这个大的方向学习准没问题。

在这里插入图片描述

👉2.网安入门到进阶视频教程👈
很多朋友都不喜欢晦涩的文字,我也为大家准备了视频教程,其中一共有21个章节,每个章节都是当前板块的精华浓缩。(全套教程文末领取哈)

在这里插入图片描述

👉3.SRC&黑客文档👈
大家最喜欢也是最关心的SRC技术文籍&黑客技术也有收录

SRC技术文籍:

在这里插入图片描述

黑客资料由于是敏感资源,这里不能直接展示哦!(全套教程文末领取哈)

👉4.护网行动资料👈
其中关于HW护网行动,也准备了对应的资料,这些内容可相当于比赛的金手指!

在这里插入图片描述

👉5.黑客必读书单👈

随着互联网技术的飞速发展,网络安全已经成为了当今科技领域的一大热点。这些SQL注入、CCNA、Web渗透、Linux服务器等,以其强大的语言理解和防御能力,正在守护着我们网络世界。 那以下这些PDF籍就是非常不错的学习资源。

img

👉6.网络安全岗面试题合集👈
当你自学到这里,你就要开始思考找工作的事情了,而工作绕不开的就是真题和面试题。

在这里插入图片描述

这份完整版的网络安全学习资料已经上传优快云,朋友们如果需要可以微信扫描下方优快云官方认证二维码免费领取【保证100%免费】

img

golang 实现WAF拦截和反向代理 / 创建一个 Coraza WAF 实例。// 处理HTTP请求的中间件。// 创建反向代理处理函数。// 设置Coraza变量。// 创建一个新的交易对象。// 创建 WAF 实例。// WAF 中间件。// 设置请求行信息。 阅读详情

相关推荐

Go语言入门书籍推荐(10本)

Go 入门指南》由中文社区 Go 中文网编写,内容涵盖了 Go 语言基础、控制流程、数组和切片、函数和指针、结构体和方法等方面的内容。《Go 语言编程》是由图灵教育编写的一本入门教程,全书共分为 18 章,包括 Go 语言基础、流程控制、函数、数组切片、指针、结构体和面向对象编程等内容。《Go 语言核心编程》是由 Go 语言爱好者张开涛编写出版的书籍,全书分为 14 章,涵盖了 Go 语言的以下方面:基础语法、函数、数组和切片、类型和接口、并发编程和Web开发等。1. 《Go 语言编程》

记录 IT 领域经验与见解的博客 4271

golang反向代理使用

一个简单的代理功能实现,主要是通过这个是httputil自带的方法,可以直接引用,但是如果我们想要做一个比较完整的反向代理功能那该怎么办呢?

zyecust的博客 2008

Go语言快速入门指南(面向Java工程师)

Go(又称 Golang)由 Google 开发,2009 年发布。简洁:语法元素少(25 个关键字 vs Java 的 50+)。高效:编译为原生机器码,无需虚拟机。并发:goroutine + channel 内置支持并发。工程化:标准库强大,依赖管理简单。与 Java 的核心区别编译方式:Java 运行在 JVM 上,Go 直接编译为机器码。面向对象模型:Java 有类和继承,Go 用 struct + 接口 + 组合。并发模型。

lpfasd123的博客 1018

Golang使用ReverseProxy实现反向代理

NewSingleHostReverseProxy是官方给的示例,代理单机服务,如果想实现负载均衡,需自己实现。

qq_22321199的专栏 1679

Go语言环境搭建

语言开发包国外官网:国内官网:第一个进不去可以进第二个。GO编辑器推荐第一款是 Visual Studio Code + Go 扩展插件,可以让你非常高效地开发,通过官方网站下载使用。第二款是老牌 IDE 公司 JetBrains 推出的 Goland,所有插件已经全部集成,更容易上手,并且功能强大,新手老手都适合,你可以通过官方网站下载使用。计算机网络基础知识:学习计算机网络的基本原理和架构,了解网络拓扑、协议等概念。

weixin_72583044的博客 1760

Go语言与区块链:用Golang开发区块链应用实战

本文旨在为开发者提供使用Go语言开发区块链应用的全面指南。区块链基础原理和架构Go语言在区块链开发中的优势区块链核心组件的Go实现智能合约开发实际应用案例分析区块链核心概念和原理Go语言实现区块链的关键技术完整区块链项目实战实际应用场景和工具推荐未来发展趋势和挑战区块链:一种分布式数据库技术,通过加密算法将数据区块按时间顺序链接起来智能合约:运行在区块链上的自执行合约,条款直接写入代码共识机制:区块链网络中节点达成一致的算法挖矿。

AI Agent Harness Engineering 1289

Go语言正/反向代理的姿势

先重温一下什么叫反向代理,正向代理。鹅厂二面,nginx回忆录[1]所谓正向,反向代理取决于代理的是出站请求,还是入站请求。正向代理:代理的出站请求, 客户端能感知到代理程序,架构上距离客户端更近。反向代理:代理的是入站请求,客户端认为代理程序就是服务器,客户端感知不到代理逻辑,架构上距离服务端更近。前几天利用golang实现反向代理程序[2],引出了Host请求头在反代中的关键作用。代理程序预置...

qq_30236895的博客 940

Go-Træfɪk一个用golang写的HTTP反向代理和负载均衡

一个用golang写的HTTP反向代理和负载均衡。提供动态变更和熔断。

【Go入门】Go语言基础知识

Go语言中那些有趣的语法

weixin_44211968的博客 7019

Go-一个反向代理提供与GoogleGithub或其他提供商的身份验证

A reverse proxy that provides authentication with Google, Github or other providers.

goproxy:反向代理身份验证服务器(golang)

Goproxy -导入“ github.com/autom8ter/goproxy” 用法 键入GoProxy type GoProxy struct { } GoProxy是可配置的单目标反向代理HTTP处理程序,与net / http http.Handler接口兼容 func NewGoProxy func NewGoProxy ( config * config. Config ) * GoProxy NewGoProxy使用指定的路径前缀为每个提供的配置注册一个新的反向代理处理程序 func(* GoProxy)ServeHTTP func ( g * GoProxy ) ServeHTTP ( w http. ResponseWriter , r * http. Request )

github上非常适合go语言新手的项目推荐

波哥公司已经全面从Python框架转向了Go语言,这反映了Go在业界的日益受欢迎。我利用工作之余的时间,在GitHub上比较了几个Go语言的开源项目,并愿意与大家分享。对于那些希望学习Go的人来说,从理解开源项目开始是个不错的选择。Go之所以越来越适合DevOps,主要是因为它拥有几个关键特性和优势,非常符合DevOps领域的需求。DevOps注重软件开发(Dev)和信息技术运维(Ops)的整合,...

IT运维技术圈 2105

一文搞定3D卷积

在讨论卷积核的时候,是不把channel维加进去的 核 = 一个可以滑动的窗口 窗口内不同位置数据之间的权值共享 3D卷积,卷积核会在3个方向上运动,那么卷积核的运动需要有三个自由度(一小块立方体,在一个大面包块内3个方向上滑动 2D卷积,卷积核只在2个方向上运动,因此只有两个自由度(一小片纸,在一大张纸内2个方向上滑动 1D卷积,卷积核只在1个方向上运动,因此只有一个自由度(一条滑窗,在一大长线上1个方向上滑动 一个卷积核运算一次 得到一个输出值 以上讨论了单个卷积核,接下来考虑多通道,一个卷积核对应一

njuptalex的博客 3万+

提速 10 倍 Go 语言开发实战内容, 从零开始开发

在当今流行的编程语言中,Go 语言独树一帜,因为其简单易学、性能强劲且原生支持并发的特点,深受开发者的青睐。Go 语言在技术 上的关注度也在逐年上升。Go语言也逐渐成为进入大厂的通行证。不时的有人问我一些关于 Go 语言学习路线、学习资源方面的问题,今天单独就来详细聊一聊。就我自己而言,已经做 Go 语言开发很年多了,中间踩了不少的坑,也整理了不少的笔记,今天就...

slphahaha的博客 3476

AI开发提效10倍:从需求到部署的全流程实战指南(附Prompt模板)

用AI开发不是“偷懒”,而是把时间花在更有价值的地方——原来花80%时间写重复代码,现在用AI搞定后,能把精力放在“优化用户体验”“提升系统性能”这些核心工作上,这才是AI给开发者的真正红利。如果你还没开始用AI做开发,建议从“写一个简单接口”“补一段注释”开始尝试,先用起来再优化方法。记住:AI是工具,不是对手,学会驾驭它,你会发现开发效率提升的同时,还能告别无效加班。

这里只有干货:从 Modbus 通信到 MES 对接,从 YOLO 训练到工控机部署,带你搞定工业软件开发全流程。 1534

水星路由器+群晖NAS+外网访问

水星路由器+群晖NAS+外网访问 有了公网IP,家里是水星路由器的 怎么设置外网访问 1.先电脑登录群晖的http://【你的群晖名】.quickconnect.to/ 2.【控制面板】进入设置 3.选择synology依次设置 ,【主机名称】就是你的名称。注意:左下角第7步,一定勾选。 4.下面进入192.168.1.1水星路由器设置。【IP与MAC绑定】点击NAS对应的【绑定】注意,点这里之前Nas一定设置了固定内网ip(后面补充 )。 5.【高级用户】-虚【拟服务器】。常用服务器不用选,其他的对应

wjxue201的博客 2600

Go(GoLang)语言基础、知识速查

Go语言基础速查摘要 Go(Golang)是Google开发的一种静态强类型、编译型语言,具有强大的并发支持和垃圾回收机制。本文介绍了Go的基础知识,包括: 语言特性:简洁高效,适合云计算、微服务等领域 基本语法:变量(var)、常量(const)声明方式,短声明语法(:=) 数据类型:基本类型(整型、浮点、布尔、字符串)和复合类型(数组、切片等) 数组与切片:数组是固定长度,切片是可变长度序列,支持自动扩容 关键字列表:25个保留关键字及其分类 文章还提供了安装指南和常用代码示例,适合快速查阅Go语言基础

张先生的前端日志 813

微信小程序消息推送全攻略:从模板消息到订阅消息的实战避坑指南

本文深入解析微信小程序消息推送机制,对比模板消息、订阅消息与客服消息的核心差异与适用场景。重点提供订阅消息从用户授权设计、前端代码实现到后端稳定发送的完整实战指南,并分享提升消息点击率的文案与运营技巧,帮助开发者构建高效、用户友好的消息推送体系。

b3n4m5q6w7的博客 341
上一篇: Docker 容器安全基础,常见容器逃逸风险
下一篇: Web 渗透完整学习路线|从 0 到入门 Web 安全,避坑指南
程序媛西米
博客等级 码龄5年 4031粉丝 1569原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值