使用Go编写轻量级代理过滤HTTP请求特殊字符

在Web安全防护中，特殊字符注入是最常见也最危险的攻击向量之一。攻击者通过在HTTP请求参数、请求头或Cookie中插入精心构造的特殊字符，试图篡改SQL查询、注入脚本或破坏后端服务逻辑。传统WAF虽然功能强大，但在性能敏感或资源受限的环境中，部署一套完整WAF往往显得笨重。使用Go语言编写一个轻量级反向代理，在请求到达业务服务之前对特殊字符进行过滤和清洗，是一种高效且可控的防护策略。Go语言天生的高并发能力、极低的内存占用和编译为单一二进制文件的特性，让它在构建这类网络中间件时优势明显。

明确需要过滤的特殊字符范围

在动手编写代码之前，必须明确哪些字符属于“特殊字符”范畴。这取决于你的后端技术栈和业务场景。对于大多数Web应用来说，高危字符主要集中在几类：SQL注入常用字符包括单引号、双引号、反斜杠、分号、双减号等；XSS攻击常用尖括号、圆括号、引号等；命令注入则涉及管道符、反引号、美元符号等。一个典型的过滤清单可以包含以下字符：<、>、'、"、;、(、)、|、&、$、"、%、\、--、/*、*/。需要注意的是，过滤策略不能一刀切，某些特殊字符在特定场景下是合法的，比如邮件地址中的@符号、URL参数中的百分号编码。因此，过滤逻辑需要结合请求的具体位置来差异化处理。

构建反向代理的核心架构

Go标准库中的net/http/httputil包提供了现成的反向代理实现，这让我们不必从零开始处理HTTP请求转发的底层细节。核心思路是创建一个自定义的Director函数来修改请求，同时重写Transport来检查响应内容。但本文的重点在于请求过滤，所以我们把主要精力放在请求体的清洗上。先看一个最精简的反向代理骨架：

package main

import (
    "net/http"
    "net/http/httputil"
    "net/url"
)

func main() {
    target, _ := url.Parse("http://localhost:8080")
    proxy := httputil.NewSingleHostReverseProxy(target)
    
    http.ListenAndServe(":9090", proxy)
}

这段代码将来自9090端口的请求原封不动地转发到本地8080端口。要加入过滤逻辑，我们需要在代理处理请求之前拦截并清洗数据。有两种方式可以实现：一种是包装http.Handler，在调用ServeHTTP之前修改请求；另一种是修改Director函数。对于请求URL和请求头的过滤，修改Director更加直接；对于请求体的过滤，则需要在Transport层面处理，因为Director无法访问请求体。

实现请求URL参数的特殊字符过滤

URL查询参数是SQL注入和XSS攻击的高发区域。攻击者常常在参数值中插入恶意字符，试图绕过前端验证直接打击后端。我们可以在Director函数中对请求的URL进行清洗。具体做法是解析原始请求的查询参数，遍历每个参数值，用正则表达式或字符串替换函数移除或转义危险字符，然后重新编码回URL。以下是实现代码：

func sanitizeQueryParams(r *http.Request) {
    q := r.URL.Query()
    for key, values := range q {
        cleaned := make([]string, len(values))
        for i, v := range values {
            cleaned[i] = sanitizeString(v)
        }
        q[key] = cleaned
    }
    r.URL.RawQuery = q.Encode()
}

func sanitizeString(s string) string {
    // 移除或替换危险字符
    replacer := strings.NewReplacer(
        "<", "",
        ">", "",
        "'", "",
        "\"", "",
        ";", "",
        "(", "",
        ")", "",
        "|", "",
        "&", "",
        "$", "",
        "`", "",
        "\\", "",
    )
    return replacer.Replace(s)
}

将sanitizeQueryParams函数集成到代理的Director中，每个经过代理的请求都会自动清洗查询参数。这里采用了直接移除危险字符的策略，你也可以选择将它们转义为HTML实体或URL编码形式，具体取决于后端服务的处理逻辑。如果后端期望接收原始数据但需要安全处理，转义会比直接删除更合适，因为直接删除可能破坏业务数据的完整性。

处理POST请求体的特殊字符过滤

请求体的过滤比URL参数复杂得多，因为请求体可能很大，而且内容类型多样，包括application/x-www-form-urlencoded、multipart/form-data、application/json等。对于表单编码的数据，处理方式与查询参数类似；对于JSON数据，需要解析JSON结构后递归过滤字符串值；对于文件上传的multipart数据，则要谨慎处理，避免损坏二进制文件内容。实现请求体过滤需要包装http.RoundTripper，在转发请求之前读取并清洗请求体，然后用清洗后的内容替换原始请求体。这里给出一个处理JSON请求体的示例：

type sanitizeTransport struct {
    transport http.RoundTripper
}

func (t *sanitizeTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    if req.Body != nil && req.Method == "POST" {
        contentType := req.Header.Get("Content-Type")
        if strings.Contains(contentType, "application/json") {
            bodyBytes, _ := io.ReadAll(req.Body)
            req.Body.Close()
            
            var data interface{}
            json.Unmarshal(bodyBytes, &data)
            sanitizeJSON(data)
            cleaned, _ := json.Marshal(data)
            
            req.Body = io.NopCloser(bytes.NewReader(cleaned))
            req.ContentLength = int64(len(cleaned))
        }
    }
    return t.transport.RoundTrip(req)
}

