如何在Go中通过自定义io.Writer过滤exec.Command输出的敏感数据

这个需求很实用，我之前做类似的日志脱敏功能时，刚好采用了自定义io.Writer的方案，下面给你详细拆解实现思路和代码：

核心思路 #

因为exec.Command的Stdout/Stderr可以接收任意实现了io.Writer接口的对象，我们只需要实现一个带过滤逻辑的Writer：

1. 维护一个缓冲区，处理分块传入的输出（比如一行内容可能被拆成多次Write调用）
2. 对每一段完整的内容（按行处理更稳妥）进行敏感词替换/模式匹配过滤
3. 将过滤后的内容转发到最终的输出目标（比如os.Stdout或者文件）

具体实现代码 #

1. 定义过滤Writer结构体 #

首先我们需要一个结构体来保存必要的状态：

import (
    "bytes"
    "io"
)

type PasswordFilter struct {
    dest     io.Writer       // 最终输出的目标Writer
    buf      []byte          // 缓冲区，暂存未处理的不完整内容
    replacer *bytes.Replacer // 敏感词替换器，也可以用正则实现模式匹配
}

2. 构造函数 #

方便快速创建过滤Writer实例：

func NewPasswordFilter(dest io.Writer, sensitivePairs ...string) *PasswordFilter {
    return &PasswordFilter{
        dest:     dest,
        buf:      make([]byte, 0, 1024), // 初始化缓冲区，大小可根据实际调整
        replacer: bytes.NewReplacer(sensitivePairs...),
    }
}

这里用bytes.Replacer是因为它处理字节流效率更高，如果需要更复杂的模式（比如匹配password: xxx这种格式），可以换成正则表达式。

3. 实现io.Writer的Write方法 #

这是核心逻辑，需要处理分块数据、缓冲区和过滤：

func (pf *PasswordFilter) Write(p []byte) (n int, err error) {
    // 把新传入的字节追加到缓冲区
    pf.buf = append(pf.buf, p...)

    // 循环处理缓冲区中的完整行
    for {
        // 找到换行符的位置
        newlineIdx := bytes.IndexByte(pf.buf, '\n')
        if newlineIdx == -1 {
            break // 没有完整的行，退出循环，保留缓冲区内容等待下一次写入
        }

        // 取出完整的一行（包含换行符）
        line := pf.buf[:newlineIdx+1]
        // 执行敏感词替换
        filteredLine := pf.replacer.Replace(line)

        // 将过滤后的内容写入目标Writer
        _, err = pf.dest.Write(filteredLine)
        if err != nil {
            return n, err
        }

        // 更新缓冲区，移除已经处理的行
        pf.buf = pf.buf[newlineIdx+1:]
    }

    // 注意：io.Writer要求返回已经接收的字节数，这里我们已经接收了全部p的内容，所以返回len(p)
    return len(p), nil
}

4. 使用示例 #

现在可以把这个过滤Writer绑定到exec.Command的输出上：

import (
    "os"
    "os/exec"
    "log"
)

func main() {
    // 定义敏感词和替换内容，比如把真实密码换成***，token换成*****
    sensitivePairs := []string{
        "mySuperSecretPass123", "***",
        "authToken_abcdef123", "*****",
    }

    // 创建过滤Writer，目标输出到控制台
    filter := NewPasswordFilter(os.Stdout, sensitivePairs...)

    // 构造要执行的命令（这里以一个输出敏感数据的命令为例）
    cmd := exec.Command("echo", "Connecting with password: mySuperSecretPass123, token: authToken_abcdef123")
    
    // 将命令的stdout和stderr都指向过滤Writer
    cmd.Stdout = filter
    cmd.Stderr = filter

    // 执行命令
    err := cmd.Run()
    if err != nil {
        log.Fatalf("Command execution failed: %v", err)
    }
}

进阶优化：正则模式匹配 #

如果不知道具体的敏感词，而是要匹配类似password: 任意内容的模式，可以把替换逻辑换成正则：

import "regexp"

// 修改结构体，替换replacer为正则对象
type PasswordFilter struct {
    dest io.Writer
    buf  []byte
    re   *regexp.Regexp
}

// 构造函数改为接收正则表达式
func NewRegexPasswordFilter(dest io.Writer, pattern string) (*PasswordFilter, error) {
    re, err := regexp.Compile(pattern)
    if err != nil {
        return nil, err
    }
    return &PasswordFilter{
        dest: dest,
        buf:  make([]byte, 0, 1024),
        re:   re,
    }, nil
}

// 修改Write方法中的过滤逻辑
func (pf *PasswordFilter) Write(p []byte) (n int, err error) {
    pf.buf = append(pf.buf, p...)

    for {
        newlineIdx := bytes.IndexByte(pf.buf, '\n')
        if newlineIdx == -1 {
            break
        }

        line := pf.buf[:newlineIdx+1]
        // 用正则替换匹配到的内容
        filteredLine := []byte(pf.re.ReplaceAllString(string(line), "$1***"))
        // 比如pattern是`(?i)(password:\s*)\S+`，$1会保留"password: "部分，替换后面的内容为***

        _, err = pf.dest.Write(filteredLine)
        if err != nil {
            return n, err
        }

        pf.buf = pf.buf[newlineIdx+1:]
    }

    return len(p), nil
}

注意事项 #

• 缓冲区的大小可以根据实际输出的内容调整，避免频繁扩容
• 如果敏感词可能被拆分成多次Write调用（比如跨块），上述按行处理的方式可能会漏过滤，这种情况需要更复杂的字符串匹配算法（比如AC自动机），不过命令输出中这种场景比较少见
• 记得同时处理Stderr，很多命令会把错误信息和敏感数据输出到标准错误流

内容的提问来源于stack exchange，提问作者Athropos