修复发布构建本机路径泄漏并补齐产物检查

This commit is contained in:
xuans committed 2026-09-20 02:01:06 +08:00
1 parent ba6c6d13e5
commit a21240109a
13 files changed
+436 -28

No files matched your search

+2 -2
View File
@@ -83,7 +83,7 @@ SCERT_SERVER_HTTPS_MODE=proxy
```powershell
go fmt ./...
go test ./...
go build -o dist/scert.exe ./cmd/scert
go build -trimpath -o dist/scert.exe ./cmd/scert
```
Linux amd64 交叉编译:
@@ -91,7 +91,7 @@ Linux amd64 交叉编译:
```powershell
$env:GOOS = 'linux'
$env:GOARCH = 'amd64'
go build -o dist/scert-linux-amd64 ./cmd/scert
go build -trimpath -o dist/scert-linux-amd64 ./cmd/scert
Remove-Item Env:GOOS
Remove-Item Env:GOARCH
```
+13 -1
View File
@@ -21,13 +21,25 @@ func (items *stringList) Set(value string) error {
}
func main() {
var executables stringList
var executables, binaries, forbiddenPaths stringList
source := flag.String("source", "", "发布源目录")
output := flag.String("output", "", "发布归档路径")
format := flag.String("format", "", "归档格式:tar.gz 或 zip")
verifyOnly := flag.Bool("verify-only", false, "仅检查路径裁剪和本机路径残留")
flag.Var(&executables, "executable", "需要写入 0755 权限的相对路径,可重复指定")
flag.Var(&binaries, "binary", "需要检查路径裁剪的二进制相对路径,可重复指定")
flag.Var(&forbiddenPaths, "forbid-path", "不得写入产物的本机构建路径,可重复指定")
flag.Parse()
if *verifyOnly {
if err := releasearchive.Verify(*source, binaries, forbiddenPaths); err != nil {
fmt.Fprintln(os.Stderr, "发布路径检查失败:"+err.Error())
os.Exit(1)
}
fmt.Println("发布路径检查通过")
return
}
if err := releasearchive.Create(releasearchive.Options{
Source: *source, Destination: *output, Format: releasearchive.Format(*format), Executables: executables,
}); err != nil {
+1 -6
View File
@@ -5,17 +5,12 @@ import (
"os"
"path/filepath"
"regexp"
"runtime"
"strings"
"testing"
)
func TestLinuxInstallerPolicy(t *testing.T) {
_, sourceFile, _, ok := runtime.Caller(0)
if !ok {
t.Fatal("无法定位测试源文件")
}
installerPath := filepath.Join(filepath.Dir(sourceFile), "..", "..", "..", "deploy", "install-linux.sh")
installerPath := filepath.Join("..", "..", "..", "deploy", "install-linux.sh")
data, err := os.ReadFile(installerPath)
if err != nil {
t.Fatalf("读取 Linux 安装器失败:%v", err)
+1 -5
View File
@@ -12,11 +12,7 @@ import (
)
func TestScertAdminSystemdUnitKeepsManualOnlyPolicy(t *testing.T) {
_, sourceFile, _, ok := runtime.Caller(0)
if !ok {
t.Fatal("无法定位测试源文件")
}
unitPath := filepath.Join(filepath.Dir(sourceFile), "..", "..", "..", "deploy", "systemd", "Scert-admin.service")
unitPath := filepath.Join("..", "..", "..", "deploy", "systemd", "Scert-admin.service")
data, err := os.ReadFile(unitPath)
if err != nil {
t.Fatalf("读取 Scert-admin systemd unit 失败:%v", err)
+1 -6
View File
@@ -3,17 +3,12 @@ package admin
import (
"os"
"path/filepath"
"runtime"
"strings"
"testing"
)
func TestScertSystemdUnitPolicy(t *testing.T) {
_, sourceFile, _, ok := runtime.Caller(0)
if !ok {
t.Fatal("无法定位测试源文件")
}
unitPath := filepath.Join(filepath.Dir(sourceFile), "..", "..", "..", "deploy", "systemd", "Scert.service")
unitPath := filepath.Join("..", "..", "..", "deploy", "systemd", "Scert.service")
data, err := os.ReadFile(unitPath)
if err != nil {
t.Fatalf("读取 Scert systemd unit 失败:%v", err)
@@ -17,7 +17,7 @@ func TestCreateTarGzPreservesReleaseModes(t *testing.T) {
destination := filepath.Join(t.TempDir(), "Scert-test.tar.gz")
if err := Create(Options{
Source: source, Destination: destination, Format: FormatTarGz,
Executables: []string{"install-linux.sh", "scert", "scert-admin"},
Executables: []string{"install-linux.sh", "scert", "scert-admin", "scert-nginx", "ScertDesktop"},
}); err != nil {
t.Fatalf("创建 Linux 发布归档失败:%v", err)
}
@@ -47,6 +47,8 @@ func TestCreateTarGzPreservesReleaseModes(t *testing.T) {
assertMode(t, modes, "install-linux.sh", 0o755)
assertMode(t, modes, "scert", 0o755)
assertMode(t, modes, "scert-admin", 0o755)
assertMode(t, modes, "scert-nginx", 0o755)
assertMode(t, modes, "ScertDesktop", 0o755)
assertMode(t, modes, "web/index.html", 0o644)
assertMode(t, modes, "web", 0o755)
}
@@ -123,7 +125,7 @@ func createFixture(t *testing.T) string {
if err := os.MkdirAll(filepath.Join(source, "web"), 0o755); err != nil {
t.Fatal(err)
}
for _, name := range []string{"install-linux.sh", "scert", "scert-admin"} {
for _, name := range []string{"install-linux.sh", "scert", "scert-admin", "scert-nginx", "ScertDesktop"} {
if err := os.WriteFile(filepath.Join(source, name), []byte(name), 0o644); err != nil {
t.Fatal(err)
}
+150
View File
@@ -0,0 +1,150 @@
package releasearchive
import (
"bytes"
"debug/buildinfo"
"errors"
"fmt"
"io"
"io/fs"
"os"
"path/filepath"
"strings"
"unicode/utf16"
)
// Verify 检查构建标记及本机构建路径,不将被禁止的路径写入发布清单。
func Verify(source string, binaries, forbiddenPaths []string) error {
if source == "" || len(binaries) == 0 || len(forbiddenPaths) == 0 {
return errors.New("发布检查必须提供源目录、二进制文件和本机路径")
}
info, err := os.Lstat(source)
if err != nil {
return fmt.Errorf("检查发布源目录失败:%w", err)
}
if !info.IsDir() || info.Mode()&os.ModeSymlink != 0 {
return errors.New("发布源路径必须是普通目录")
}
patterns := pathPatterns(forbiddenPaths)
if len(patterns) == 0 {
return errors.New("本机路径不能为空")
}
if err := filepath.WalkDir(source, func(path string, entry fs.DirEntry, walkErr error) error {
if walkErr != nil {
return walkErr
}
if entry.IsDir() {
return nil
}
info, err := entry.Info()
if err != nil {
return err
}
if !info.Mode().IsRegular() {
return errors.New("发布检查不接受符号链接或特殊文件")
}
file, err := os.Open(path)
if err != nil {
return err
}
defer file.Close()
if err := scanPaths(file, patterns); err != nil {
relative, _ := filepath.Rel(source, path)
return fmt.Errorf("发布文件 %s 检查失败:%w", relative, err)
}
return nil
}); err != nil {
return err
}
for _, name := range binaries {
if !filepath.IsLocal(name) {
return errors.New("二进制文件必须位于发布目录内")
}
info, err := buildinfo.ReadFile(filepath.Join(source, name))
if err != nil {
return fmt.Errorf("读取 %s 的 Go 构建信息失败:%w", name, err)
}
trimmed := false
for _, setting := range info.Settings {
if setting.Key == "-trimpath" && setting.Value == "true" {
trimmed = true
}
}
if !trimmed {
return fmt.Errorf("二进制文件 %s 未启用 -trimpath", name)
}
}
return nil
}
func pathPatterns(paths []string) [][]byte {
var patterns [][]byte
seen := make(map[string]bool)
for _, path := range paths {
if strings.TrimSpace(path) == "" {
continue
}
slash := strings.ReplaceAll(path, `\`, "/")
backslash := strings.ReplaceAll(slash, "/", `\`)
for _, variant := range []string{slash, backslash, strings.ReplaceAll(backslash, `\`, `\\`), strings.ReplaceAll(slash, "/", `\/`)} {
utf8Pattern := []byte(variant)
lowerASCII(utf8Pattern)
if seen[string(utf8Pattern)] {
continue
}
seen[string(utf8Pattern)] = true
patterns = append(patterns, utf8Pattern)
var little, big []byte
for _, unit := range utf16.Encode([]rune(variant)) {
little = append(little, byte(unit), byte(unit>>8))
big = append(big, byte(unit>>8), byte(unit))
}
lowerASCII(little)
lowerASCII(big)
patterns = append(patterns, little, big)
}
}
return patterns
}
func scanPaths(reader io.Reader, patterns [][]byte) error {
longest := 0
for _, pattern := range patterns {
if len(pattern) > longest {
longest = len(pattern)
}
}
if longest == 0 {
return errors.New("路径检查模式不能为空")
}
const chunkSize = 64 * 1024
buffer := make([]byte, chunkSize+longest-1)
retained := 0
for {
n, err := reader.Read(buffer[retained:])
data := buffer[:retained+n]
lowerASCII(data)
for _, pattern := range patterns {
if bytes.Contains(data, pattern) {
return errors.New("发现本机构建路径,拒绝发布")
}
}
if err == io.EOF {
return nil
}
if err != nil {
return err
}
// 保留跨读取边界的前缀,避免路径被分块后漏检。
retained = min(longest-1, len(data))
copy(buffer, data[len(data)-retained:])
}
}
func lowerASCII(data []byte) {
for i, value := range data {
if value >= 'A' && value <= 'Z' {
data[i] = value + ('a' - 'A')
}
}
}
@@ -0,0 +1,154 @@
package releasearchive
import (
"bytes"
"errors"
"io"
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
"testing"
"unicode/utf16"
)
func TestScanPathsRejectsEncodedLocalPaths(t *testing.T) {
const local = `D:\Workspace\Scert`
for name, value := range map[string]string{
"native": local + `\backend\main.go`,
"forward": `d:/workspace/scert/backend/main.go`,
"json": `D:\\Workspace\\Scert\\backend\\main.go`,
"json_forward": `D:\/Workspace\/Scert\/backend\/main.go`,
} {
t.Run(name, func(t *testing.T) {
if err := scanPaths(strings.NewReader(value), pathPatterns([]string{local})); err == nil {
t.Fatal("未拒绝本机路径")
}
})
}
for name, bigEndian := range map[string]bool{"utf16le": false, "utf16be": true} {
t.Run(name, func(t *testing.T) {
const unicodePath = `C:\用户\构建`
var data []byte
for _, unit := range utf16.Encode([]rune(unicodePath)) {
if bigEndian {
data = append(data, byte(unit>>8), byte(unit))
} else {
data = append(data, byte(unit), byte(unit>>8))
}
}
if err := scanPaths(bytes.NewReader(data), pathPatterns([]string{unicodePath})); err == nil {
t.Fatal("未拒绝 UTF-16 本机路径")
}
})
}
}
func TestScanPathsRejectsPathsAcrossReadBoundary(t *testing.T) {
reader := io.MultiReader(strings.NewReader("prefix C:/Use"), strings.NewReader("rs/build-user/project/main.go"))
if err := scanPaths(reader, pathPatterns([]string{`C:\Users\build-user`})); err == nil {
t.Fatal("读取边界上的本机路径被漏检")
}
}
func TestScanPathsAllowsModuleAndRuntimePaths(t *testing.T) {
data := "git.pcux.cn/xuans/Scert/backend@v1.0.0/cmd/scert/main.go\x00/scert/conf/scert.json\x00/etc/nginx/nginx.conf\x00PATH=/usr/sbin:/usr/bin:/sbin:/bin"
if err := scanPaths(strings.NewReader(data), pathPatterns([]string{`D:\Workspace`, `C:\Users\builder`})); err != nil {
t.Fatalf("模块路径或部署路径被误拒绝:%v", err)
}
}
type brokenReader struct{}
func (brokenReader) Read([]byte) (int, error) { return 0, errors.New("读取失败") }
func TestScanPathsPropagatesReadError(t *testing.T) {
if err := scanPaths(brokenReader{}, pathPatterns([]string{`C:\Users\builder`})); err == nil {
t.Fatal("读取失败必须阻止发布")
}
}
func TestVerifyRequiresTrimpathBuildSetting(t *testing.T) {
for _, trimpath := range []bool{false, true} {
name := "untrimmed"
if trimpath {
name = "trimmed"
}
t.Run(name, func(t *testing.T) {
source := t.TempDir()
mainPath := filepath.Join(t.TempDir(), "main.go")
if err := os.WriteFile(mainPath, []byte("package main\nfunc main() {}\n"), 0o600); err != nil {
t.Fatal(err)
}
binary := "fixture"
if runtime.GOOS == "windows" {
binary += ".exe"
}
flag := "-trimpath=false"
if trimpath {
flag = "-trimpath=true"
}
command := exec.Command("go", "build", flag, "-buildvcs=false", "-o", filepath.Join(source, binary), mainPath)
command.Env = append(os.Environ(), "GOFLAGS=", "CGO_ENABLED=0", "GOOS="+runtime.GOOS, "GOARCH="+runtime.GOARCH)
if output, err := command.CombinedOutput(); err != nil {
t.Fatalf("构建路径检查夹具失败:%v\n%s", err, output)
}
err := Verify(source, []string{binary}, []string{"unused-build-root-298e4699"})
if trimpath && err != nil {
t.Fatalf("裁剪产物检查失败:%v", err)
}
if !trimpath && (err == nil || !strings.Contains(err.Error(), "-trimpath")) {
t.Fatalf("未拒绝缺少路径裁剪的构建:%v", err)
}
if trimpath {
if err := Verify(source, []string{binary}, []string{filepath.Dir(mainPath)}); err != nil {
t.Fatalf("裁剪构建仍有源目录残留:%v", err)
}
}
})
}
}
func TestVerifyChecksStaticAssetsAndRejectsInvalidInputs(t *testing.T) {
source := t.TempDir()
if err := os.WriteFile(filepath.Join(source, "app.js"), []byte(`const path="C:\\Users\\builder\\src";`), 0o600); err != nil {
t.Fatal(err)
}
if err := Verify(source, []string{"missing"}, []string{`C:\Users\builder`}); err == nil || !strings.Contains(err.Error(), "本机构建路径") {
t.Fatalf("静态文件路径残留未被拒绝:%v", err)
}
for name, test := range map[string]struct {
binaries []string
paths []string
}{
"empty_binaries": {},
"empty_paths": {binaries: []string{"missing"}},
"blank_paths": {binaries: []string{"missing"}, paths: []string{" "}},
"outside": {binaries: []string{"../outside"}, paths: []string{"unused-local-root"}},
"missing": {binaries: []string{"missing"}, paths: []string{"unused-local-root"}},
} {
t.Run(name, func(t *testing.T) {
if err := Verify(source, test.binaries, test.paths); err == nil {
t.Fatal("无效发布检查输入未被拒绝")
}
})
}
}
func TestReleaseScriptUsesPathChecksAndIncludesLinuxHelper(t *testing.T) {
data, err := os.ReadFile(filepath.Join("..", "..", "..", "build", "build-release.ps1"))
if err != nil {
t.Fatal(err)
}
for _, required := range []string{
"go build -trimpath", "wails build -trimpath", "Test-ReleasePaths -Source $targetDirectory",
`-Package "./cmd/scert-nginx"`, `$binaries += "scert-nginx"`,
`-Executable (@("install-linux.sh") + $binaries)`,
`trimpath = $true`, `local_path_check = "passed"`,
} {
if !strings.Contains(string(data), required) {
t.Errorf("发布脚本缺少必要约束:%s", required)
}
}
}