func sanitizeJSON(data interface{}) {
    switch v := data.(type) {
    case map[string]interface{}:
        for key, val := range v {
            switch val.(type) {
            case string:
                v[key] = sanitizeString(val.(string))
            case map[string]interface{}, []interface{}:
                sanitizeJSON(val)
            }
        }
    case []interface{}:
        for i, val := range v {
            switch val.(type) {
            case string:
                v[i] = sanitizeString(val.(string))
            case map[string]interface{}, []interface{}:
                sanitizeJSON(val)
            }
        }
    }
}

这个自定义Transport会拦截所有POST请求，检查Content-Type是否为JSON，如果是则解析JSON、递归过滤所有字符串值中的特殊字符，然后重新序列化并替换请求体。对于其他内容类型，可以按类似逻辑扩展。需要注意的是，读取请求体会消耗io.ReadCloser，所以必须用io.NopCloser重新包装一个可读取的Reader放回去，否则下游服务将收到空的请求体。

过滤HTTP请求头中的特殊字符

请求头同样是攻击者喜欢利用的通道，尤其是User-Agent、Referer、Cookie等由客户端自由填写的头部字段。头部注入可能导致日志污染、HTTP响应拆分等安全问题。在Director函数中遍历请求头并清洗每个值，可以有效阻断这类攻击。实现代码非常直接：

func sanitizeHeaders(r *http.Request) {
    for key, values := range r.Header {
        cleaned := make([]string, len(values))
        for i, v := range values {
            cleaned[i] = sanitizeString(v)
        }
        r.Header[key] = cleaned
    }
}

将sanitizeHeaders与前面的sanitizeQueryParams一起放入Director，就能同时覆盖URL参数和请求头两个攻击面。对于Cookie，虽然它也属于请求头的一部分，但由于Cookie的格式特殊，有时需要单独解析Cookie头部，对每个Cookie的值进行过滤后再重新拼接。否则直接对整个Cookie字符串做字符替换可能会破坏Cookie的分隔符结构。

构建完整的代理服务并添加配置灵活性

将上述所有组件整合在一起，我们得到一个功能完整的轻量级过滤代理。为了让它更具实用性，可以添加命令行参数来配置监听地址、目标地址以及过滤策略的严格程度。以下是一个完整的可运行版本：

package main

import (
    "bytes"
    "encoding/json"
    "flag"
    "io"
    "log"
    "net/http"
    "net/http/httputil"
    "net/url"
    "strings"
)

var (
    listenAddr = flag.String("listen", ":9090", "代理监听地址")
    targetAddr = flag.String("target", "http://localhost:8080", "后端目标地址")
    strictMode = flag.Bool("strict", false, "严格模式：遇到危险字符直接拒绝请求")
)

func main() {
    flag.Parse()
    
    target, err := url.Parse(*targetAddr)
    if err != nil {
        log.Fatal("无效的目标地址:", err)
    }
    
    proxy := httputil.NewSingleHostReverseProxy(target)
    
    originalDirector := proxy.Director
    proxy.Director = func(req *http.Request) {
        originalDirector(req)
        sanitizeHeaders(req)
        sanitizeQueryParams(req)
    }
    
    proxy.Transport = &sanitizeTransport{
        transport: http.DefaultTransport,
        strict:    *strictMode,
    }
    
    log.Printf("代理启动，监听 %s -> %s", *listenAddr, *targetAddr)
    log.Fatal(http.ListenAndServe(*listenAddr, proxy))
}

