继续复审前保存初始化安全校验与链路测试检查点

This commit is contained in:
xuans committed 2026-09-16 20:06:36 +08:00
1 parent 199d727ecc
commit c6bfcfd9ae
15 files changed
+676 -23

No files matched your search

+52
View File
@@ -0,0 +1,52 @@
package bootstrap
import (
"net/http"
"net/http/httptest"
"strings"
"testing"
)
func TestBootstrapRejectsCrossOriginBeforeTokenExchange(t *testing.T) {
for _, origin := range []string{"https://attacker.example", "http://127.0.0.1:8443", "null", "https://127.0.0.1:8443/path"} {
t.Run(origin, func(t *testing.T) {
sessions, token, err := NewSessionManager()
if err != nil {
t.Fatal(err)
}
router := NewRouter(sessions, nil, nil, nil)
request := httptest.NewRequest(http.MethodPost, "https://127.0.0.1:8443/api/v1/bootstrap/session", strings.NewReader(`{"token":"`+token+`"}`))
request.Header.Set("Origin", origin)
response := httptest.NewRecorder()
router.ServeHTTP(response, request)
if response.Code != http.StatusForbidden {
t.Fatalf("跨源写入未拒绝:%d", response.Code)
}
if _, err := sessions.Exchange(token, "127.0.0.1"); err != nil {
t.Fatalf("被拒绝的请求消耗了令牌:%v", err)
}
})
}
}
func TestBootstrapSameOriginPolicy(t *testing.T) {
for _, item := range []struct {
origin string
site string
allowed bool
}{
{"https://127.0.0.1:8443", "same-origin", true},
{"", "", true},
{"", "cross-site", false},
{"https://127.0.0.1:8443", "same-site", false},
{"https://user@127.0.0.1:8443", "", false},
} {
request := httptest.NewRequest(http.MethodPost, "https://127.0.0.1:8443/", nil)
request.Header.Set("Origin", item.origin)
request.Header.Set("Sec-Fetch-Site", item.site)
request.Header.Set("X-Forwarded-Host", "attacker.example")
if bootstrapSameOrigin(request) != item.allowed {
t.Fatalf("来源策略不符:%+v", item)
}
}
}
+20
View File
@@ -8,6 +8,7 @@ import (
"io"
"mime"
"net/http"
"net/url"
"strings"
"sync"
"time"
@@ -70,6 +71,10 @@ func (router *Router) ServeHTTP(writer http.ResponseWriter, request *http.Reques
writeBootstrapError(writer, http.StatusBadRequest, "请求无效")
return
}
if request.Method != http.MethodGet && request.Method != http.MethodHead && !bootstrapSameOrigin(request) {
writeBootstrapError(writer, http.StatusForbidden, "初始化写入请求必须来自当前管理页面")
return
}
switch request.URL.Path {
case "/api/v1/bootstrap/status":
if !requireBootstrapMethod(writer, request, http.MethodGet) {
@@ -366,6 +371,21 @@ func requireBootstrapMethod(writer http.ResponseWriter, request *http.Request, m
return false
}
// 不信任转发头;同站子域也不能向初始化服务提交写入请求。
func bootstrapSameOrigin(request *http.Request) bool {
if site := request.Header.Get("Sec-Fetch-Site"); site != "" && site != "same-origin" && site != "none" {
return false
}
origin := request.Header.Get("Origin")
if origin == "" {
return true
}
parsed, err := url.Parse(origin)
return err == nil && parsed.Scheme == "https" && parsed.User == nil &&
parsed.Path == "" && parsed.RawQuery == "" && parsed.Fragment == "" &&
strings.EqualFold(parsed.Host, request.Host)
}
func setBootstrapSecurityHeaders(writer http.ResponseWriter) {
writer.Header().Set("Cache-Control", "no-store")
writer.Header().Set("Referrer-Policy", "no-referrer")
@@ -0,0 +1,261 @@
package bootstrap
import (
"bytes"
"context"
"crypto/tls"
"crypto/x509"
"encoding/json"
"errors"
"io"
"net"
"net/http"
"net/http/cookiejar"
"net/url"
"os"
"path/filepath"
"strings"
"testing"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/app"
"git.pcux.cn/xuans/Scert/backend/internal/config"
"git.pcux.cn/xuans/Scert/backend/internal/secretstore"
"git.pcux.cn/xuans/Scert/backend/internal/setup"
)
func TestHTTPSBootstrapCompletesSQLiteAndStartsApplication(t *testing.T) {
fixture := newCompletionFixture(t, "authorized.example.test")
store, err := secretstore.Open(fixture.base.Paths.Config)
if err != nil {
t.Fatal(err)
}
databases := NewDatabaseVerificationManager(fixture.base, store)
dns := setup.NewDNSVerificationManager(completionDNSTester{}, store)
sessions, token, err := NewSessionManager()
if err != nil {
t.Fatal(err)
}
completer := NewCompleter(CompleteDependencies{
BaseConfig: fixture.base, ConfigPath: fixture.configPath,
DatabaseSessions: databases, DNSSessions: dns, Credentials: store,
Sessions: sessions, Firewall: fixture.firewall, Certificate: fixture.issuer,
})
router := NewRouter(sessions, databases, dns, completer)
handler, closeFiles := bootstrapHandler(router, fixture.base)
defer closeFiles()
material, err := NewTemporaryTLSMaterial("127.0.0.1")
if err != nil {
t.Fatal(err)
}
listener, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
address := listener.Addr().String()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
result := make(chan error, 1)
go func() {
ok, err := serveTemporaryHTTPS(ctx, listener, material, handler, router.Completed())
if err == nil && !ok {
err = errors.New("初始化未完成")
}
result <- err
}()
roots := x509.NewCertPool()
roots.AddCert(material.Leaf)
transport := &http.Transport{TLSClientConfig: &tls.Config{MinVersion: tls.VersionTLS12, RootCAs: roots}}
defer transport.CloseIdleConnections()
jar, err := cookiejar.New(nil)
if err != nil {
t.Fatal(err)
}
client := &http.Client{Transport: transport, Jar: jar, Timeout: 10 * time.Second}
origin := "https://" + address
post := func(path string, input any, output any) {
t.Helper()
body, err := json.Marshal(input)
if err != nil {
t.Fatal(err)
}
request, err := http.NewRequest(http.MethodPost, origin+path, bytes.NewReader(body))
if err != nil {
t.Fatal(err)
}
request.Header.Set("Content-Type", "application/json")
request.Header.Set("Origin", origin)
response, err := client.Do(request)
if err != nil {
t.Fatal(err)
}
defer response.Body.Close()
data, err := io.ReadAll(response.Body)
if err != nil || response.StatusCode != http.StatusOK {
t.Fatalf("初始化步骤 %s 失败:状态 %d,读取错误 %v", path, response.StatusCode, err)
}
if err := json.Unmarshal(data, output); err != nil {
t.Fatal(err)
}
}
var authenticated map[string]any
post("/api/v1/bootstrap/session", map[string]string{"token": token}, &authenticated)
var databaseResult, dnsResult struct {
Token string `json:"verification_token"`
}
post("/api/v1/bootstrap/database/test", DatabaseInput{Driver: "sqlite"}, &databaseResult)
post("/api/v1/bootstrap/dns/test", bootstrapDNSTestRequest{
Provider: "aliyun", TestDomain: "authorized.example.test",
Credentials: map[string]string{"access_key_id": "test-id", "access_key_secret": "test-secret"},
}, &dnsResult)
input := fixture.request("")
input.WebPublicIP = "203.0.113.20"
input.ServerPort = listener.Addr().(*net.TCPAddr).Port
input.DatabaseVerificationToken = databaseResult.Token
input.DNSVerificationToken = dnsResult.Token
var completed CompleteResult
post("/api/v1/bootstrap/complete", input, &completed)
if !completed.Completed || completed.ManagementURL != "https://"+net.JoinHostPort(input.WebPublicIP, strings.Split(address, ":")[1])+"/" {
t.Fatal("初始化未返回正确管理地址")
}
select {
case err := <-result:
if err != nil {
t.Fatal(err)
}
case <-time.After(5 * time.Second):
t.Fatal("初始化服务未退出")
}
parsed, _ := url.Parse(origin)
if len(jar.Cookies(parsed)) != 0 {
t.Fatal("完成响应未清除初始化会话")
}
// 清理未领取凭据不能删除已提交配置持有的凭据。
databases.DiscardAllExcept()
dns.DiscardAll()
stored, err := config.Load(fixture.configPath)
if err != nil {
t.Fatal(err)
}
stored.Server.Host = "127.0.0.1"
application, err := app.NewWithConfigPath(ctx, stored, fixture.configPath)
if err != nil {
t.Fatal(err)
}
applicationResult := make(chan error, 1)
go func() { applicationResult <- application.HTTP.ListenAndServe() }()
// 正式 IP 证书与临时证书不同,只信任本次生成的正式证书。
certificatePEM, err := os.ReadFile(stored.Server.TLSCert)
if err != nil {
t.Fatal(err)
}
formalRoots := x509.NewCertPool()
if !formalRoots.AppendCertsFromPEM(certificatePEM) {
t.Fatal("正式管理证书无法解析")
}
// 仅连接回环套接字,证书身份仍按配置中的文档示例公网 IP 完整校验。
formalTransport := &http.Transport{TLSClientConfig: &tls.Config{
MinVersion: tls.VersionTLS12, RootCAs: formalRoots, ServerName: input.WebPublicIP,
}}
defer formalTransport.CloseIdleConnections()
formalClient := &http.Client{Transport: formalTransport, Timeout: time.Second}
deadline := time.Now().Add(5 * time.Second)
for {
response, err := formalClient.Get(origin + "/healthz")
if err == nil {
response.Body.Close()
if response.StatusCode != http.StatusOK {
t.Fatal("正式服务健康检查失败")
}
break
}
if time.Now().After(deadline) {
t.Fatalf("正式 HTTPS 未就绪:%v", err)
}
time.Sleep(10 * time.Millisecond)
}
defer application.Close()
for path, expected := range map[string]int{
"/api/v1/bootstrap/status": http.StatusNotFound,
"/api/v1/bootstrap/settings": http.StatusNotFound,
"/api/v1/auth/session": http.StatusUnauthorized,
} {
response, err := formalClient.Get(origin + path)
if err != nil {
t.Fatal(err)
}
response.Body.Close()
if response.StatusCode != expected {
t.Fatalf("切换后 %s 状态错误:%d", path, response.StatusCode)
}
}
if err := application.Close(); err != nil {
t.Fatal(err)
}
select {
case err := <-applicationResult:
if !errors.Is(err, http.ErrServerClosed) {
t.Fatalf("正式服务关闭错误:%v", err)
}
case <-time.After(5 * time.Second):
t.Fatal("正式服务关闭超时")
}
}
func TestBootstrapRunCancellationRemovesURLWithoutCreatingBusinessDatabase(t *testing.T) {
fixture := newCompletionFixture(t, "authorized.example.test")
listener, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
fixture.base.Server.Host = "127.0.0.1"
fixture.base.Server.Port = listener.Addr().(*net.TCPAddr).Port
listener.Close()
var output bytes.Buffer
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
result := make(chan error, 1)
go func() {
ok, err := Run(ctx, ServerOptions{
Config: fixture.base, ConfigPath: fixture.configPath,
PublicIP: "127.0.0.1", URLPath: fixture.urlPath, Output: &output,
})
if ok {
err = errors.New("取消操作误报初始化完成")
}
result <- err
}()
deadline := time.Now().Add(5 * time.Second)
var address []byte
for {
address, err = os.ReadFile(fixture.urlPath)
if err == nil {
break
}
if time.Now().After(deadline) {
t.Fatal("初始化地址文件没有生成")
}
time.Sleep(10 * time.Millisecond)
}
cancel()
select {
case err := <-result:
if err != nil {
t.Fatal(err)
}
case <-time.After(5 * time.Second):
t.Fatal("取消后初始化未退出")
}
parsed, err := url.Parse(strings.TrimSpace(string(address)))
if err != nil {
t.Fatal(err)
}
if parsed.Fragment == "" || strings.Contains(output.String(), parsed.Fragment) {
t.Fatal("一次性令牌缺失或泄露到日志")
}
for _, path := range []string{fixture.urlPath, fixture.configPath, filepath.Join(fixture.base.Paths.Data, "scert.db")} {
if _, err := os.Stat(path); !errors.Is(err, os.ErrNotExist) {
t.Fatalf("取消后不应保留初始化地址或提前产生正式文件:%s", path)
}
}
}
+10 -4
View File
@@ -204,18 +204,24 @@ func WriteBootstrapURL(path, value string) error {
return fmt.Errorf("检查 Bootstrap 地址文件失败:%w", err)
}
temporary, err := os.CreateTemp(directory, ".bootstrap-url-")
if err != nil { return fmt.Errorf("创建 Bootstrap 临时地址文件失败:%w", err) }
if err != nil {
return fmt.Errorf("创建 Bootstrap 临时地址文件失败:%w", err)
}
temporaryPath := temporary.Name()
defer os.Remove(temporaryPath)
defer temporary.Close()
if _, err := temporary.WriteString(value+"\n"); err != nil {
if _, err := temporary.WriteString(value + "\n"); err != nil {
return fmt.Errorf("写入 Bootstrap 临时地址文件失败:%w", err)
}
if err := temporary.Chmod(0o600); err != nil {
return fmt.Errorf("设置 Bootstrap 临时地址文件权限失败:%w", err)
}
if err := temporary.Sync(); err != nil { return fmt.Errorf("同步 Bootstrap 地址文件失败:%w", err) }
if err := temporary.Close(); err != nil { return fmt.Errorf("关闭 Bootstrap 地址文件失败:%w", err) }
if err := temporary.Sync(); err != nil {
return fmt.Errorf("同步 Bootstrap 地址文件失败:%w", err)
}
if err := temporary.Close(); err != nil {
return fmt.Errorf("关闭 Bootstrap 地址文件失败:%w", err)
}
if err := os.Rename(temporaryPath, path); err != nil {
_ = os.Remove(temporaryPath)
return fmt.Errorf("替换 Bootstrap 地址文件失败:%w", err)