Go 语言开发简单代理工具,适合安全工程师入门
免责声明:本文所讲解的代理工具开发、网络编程知识,仅用于内网安全演练、企业授权安全测试、个人编程学习。禁止使用本文代码在未获得授权的网络环境中进行流量转发、端口转发、代理访问等操作。未经授权的流量代理、内网穿透、流量劫持行为,会触犯网络安全相关法律法规,由此产生的一切法律责任由使用者自行承担。本文所有代码仅做学习演示,不建议直接用于生产环境。
前言
作为安全工程师,日常工作中经常会和代理、端口转发打交道。内网渗透、横向移动、流量中转、绕过防火墙、隧道搭建,几乎都离不开代理工具。很多同学平时都是直接使用现成工具:socat、nc、frp、reGeorg、chisel 等工具,拿来即用。但很多人只知道怎么用,不知道底层原理。一旦遇到特殊场景,现有工具不满足需求,就束手无策。
Go 语言(Golang)非常适合安全工具开发。它编译简单,单文件静态编译,编译之后直接生成可执行程序,不需要依赖运行环境,丢到 Linux、Windows 服务器直接运行,交叉编译也很方便。这也是大量红队工具选择 Go 开发的核心原因。
本文面向安全工程师入门,从零开始,使用 Go 语言一步步实现TCP 端口转发、正向代理、简单 HTTP 代理,讲解底层网络编程知识,剖析代理的原理。从基础的 Socket 编程入手,循序渐进,先写最简单端口转发,再实现正向 TCP 代理,最后实现简易 HTTP 代理,附带代码逐行讲解、编译方法、靶场测试、踩坑点、工具扩展思路。
文章不会堆砌复杂语法,不会深入 Go 协程底层复杂原理,重点聚焦网络编程 + 代理原理。适合有基础 Go 语法基础,或者安全从业者想入门 Go 安全工具开发的读者。读完本文,你能理解代理底层原理,独立写出简单 TCP 转发工具,并且可以基于本文代码继续扩展成自己的简易隧道工具。
全文所有代码都可以直接复制到本地测试,配套讲解每一段代码的作用、安全场景用途、存在的缺陷,以及后续优化方向。
一、前置知识准备
1.1 为什么安全工程师推荐学习 Go 开发工具?
- 静态编译,无依赖:Go 编译后生成单个二进制文件,不需要安装 lib、python 环境。渗透拿到服务器,直接上传二进制就能运行,这是安全场景巨大优势。
- 原生协程 Goroutine:轻量级协程,处理并发连接非常方便。写代理工具,每一条客户端连接起一个协程,代码简单,并发性能不错。对比 C 语言需要手动处理多线程,Python 多线程 GIL 锁限制并发,Go 写网络工具非常顺手。
- 标准库强大:
net包内置 TCP、UDP、HTTP 网络相关库,不需要额外安装第三方库,写网络工具只依赖标准库,编译出来的程序体积可控。 - 跨平台交叉编译:一行命令,在 Windows 上编译 Linux 可执行文件,Linux 编译 Windows 程序,适配靶场多操作系统环境。
- 语法简洁:相比 C/C++,语法简单,上手门槛低,不用花大量时间处理内存管理。
劣势:Go 生成的二进制文件体积偏大;不适合底层内核级工具开发。但对于应用层代理、端口转发、爬虫、简单扫描器这类安全工具,Go 是首选。
1.2 代理基础概念区分(安全面试高频)
很多新手容易混淆端口转发、正向代理、反向代理,这里一次性区分清楚。
- 端口转发(TCP 转发):监听本地端口,收到流量之后,原样转发到目标 IP: 端口。属于底层 TCP 流量转发,不解析上层协议。典型场景:内网机器 A 无法直连机器 B,在中间跳板机做端口转发,访问跳板机端口,流量转发到 B。
- 正向代理:客户端明确指定代理服务器,代理代替客户端去访问目标地址。比如 HTTP 代理,浏览器配置代理服务器,由代理去访问外网网站。客户端知道代理存在。
- 反向代理:用户访问代理,代理把流量分发到后端多台服务器。用户不知道后端真实服务器,Nginx 反向代理属于这类。红队渗透很少用到反向代理。
本文实现顺序:
- 基础 TCP Socket 编程(Go net 包基础)
- TCP 端口转发工具(最简单,无协议解析)
- TCP 正向代理(支持多并发连接)
- 简易 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包是本次开发的核心,两个核心函数:
net.Listen("tcp", "0.0.0.0:8888"):监听 TCP 端口,开启服务,等待客户端连接。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)
}
}
代码逐行讲解
net.Listen在本机 9999 端口监听 TCP,0.0.0.0 代表监听本机所有网卡。- 无限循环
listener.Accept(),阻塞等待新客户端 TCP 连接。 - 一旦收到连接,立刻开启 goroutine
go handleConn(conn),单独协程处理这个客户端,主循环继续等待下一个连接,实现并发。 conn.Read读取客户端发来的字节流;conn.Write向客户端发送数据。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 逐行解析核心逻辑
transfer函数:io.Copy(dst, src),把 src 的数据流全部拷贝写入 dst。TCP 是双向流,客户端发往目标、目标返回客户端,两个方向,需要两个 transfer。handleClient:收到客户端连接后,代理使用net.Dial建立到目标服务的 TCP 连接。- 开启协程
go transfer(clientConn, targetConn):客户端流量转发给目标。主线程执行transfer(targetConn, clientConn),目标返回流量转发回客户端。
关键点:io.Copy 是阻塞调用,一旦连接断开,io.Copy 返回,defer 自动关闭两个连接。
- 使用 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 安全场景使用场景
- 内网跳板端口转发,访问内网无法直连端口;
- 流量中转,简单流量中继;
- 渗透测试中,绕过网络 ACL,把内网端口暴露到跳板机。
3.5 当前版本缺陷(重点,安全工具开发要清楚局限性)
- 无日志,无流量打印,无法查看转发了什么流量;
- 没有超时控制,长时间空闲连接不会自动断开,容易积累大量 socket 句柄;
- 没有连接数限制,大量并发连接会耗尽服务器资源;
- 纯 TCP 转发,不解析上层协议,只能转发 TCP 流量,不能做 HTTP 代理;
- 没有身份认证,任何人访问监听端口都能使用转发,存在安全风险;
- 没有加密,流量明文传输,抓包直接看到全部数据。
这就是入门工具的特点,功能简单,适合学习,生产 / 实战需要继续增加功能。
四、实战开发 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 新增功能讲解
- 连接计数 + 最大并发限制:使用
sync.Mutex互斥锁保护全局连接计数器,防止并发修改变量引发竞态问题。超过最大连接数直接拒绝新连接,防止服务器资源耗尽。 - 读写超时 SetReadDeadline:30 秒无数据,自动断开连接,释放 socket 资源,防止僵死连接。
- DialTimeout:连接目标地址 5 秒超时,不会无限阻塞。
- 自定义 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 代码讲解
http.ReadRequest直接解析客户端发来的 HTTP 请求,Go 标准库 http 包内置 HTTP 解析,不用手动解析字符串,极大简化开发。http.DefaultClient.Do(req):代理客户端发起 HTTP 请求,访问目标网站。resp.Write(conn):将目标服务器返回的 HTTP 响应,直接写入客户端连接,返回浏览器。
5.4 测试方法
- 编译运行
go build -o httpproxy main.go
./httpproxy -l 0.0.0.0:8080
- 浏览器设置 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 加密。
七、工具扩展方向(安全工程师进阶开发思路)
基于本文代码,你可以继续扩展功能,把简单代理升级为渗透可用的隧道工具:
- 增加账号密码认证:TCP 代理握手阶段,客户端先发认证包,认证失败直接断开,防止未授权访问。
- 增加 TLS 加密:客户端和代理之间流量 TLS 加密,规避 IDS 明文流量检测。
- 实现 CONNECT 方法,支持 HTTPS 代理,完善 HTTP 代理。
- 实现 SOCKS5 代理,红队最常用代理协议。
- 增加流量日志保存,把转发流量保存到 pcap 或者日志文件。
- 增加流量混淆、自定义数据包编码,绕过 WAF、IDS 特征检测。
- 增加断线重连,反向代理(反向隧道),类似 frp。
- 增加 UDP 转发,本文只实现 TCP,DNS 转发等场景需要 UDP。
- 增加限速功能,防止流量打满带宽。
- 增加命令行彩色输出,格式化日志。
开发思路:先实现最小可用版本,逐步迭代增加功能,不要一次性写大量复杂代码。这是安全工具开发推荐的开发方式。
八、安全开发规范:安全工程师写工具的注意事项
很多安全同学写工具,只追求功能,忽略代码安全,这里列出规范:
- 输入校验:所有命令行参数、网络读取的数据,做好校验,防止异常输入导致程序 panic 崩溃。比如目标地址不可为空,端口范围合法。
- 日志脱敏:日志中不要打印明文密码、密钥等敏感信息。
- 资源限制:最大连接数、内存限制,防止工具被攻击触发 DoS。
- 不要硬编码 IP、密码,代码中禁止写死密钥,通过命令行参数传入。
- 错误处理:不能忽略 err,很多新手写代码直接
_, _ := net.Dial(...)丢弃错误,出问题无法排查。 - 最小权限运行:工具运行尽量不用 root,除非端口 < 1024 需要 root 监听。
重要:自己开发的工具,在客户环境、企业网络使用,必须提前获得书面授权。
九、面试 & 红队安全开发高频问题汇总
- TCP 端口转发的原理是什么?
答:代理监听本地端口,收到客户端 TCP 连接后,代理主动建立到目标服务的 TCP 连接。开启双向 IO 拷贝,客户端流量转发给目标,目标返回流量转发回客户端。TCP 是字节流,不关心上层应用协议。 - Go 为什么适合安全工具开发?
答:静态编译,单二进制无依赖;原生 Goroutine 轻量级协程,并发网络处理简单;标准库 net/http 完善,跨平台交叉编译方便。 - Goroutine 并发开发,全局计数器为什么需要 sync.Mutex?
答:多个协程同时读写同一个全局变量,会出现竞态条件,数据错乱。Mutex 互斥锁保证同一时间只有一个协程修改变量。 - io.Copy 的作用?
答:io.Copy 会持续从源 reader 读取数据,写入到 writer,直到流关闭或者出错,阻塞执行。代理双向转发依赖 io.Copy。 - HTTP 正向代理和 TCP 端口转发的区别?
TCP 转发:直接转发原始 TCP 字节流,不解析 HTTP 协议。HTTP 正向代理需要解析 HTTP 请求,从请求行提取完整目标 URL,再访问目标网站。普通 HTTP 代理默认不支持 HTTPS,需要实现 CONNECT 隧道。 - 静态编译参数 CGO_ENABLED=0 作用?
关闭 CGO,不链接 C 语言库,编译得到纯 Go 静态二进制,不依赖系统 glibc,上传到 Linux 服务器直接运行。 - 代理工具常见缺陷有哪些?
无身份认证、无超时导致僵死连接、无连接限制导致资源耗尽、流量明文传输、缺少日志、没有异常处理容易 panic 崩溃。 - 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%免费】

👉1.成长路线图&学习规划👈
要学习一门新的技术,作为新手一定要先学习成长路线图,方向不对,努力白费。
对于从来没有接触过网络安全的同学,我们帮你准备了详细的学习成长路线图&学习规划。可以说是最科学最系统的学习路线,大家跟着这个大的方向学习准没问题。

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

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

黑客资料由于是敏感资源,这里不能直接展示哦!(全套教程文末领取哈)
👉4.护网行动资料👈
其中关于HW护网行动,也准备了对应的资料,这些内容可相当于比赛的金手指!

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

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

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

4271



被折叠的 条评论
为什么被折叠?