func sanitizeString(s string) string {
    replacer := strings.NewReplacer(
        "<", "<",
        ">", ">",
        "'", "'",
        "\"", """,
        ";", "",
        "|", "",
        "`", "",
        "\\", "\\\\",
    )
    return replacer.Replace(s)
}

func sanitizeHeaders(r *http.Request) {
    for key, values := range r.Header {
        cleaned := make([]string, len(values))
        for i, v := range values {
            cleaned[i] = sanitizeString(v)
        }
        r.Header[key] = cleaned
    }
}

func sanitizeQueryParams(r *http.Request) {
    q := r.URL.Query()
    for key, values := range q {
        cleaned := make([]string, len(values))
        for i, v := range values {
            cleaned[i] = sanitizeString(v)
        }
        q[key] = cleaned
    }
    r.URL.RawQuery = q.Encode()
}

type sanitizeTransport struct {
    transport http.RoundTripper
    strict    bool
}

func (t *sanitizeTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    if req.Body != nil && (req.Method == "POST" || req.Method == "PUT" || req.Method == "PATCH") {
        contentType := req.Header.Get("Content-Type")
        
        if strings.Contains(contentType, "application/json") {
            bodyBytes, err := io.ReadAll(req.Body)
            req.Body.Close()
            if err != nil {
                return nil, err
            }
            
            var data interface{}
            if err := json.Unmarshal(bodyBytes, &data); err != nil {
                // JSON解析失败，在严格模式下拒绝请求
                if t.strict {
                    return &http.Response{
                        StatusCode: http.StatusBadRequest,
                        Body:       io.NopCloser(strings.NewReader("Invalid JSON")),
                    }, nil
                }
                // 非严格模式下原样转发
                req.Body = io.NopCloser(bytes.NewReader(bodyBytes))
                return t.transport.RoundTrip(req)
            }
            
            sanitizeJSON(data)
            cleaned, _ := json.Marshal(data)
            req.Body = io.NopCloser(bytes.NewReader(cleaned))
            req.ContentLength = int64(len(cleaned))
        }
    }
    return t.transport.RoundTrip(req)
}

func sanitizeJSON(data interface{}) {
    switch v := data.(type) {
    case map[string]interface{}:
        for key, val := range v {
            switch val.(type) {
            case string:
                v[key] = sanitizeString(val.(string))
            case map[string]interface{}, []interface{}:
                sanitizeJSON(val)
            }
        }
    case []interface{}:
        for i, val := range v {
            switch val.(type) {
            case string:
                v[i] = sanitizeString(val.(string))
            case map[string]interface{}, []interface{}:
                sanitizeJSON(val)
            }
        }
    }
}

这个版本增加了严格模式选项，当JSON请求体格式错误时可以选择直接返回400错误，而不是原样转发。这种灵活性在生产环境中非常重要，因为有些客户端可能发送非标准但业务上可接受的请求体。

性能考量与并发优化

Go语言的反向代理默认为每个请求启动一个goroutine，并发能力已经非常出色。但我们的过滤逻辑引入了额外的CPU开销，尤其是JSON解析和字符串替换。在高并发场景下，有几个优化点值得关注。第一，字符串替换可以使用strings.Builder手动遍历字符来避免多次内存分配，比strings.NewReplacer在替换规则较多时更高效。第二，对于JSON过滤，如果请求体很大，完全解析和重新序列化的成本不容忽视。可以考虑使用json.Decoder流式处理，边读取边过滤边写入，减少内存峰值。第三，对于不需要过滤的静态资源请求，可以在代理层面直接放行，避免不必要的解析开销。通过检查请求路径后缀来判断是否为静态资源，如果是则跳过所有过滤逻辑。第四，利用sync.Pool复用bytes.Buffer和strings.Builder等对象，降低GC压力。

日志记录与监控告警

一个合格的过滤代理不仅要拦截恶意请求，还需要记录攻击行为以便后续分析和追溯。在过滤逻辑触发时，应该输出包含时间戳、客户端IP、原始请求内容、过滤后内容等信息的日志。建议使用结构化日志库如zerolog或zap来输出JSON格式日志，方便接入日志收集系统。当某个IP在短时间内触发大量过滤规则时，可以触发告警或自动将该IP加入临时黑名单。这种动态防护能力让轻量级代理不再只是被动过滤，而是具备了初步的主动防御能力。日志记录要注意隐私合规，避免将用户密码、Token等敏感字段明文写入日志。

测试策略与验证方法

过滤代理上线前必须经过充分的测试。单元测试可以覆盖sanitizeString、sanitizeJSON等纯函数，确保各种特殊字符组合都能被正确处理。集成测试则需要启动一个模拟后端服务，通过代理发送包含恶意字符的请求，验证后端收到的请求确实已被清洗。测试用例应该覆盖GET参数注入、POST JSON注入、请求头注入、Cookie注入、多层嵌套JSON、Unicode编码绕过等场景。特别要注意的是，攻击者可能会使用URL编码、双重编码、Unicode同形字等手段绕过简单的字符串匹配过滤。例如，尖括号<可以被编码为%3C，如果代理在URL解码之前就进行过滤，就会漏掉这类攻击。因此，过滤逻辑应该作用在解码后的数据上，这也是为什么我们在r.URL.Query()返回已解码的参数值之后才进行过滤的原因。

部署方式与运维建议

编译后的Go代理是一个独立的二进制文件，不依赖任何运行时环境，部署极其简单。可以将其放置在业务服务的前端，作为Sidecar容器与业务容器部署在同一个Pod中，或者作为独立的守护进程运行在宿主机上。对于多实例部署，可以在代理前面再加一层负载均衡。配置管理方面，建议将过滤规则、目标地址等配置外置到配置文件或环境变量中，避免硬编码。在运维过程中，要定期审查过滤日志，根据新的攻击手法更新过滤规则。同时要注意代理自身的资源消耗，设置合理的goroutine数量上限和请求超时时间，防止因后端服务响应缓慢导致代理资源耗尽。

使用Go编写轻量级代理来过滤HTTP请求特殊字符，本质上是在应用层构建一道可编程、可定制的安全防线。它不像商业WAF那样大而全，但胜在轻量、透明、完全可控。对于中小型项目或微服务架构中的关键服务节点，这种方案在安全性和性能之间取得了很好的平衡。通过持续迭代过滤规则和优化处理逻辑，这个小小的代理可以成为整体安全体系中坚实的一环。

使用Go编写轻量级代理过滤HTTP请求特殊字符

服务指南

帮助中心