完善证书申请续期与安装初始化流程

This commit is contained in:
xuans committed 2026-08-27 00:31:40 +08:00
1 parent fd8d8608f5
commit 07636abe44
66 files changed
+9470 -165

No files matched your search

+28
View File
@@ -0,0 +1,28 @@
package firewall
import "context"
const BackendNone = "none"
type Result struct {
Backend string `json:"backend"`
RuleName string `json:"rule_name,omitempty"`
Port int `json:"port"`
Created bool `json:"created"`
Message string `json:"message"`
}
type Manager interface {
OpenTCP(ctx context.Context, port int) (Result, error)
Rollback(ctx context.Context, result Result) error
}
type CommandResult struct {
Output []byte
ExitCode int
}
type Runner interface {
LookPath(name string) (string, error)
Run(ctx context.Context, name string, args ...string) (CommandResult, error)
}
+143
View File
@@ -0,0 +1,143 @@
package firewall
import (
"context"
"fmt"
"strconv"
"strings"
)
func (m *manager) openLinux(ctx context.Context, port int) (Result, error) {
ufw, ufwErr := m.runner.LookPath("ufw")
if ufwErr == nil {
status, err := m.runner.Run(ctx, ufw, "status")
if err != nil || status.ExitCode != 0 {
return Result{}, commandError("检查 UFW 状态", ufw, status, err)
}
if ufwIsActive(status.Output) {
return m.openUFW(ctx, ufw, port, status.Output)
}
}
firewallCMD, firewalldErr := m.runner.LookPath("firewall-cmd")
if firewalldErr == nil {
state, err := m.runner.Run(ctx, firewallCMD, "--state")
if err != nil {
return Result{}, commandError("检查 firewalld 状态", firewallCMD, state, err)
}
if state.ExitCode == 0 && strings.TrimSpace(strings.ToLower(string(state.Output))) == "running" {
return m.openFirewalld(ctx, firewallCMD, port)
}
if state.ExitCode != 0 && state.ExitCode != 252 && !strings.Contains(strings.ToLower(string(state.Output)), "not running") {
return Result{}, commandError("检查 firewalld 状态", firewallCMD, state, nil)
}
}
return Result{
Backend: BackendNone, Port: port,
Message: "未检测到已启用的 UFW 或 firewalld,无需创建主服务端口入站规则",
}, nil
}
func (m *manager) openUFW(ctx context.Context, executable string, port int, statusOutput []byte) (Result, error) {
name := ruleName(port)
if ufwHasRule(statusOutput, port) {
return Result{
Backend: backendUFW, RuleName: name, Port: port,
Message: fmt.Sprintf("UFW 已放行主服务 TCP 端口 %d", port),
}, nil
}
rule := strconv.Itoa(port) + "/tcp"
added, err := m.runner.Run(ctx, executable, "allow", rule, "comment", name)
if err != nil || added.ExitCode != 0 {
return Result{}, commandError("创建 UFW 入站规则", executable, added, err)
}
return Result{
Backend: backendUFW, RuleName: name, Port: port, Created: true,
Message: fmt.Sprintf("已通过 UFW 放行主服务 TCP 端口 %d", port),
}, nil
}
func (m *manager) rollbackUFW(ctx context.Context, result Result) error {
executable, err := m.runner.LookPath("ufw")
if err != nil {
return fmt.Errorf("未找到 UFW,无法回滚防火墙规则:%w", err)
}
rule := strconv.Itoa(result.Port) + "/tcp"
removed, err := m.runner.Run(ctx, executable, "--force", "delete", "allow", rule)
if err != nil || removed.ExitCode != 0 {
return commandError("回滚 UFW 入站规则", executable, removed, err)
}
return nil
}
func (m *manager) openFirewalld(ctx context.Context, executable string, port int) (Result, error) {
name := ruleName(port)
rule := strconv.Itoa(port) + "/tcp"
query, err := m.runner.Run(ctx, executable, "--permanent", "--query-port="+rule)
if err != nil {
return Result{}, commandError("检查 firewalld 规则", executable, query, err)
}
if query.ExitCode == 0 {
return Result{
Backend: backendFirewalld, RuleName: name, Port: port,
Message: fmt.Sprintf("firewalld 已放行主服务 TCP 端口 %d", port),
}, nil
}
if query.ExitCode != 1 {
return Result{}, commandError("检查 firewalld 规则", executable, query, nil)
}
added, err := m.runner.Run(ctx, executable, "--permanent", "--add-port="+rule)
if err != nil || added.ExitCode != 0 {
return Result{}, commandError("创建 firewalld 永久规则", executable, added, err)
}
reloaded, err := m.runner.Run(ctx, executable, "--reload")
if err != nil || reloaded.ExitCode != 0 {
rollback, rollbackErr := m.runner.Run(ctx, executable, "--permanent", "--remove-port="+rule)
if rollbackErr == nil && rollback.ExitCode == 0 {
_, _ = m.runner.Run(ctx, executable, "--reload")
}
return Result{}, commandError("重新加载 firewalld", executable, reloaded, err)
}
return Result{
Backend: backendFirewalld, RuleName: name, Port: port, Created: true,
Message: fmt.Sprintf("已通过 firewalld 放行主服务 TCP 端口 %d", port),
}, nil
}
func (m *manager) rollbackFirewalld(ctx context.Context, result Result) error {
executable, err := m.runner.LookPath("firewall-cmd")
if err != nil {
return fmt.Errorf("未找到 firewalld,无法回滚防火墙规则:%w", err)
}
rule := strconv.Itoa(result.Port) + "/tcp"
removed, err := m.runner.Run(ctx, executable, "--permanent", "--remove-port="+rule)
if err != nil || removed.ExitCode != 0 {
return commandError("回滚 firewalld 永久规则", executable, removed, err)
}
reloaded, err := m.runner.Run(ctx, executable, "--reload")
if err != nil || reloaded.ExitCode != 0 {
return commandError("重新加载 firewalld", executable, reloaded, err)
}
return nil
}
func ufwIsActive(output []byte) bool {
for _, line := range strings.Split(strings.ToLower(string(output)), "\n") {
if strings.TrimSpace(line) == "status: active" {
return true
}
}
return false
}
func ufwHasRule(output []byte, port int) bool {
prefix := strconv.Itoa(port) + "/tcp"
for _, line := range strings.Split(strings.ToLower(string(output)), "\n") {
line = strings.TrimSpace(line)
if strings.HasPrefix(line, prefix) && strings.Contains(line, "allow") {
return true
}
}
return false
}
+112
View File
@@ -0,0 +1,112 @@
package firewall
import (
"context"
"errors"
"fmt"
"os"
"os/exec"
"runtime"
"strconv"
"strings"
)
const (
backendWindows = "windows"
backendUFW = "ufw"
backendFirewalld = "firewalld"
)
type manager struct {
goos string
runner Runner
}
type execRunner struct{}
func NewManager() Manager {
return NewManagerForOS(runtime.GOOS, execRunner{})
}
func NewManagerForOS(goos string, runner Runner) Manager {
if runner == nil {
runner = execRunner{}
}
return &manager{goos: strings.ToLower(strings.TrimSpace(goos)), runner: runner}
}
func (execRunner) LookPath(name string) (string, error) {
return exec.LookPath(name)
}
func (execRunner) Run(ctx context.Context, name string, args ...string) (CommandResult, error) {
command := exec.CommandContext(ctx, name, args...)
command.Env = append(os.Environ(), "LC_ALL=C", "LANG=C")
output, err := command.CombinedOutput()
if err == nil {
return CommandResult{Output: output, ExitCode: 0}, nil
}
var exitErr *exec.ExitError
if errors.As(err, &exitErr) {
return CommandResult{Output: output, ExitCode: exitErr.ExitCode()}, nil
}
return CommandResult{Output: output, ExitCode: -1}, err
}
func (m *manager) OpenTCP(ctx context.Context, port int) (Result, error) {
if err := validatePort(port); err != nil {
return Result{}, err
}
switch m.goos {
case "windows":
return m.openWindows(ctx, port)
case "linux":
return m.openLinux(ctx, port)
default:
return Result{
Backend: BackendNone, Port: port,
Message: fmt.Sprintf("当前操作系统 %s 不在自动防火墙配置范围内,已跳过本机规则创建", m.goos),
}, nil
}
}
func (m *manager) Rollback(ctx context.Context, result Result) error {
if !result.Created {
return nil
}
if err := validatePort(result.Port); err != nil {
return err
}
switch result.Backend {
case backendWindows:
return m.rollbackWindows(ctx, result)
case backendUFW:
return m.rollbackUFW(ctx, result)
case backendFirewalld:
return m.rollbackFirewalld(ctx, result)
default:
return fmt.Errorf("无法回滚未知防火墙后端:%s", result.Backend)
}
}
func validatePort(port int) error {
if port < 1 || port > 65535 {
return fmt.Errorf("防火墙端口无效:%d", port)
}
return nil
}
func ruleName(port int) string {
return "Scert Web TCP " + strconv.Itoa(port)
}
func commandError(action, name string, result CommandResult, err error) error {
if err != nil {
return fmt.Errorf("%s失败,无法执行 %s:%w", action, name, err)
}
message := strings.TrimSpace(string(result.Output))
if message == "" {
message = fmt.Sprintf("退出码 %d", result.ExitCode)
}
return fmt.Errorf("%s失败:%s", action, message)
}
+205
View File
@@ -0,0 +1,205 @@
package firewall
import (
"context"
"errors"
"reflect"
"testing"
)
type runnerCall struct {
name string
args []string
}
type runnerResponse struct {
result CommandResult
err error
}
type fakeRunner struct {
paths map[string]string
responses []runnerResponse
calls []runnerCall
}
func (f *fakeRunner) LookPath(name string) (string, error) {
path, ok := f.paths[name]
if !ok {
return "", errors.New("not found")
}
return path, nil
}
func (f *fakeRunner) Run(_ context.Context, name string, args ...string) (CommandResult, error) {
f.calls = append(f.calls, runnerCall{name: name, args: append([]string(nil), args...)})
if len(f.responses) == 0 {
return CommandResult{}, errors.New("unexpected command")
}
response := f.responses[0]
f.responses = f.responses[1:]
return response.result, response.err
}
func TestOpenTCPRejectsInvalidPortBeforeRunningCommand(t *testing.T) {
runner := &fakeRunner{}
manager := NewManagerForOS("windows", runner)
if _, err := manager.OpenTCP(context.Background(), 0); err == nil {
t.Fatal("无效端口应被拒绝")
}
if len(runner.calls) != 0 {
t.Fatalf("无效端口不应执行系统命令:%+v", runner.calls)
}
}
func TestWindowsCreatesIdempotentRuleAndRollsBackOwnChange(t *testing.T) {
runner := &fakeRunner{
paths: map[string]string{"powershell.exe": `C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe`},
responses: []runnerResponse{
{result: CommandResult{Output: []byte("enabled\n")}},
{result: CommandResult{ExitCode: 3}},
{result: CommandResult{}},
{result: CommandResult{}},
},
}
manager := NewManagerForOS("windows", runner)
result, err := manager.OpenTCP(context.Background(), 8443)
if err != nil {
t.Fatalf("创建 Windows 防火墙规则失败:%v", err)
}
if !result.Created || result.Backend != backendWindows || result.RuleName != "Scert Web TCP 8443" {
t.Fatalf("Windows 防火墙结果不正确:%+v", result)
}
addArgs := runner.calls[2].args
if got := addArgs[len(addArgs)-2:]; !reflect.DeepEqual(got, []string{"Scert Web TCP 8443", "8443"}) {
t.Fatalf("端口和规则名称必须通过独立参数传递:%v", addArgs)
}
if err := manager.Rollback(context.Background(), result); err != nil {
t.Fatalf("回滚 Windows 防火墙规则失败:%v", err)
}
removeArgs := runner.calls[3].args
if removeArgs[len(removeArgs)-1] != result.RuleName {
t.Fatalf("回滚规则名称不正确:%v", removeArgs)
}
}
func TestWindowsSkipsRuleWhenFirewallIsDisabled(t *testing.T) {
runner := &fakeRunner{
paths: map[string]string{"powershell.exe": "powershell.exe"},
responses: []runnerResponse{{result: CommandResult{Output: []byte("disabled\n")}}},
}
result, err := NewManagerForOS("windows", runner).OpenTCP(context.Background(), 443)
if err != nil {
t.Fatalf("检查 Windows 防火墙失败:%v", err)
}
if result.Created || result.Backend != BackendNone || len(runner.calls) != 1 {
t.Fatalf("Windows 防火墙未启用时不应创建规则:%+v calls=%+v", result, runner.calls)
}
}
func TestUFWCreatesRuleAndRollbackUsesExactPortArgument(t *testing.T) {
runner := &fakeRunner{
paths: map[string]string{"ufw": "/usr/sbin/ufw"},
responses: []runnerResponse{
{result: CommandResult{Output: []byte("Status: active\n")}},
{result: CommandResult{}},
{result: CommandResult{}},
},
}
manager := NewManagerForOS("linux", runner)
result, err := manager.OpenTCP(context.Background(), 8443)
if err != nil {
t.Fatalf("创建 UFW 规则失败:%v", err)
}
if !result.Created || result.Backend != backendUFW {
t.Fatalf("UFW 结果不正确:%+v", result)
}
if got := runner.calls[1].args; !reflect.DeepEqual(got, []string{"allow", "8443/tcp", "comment", "Scert Web TCP 8443"}) {
t.Fatalf("UFW 创建参数不正确:%v", got)
}
if err := manager.Rollback(context.Background(), result); err != nil {
t.Fatalf("回滚 UFW 规则失败:%v", err)
}
if got := runner.calls[2].args; !reflect.DeepEqual(got, []string{"--force", "delete", "allow", "8443/tcp"}) {
t.Fatalf("UFW 回滚参数不正确:%v", got)
}
}
func TestUFWKeepsExistingRule(t *testing.T) {
runner := &fakeRunner{
paths: map[string]string{"ufw": "/usr/sbin/ufw"},
responses: []runnerResponse{{result: CommandResult{Output: []byte("Status: active\n8443/tcp ALLOW Anywhere\n")}}},
}
result, err := NewManagerForOS("linux", runner).OpenTCP(context.Background(), 8443)
if err != nil {
t.Fatalf("检查 UFW 规则失败:%v", err)
}
if result.Created || result.Backend != backendUFW || len(runner.calls) != 1 {
t.Fatalf("已有 UFW 规则不应重复创建:%+v calls=%+v", result, runner.calls)
}
}
func TestFirewalldCreatesPermanentRuleAndReloads(t *testing.T) {
runner := &fakeRunner{
paths: map[string]string{"firewall-cmd": "/usr/bin/firewall-cmd"},
responses: []runnerResponse{
{result: CommandResult{Output: []byte("running\n")}},
{result: CommandResult{ExitCode: 1}},
{result: CommandResult{}},
{result: CommandResult{}},
{result: CommandResult{}},
{result: CommandResult{}},
},
}
manager := NewManagerForOS("linux", runner)
result, err := manager.OpenTCP(context.Background(), 9443)
if err != nil {
t.Fatalf("创建 firewalld 规则失败:%v", err)
}
if !result.Created || result.Backend != backendFirewalld {
t.Fatalf("firewalld 结果不正确:%+v", result)
}
if got := runner.calls[2].args; !reflect.DeepEqual(got, []string{"--permanent", "--add-port=9443/tcp"}) {
t.Fatalf("firewalld 创建参数不正确:%v", got)
}
if err := manager.Rollback(context.Background(), result); err != nil {
t.Fatalf("回滚 firewalld 规则失败:%v", err)
}
if got := runner.calls[4].args; !reflect.DeepEqual(got, []string{"--permanent", "--remove-port=9443/tcp"}) {
t.Fatalf("firewalld 回滚参数不正确:%v", got)
}
}
func TestFirewalldReloadFailureRemovesNewPermanentRule(t *testing.T) {
runner := &fakeRunner{
paths: map[string]string{"firewall-cmd": "/usr/bin/firewall-cmd"},
responses: []runnerResponse{
{result: CommandResult{Output: []byte("running\n")}},
{result: CommandResult{ExitCode: 1}},
{result: CommandResult{}},
{result: CommandResult{Output: []byte("reload failed"), ExitCode: 2}},
{result: CommandResult{}},
{result: CommandResult{}},
},
}
_, err := NewManagerForOS("linux", runner).OpenTCP(context.Background(), 9443)
if err == nil {
t.Fatal("firewalld 重新加载失败时初始化应失败")
}
if got := runner.calls[4].args; !reflect.DeepEqual(got, []string{"--permanent", "--remove-port=9443/tcp"}) {
t.Fatalf("重新加载失败时应移除本次新增规则:%v", got)
}
}
func TestFirewalldStatePermissionFailureIsNotReportedAsDisabled(t *testing.T) {
runner := &fakeRunner{
paths: map[string]string{"firewall-cmd": "/usr/bin/firewall-cmd"},
responses: []runnerResponse{{result: CommandResult{
Output: []byte("Authorization failed"), ExitCode: 2,
}}},
}
result, err := NewManagerForOS("linux", runner).OpenTCP(context.Background(), 8443)
if err == nil {
t.Fatalf("firewalld 权限错误不得被报告为未启用:%+v", result)
}
}
+68
View File
@@ -0,0 +1,68 @@
package firewall
import (
"context"
"fmt"
"strconv"
"strings"
)
const (
windowsStatusScript = `$ErrorActionPreference='Stop'; if ((Get-NetFirewallProfile | Where-Object { $_.Enabled }).Count -gt 0) { Write-Output 'enabled' } else { Write-Output 'disabled' }`
windowsQueryScript = `$ErrorActionPreference='Stop'; $rule=Get-NetFirewallRule -DisplayName $args[0] -ErrorAction SilentlyContinue; if ($null -eq $rule) { exit 3 }; exit 0`
windowsAddScript = `$ErrorActionPreference='Stop'; New-NetFirewallRule -DisplayName $args[0] -Direction Inbound -Action Allow -Enabled True -Profile Any -Protocol TCP -LocalPort ([int]$args[1]) | Out-Null`
windowsRemoveScript = `$ErrorActionPreference='Stop'; Remove-NetFirewallRule -DisplayName $args[0]`
)
func (m *manager) openWindows(ctx context.Context, port int) (Result, error) {
powershell, err := m.runner.LookPath("powershell.exe")
if err != nil {
return Result{}, fmt.Errorf("未找到 Windows PowerShell,无法配置本机防火墙:%w", err)
}
status, err := m.runner.Run(ctx, powershell, "-NoProfile", "-NonInteractive", "-Command", windowsStatusScript)
if err != nil || status.ExitCode != 0 {
return Result{}, commandError("检查 Windows 防火墙状态", powershell, status, err)
}
if !strings.Contains(strings.ToLower(string(status.Output)), "enabled") {
return Result{
Backend: BackendNone, Port: port,
Message: "Windows 防火墙当前未启用,无需创建主服务端口入站规则",
}, nil
}
name := ruleName(port)
query, err := m.runner.Run(ctx, powershell, "-NoProfile", "-NonInteractive", "-Command", windowsQueryScript, name)
if err != nil {
return Result{}, commandError("检查 Windows 防火墙规则", powershell, query, err)
}
if query.ExitCode == 0 {
return Result{
Backend: backendWindows, RuleName: name, Port: port,
Message: fmt.Sprintf("Windows 防火墙规则已存在:%s", name),
}, nil
}
if query.ExitCode != 3 {
return Result{}, commandError("检查 Windows 防火墙规则", powershell, query, nil)
}
added, err := m.runner.Run(ctx, powershell, "-NoProfile", "-NonInteractive", "-Command", windowsAddScript, name, strconv.Itoa(port))
if err != nil || added.ExitCode != 0 {
return Result{}, commandError("创建 Windows 防火墙入站规则", powershell, added, err)
}
return Result{
Backend: backendWindows, RuleName: name, Port: port, Created: true,
Message: fmt.Sprintf("已创建 Windows 防火墙规则:%s", name),
}, nil
}
func (m *manager) rollbackWindows(ctx context.Context, result Result) error {
powershell, err := m.runner.LookPath("powershell.exe")
if err != nil {
return fmt.Errorf("未找到 Windows PowerShell,无法回滚防火墙规则:%w", err)
}
removed, err := m.runner.Run(ctx, powershell, "-NoProfile", "-NonInteractive", "-Command", windowsRemoveScript, result.RuleName)
if err != nil || removed.ExitCode != 0 {
return commandError("回滚 Windows 防火墙规则", powershell, removed, err)
}
return nil
}