迁移测试并禁止私钥认证

This commit is contained in:
xuans committed 2026-10-02 03:12:33 +08:00
1 parent 48fc5eb395
commit e6478ab303
18 files changed
+160 -475

No files matched your search

@@ -128,7 +128,6 @@ func TestAdminAPIRequiresSetupBeforeAccessingManagementHandlers(t *testing.T) {
"/api/v1/tasks",
"/api/v1/audit-logs",
"/api/v1/certificates",
"/api/v1/ssh-keys",
}
for _, path := range paths {
t.Run(path, func(t *testing.T) {
@@ -45,7 +45,7 @@ func newProjectResourceAPIFixture(t *testing.T) (projectMemberAPIFixture, *resou
server := deployment.Server{
ResourceScope: domain.ResourceScope{ProjectID: item.ProjectID},
ID: "server-" + suffix, Name: suffix + " 服务器", Address: "192.0.2.10", Port: 22, Username: "deploy",
PrivateKeyRef: "secret://ssh/fixture", HostKeyFingerprint: "SHA256:test",
AuthMethod: deployment.SSHAuthPassword, PasswordRef: "secret://ssh/password/fixture", HostKeyFingerprint: "SHA256:test",
CertificatePath: "/ssl/cert.pem", PrivateKeyPath: "/ssl/key.pem", WebServer: deployment.WebServerNginx,
}
if err := servers.CreateServer(t.Context(), server); err != nil {
+7 -18
View File
@@ -23,7 +23,6 @@ import (
"git.pcux.cn/xuans/Scert/backend/internal/logging"
"git.pcux.cn/xuans/Scert/backend/internal/repository"
"git.pcux.cn/xuans/Scert/backend/internal/secretstore"
"git.pcux.cn/xuans/Scert/backend/internal/sshkey"
)
func TestHealthAndDomainAPI(t *testing.T) {
@@ -303,16 +302,11 @@ func TestServerAndDomainAssociationAPI(t *testing.T) {
}
secretStore, err := secretstore.Open(filepath.Join(dir, "config"))
if err != nil {
t.Fatalf("打开敏感信息存储失败:%v", err)
}
sshKeys := sshkey.NewService(secretStore)
key, err := sshKeys.Create(t.Context(), "测试部署私钥", testSSHPrivateKey(t), "")
if err != nil {
t.Fatalf("创建测试 SSH 私钥失败:%v", err)
t.Fatalf("open secret store failed: %v", err)
}
server := New(Dependencies{
Config: cfg, Repository: repository.NewSQLDomainRepository(db.DB),
Servers: repository.NewSQLServerRepository(db.DB), SSHKeys: sshKeys,
Servers: repository.NewSQLServerRepository(db.DB), Secrets: secretStore,
Users: repository.NewSQLUserRepository(db.DB),
ProjectResources: repository.NewSQLProjectMemberRepository(db.DB),
ProjectBindings: repository.NewSQLProjectMemberRepository(db.DB),
@@ -341,7 +335,7 @@ func TestServerAndDomainAssociationAPI(t *testing.T) {
t.Fatalf("测试域名响应无效:%v %s", err, domainResponse.Body.String())
}
serverRequest := httptest.NewRequest(http.MethodPost, "/api/v1/servers", strings.NewReader(`{"name":"测试服务器","address":"192.0.2.50","port":22,"username":"deploy","private_key_ref":"`+key.Reference+`","host_key_fingerprint":"SHA256:test","web_server":"nginx"}`))
serverRequest := httptest.NewRequest(http.MethodPost, "/api/v1/servers", strings.NewReader(`{"name":"测试服务器","address":"192.0.2.50","port":22,"username":"deploy","password":"test-password","host_key_fingerprint":"SHA256:test","web_server":"nginx"}`))
serverRequest.Header.Set("Content-Type", "application/json")
serverResponse := httptest.NewRecorder()
serveAdminHTTP(server, serverResponse, serverRequest)
@@ -362,7 +356,7 @@ func TestServerAndDomainAssociationAPI(t *testing.T) {
if created.ProjectID != "default" || created.OwnerID != "test-admin" || created.CreatedBy != "test-admin" || created.UpdatedBy != "test-admin" {
t.Fatalf("服务器未记录服务端会话归属:%+v", created.ResourceScope)
}
updateRequest := httptest.NewRequest(http.MethodPut, "/api/v1/servers/"+created.ID, strings.NewReader(`{"name":"updated-server","address":"192.0.2.50","port":22,"username":"deploy","private_key_ref":"`+key.Reference+`","host_key_fingerprint":"SHA256:test","web_server":"nginx"}`))
updateRequest := httptest.NewRequest(http.MethodPut, "/api/v1/servers/"+created.ID, strings.NewReader(`{"name":"updated-server","address":"192.0.2.50","port":22,"username":"deploy","password":"test-password","host_key_fingerprint":"SHA256:test","web_server":"nginx"}`))
updateRequest.Header.Set("Content-Type", "application/json")
updateResponse := httptest.NewRecorder()
serveAdminHTTP(server, updateResponse, updateRequest)
@@ -859,19 +853,14 @@ func TestServerHostKeyChangeCreatesAuditRecord(t *testing.T) {
if err != nil {
t.Fatalf("打开敏感信息存储失败:%v", err)
}
sshKeys := sshkey.NewService(store)
key, err := sshKeys.Create(t.Context(), "审计测试私钥", testSSHPrivateKey(t), "")
if err != nil {
t.Fatalf("创建测试私钥失败:%v", err)
}
serverRepo := repository.NewSQLServerRepository(db.DB)
resourceRepo := repository.NewSQLProjectMemberRepository(db.DB)
server := New(Dependencies{
Config: cfg, Repository: repository.NewSQLDomainRepository(db.DB), Servers: serverRepo,
SSHKeys: sshKeys, Audit: repository.NewSQLAuditRepository(db.DB),
Secrets: store, Audit: repository.NewSQLAuditRepository(db.DB),
ProjectResources: resourceRepo, ProjectBindings: resourceRepo, ProjectDomains: resourceRepo,
})
createBody := `{"name":"审计测试服务器","address":"192.0.2.80","port":22,"username":"deploy","private_key_ref":"` + key.Reference + `","host_key_fingerprint":"SHA256:first","web_server":"nginx"}`
createBody := `{"name":"审计测试服务器","address":"192.0.2.80","port":22,"username":"deploy","password":"test-password","host_key_fingerprint":"SHA256:first","web_server":"nginx"}`
createRequest := httptest.NewRequest(http.MethodPost, "/api/v1/servers", strings.NewReader(createBody))
createRequest.Header.Set("Content-Type", "application/json")
createResponse := httptest.NewRecorder()
@@ -883,7 +872,7 @@ func TestServerHostKeyChangeCreatesAuditRecord(t *testing.T) {
if err := json.Unmarshal(createResponse.Body.Bytes(), &created); err != nil || created.ID == "" {
t.Fatalf("解析测试服务器响应失败:%v %s", err, createResponse.Body.String())
}
updateBody := `{"name":"审计测试服务器","address":"192.0.2.80","port":22,"username":"deploy","private_key_ref":"` + key.Reference + `","host_key_fingerprint":"SHA256:second","web_server":"nginx"}`
updateBody := `{"name":"审计测试服务器","address":"192.0.2.80","port":22,"username":"deploy","password":"test-password","host_key_fingerprint":"SHA256:second","web_server":"nginx"}`
updateRequest := httptest.NewRequest(http.MethodPut, "/api/v1/servers/"+created.ID, strings.NewReader(updateBody))
updateRequest.Header.Set("Content-Type", "application/json")
updateResponse := httptest.NewRecorder()
+6 -238
View File
@@ -1,252 +1,20 @@
package httpapi
import (
"context"
"crypto/ed25519"
"crypto/rand"
"crypto/x509"
"encoding/json"
"encoding/pem"
"net/http"
"net/http/httptest"
"path/filepath"
"strings"
"testing"
"git.pcux.cn/xuans/Scert/backend/internal/database"
"git.pcux.cn/xuans/Scert/backend/internal/repository"
"git.pcux.cn/xuans/Scert/backend/internal/secretstore"
"git.pcux.cn/xuans/Scert/backend/internal/sshkey"
)
func TestSSHKeyAPIAllowsSuperAdminProjectAuthorization(t *testing.T) {
directory := t.TempDir()
cfg := readyTestConfig(directory)
cfg.Database.DSN = filepath.Join(directory, "data", "ssh-keys-super-admin.db")
db, err := database.Open(context.Background(), cfg.Database)
if err != nil {
t.Fatalf("open database: %v", err)
}
defer db.Close()
if err := database.Migrate(context.Background(), db.DB, "sqlite"); err != nil {
t.Fatalf("migrate database: %v", err)
}
if _, err := db.DB.ExecContext(t.Context(), `INSERT INTO users (id, username, email, password_hash, role, status) VALUES ('super-admin', 'super-admin', 'super-admin@example.invalid', 'test-only-no-login', 'super_admin', 'active')`); err != nil {
t.Fatalf("create super admin: %v", err)
}
store, err := secretstore.Open(filepath.Join(directory, "config"))
if err != nil {
t.Fatalf("open secret store: %v", err)
}
func TestSSHKeyAPIIsUnavailable(t *testing.T) {
server := New(Dependencies{
Config: cfg,
Repository: repository.NewSQLDomainRepository(db.DB),
ProjectDomains: repository.NewSQLProjectMemberRepository(db.DB),
SSHKeys: sshkey.NewService(store),
Config: readyTestConfig(t.TempDir()),
Repository: &stubDomainRepository{},
})
response := httptest.NewRecorder()
request := httptest.NewRequest(http.MethodGet, "/api/v1/ssh-keys", nil)
request.AddCookie(httpUserSessionCookie(server, "super-admin", repository.UserRoleSuperAdmin))
response := httptest.NewRecorder()
server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusOK {
t.Fatalf("super admin SSH key list failed: %d %s", response.Code, response.Body.String())
if response.Code != http.StatusNotFound {
t.Fatalf("SSH private key API should not be exposed, got status %d", response.Code)
}
}
func TestSSHKeyAPIHidesPrivateKeyAndBlocksDeletingUsedReference(t *testing.T) {
directory := t.TempDir()
cfg := readyTestConfig(directory)
cfg.Database.DSN = filepath.Join(directory, "data", "ssh-keys.db")
db, err := database.Open(context.Background(), cfg.Database)
if err != nil {
t.Fatalf("打开数据库失败:%v", err)
}
defer db.Close()
if err := database.Migrate(context.Background(), db.DB, "sqlite"); err != nil {
t.Fatalf("数据库迁移失败:%v", err)
}
store, err := secretstore.Open(filepath.Join(directory, "config"))
if err != nil {
t.Fatalf("打开敏感信息存储失败:%v", err)
}
serverRepo := repository.NewSQLServerRepository(db.DB)
server := New(Dependencies{
Config: cfg, Repository: repository.NewSQLDomainRepository(db.DB), Servers: serverRepo,
SSHKeys: sshkey.NewService(store),
ProjectResources: projectResourceReaderStub{servers: serverRepo},
ProjectDomains: projectDomainRepositoryStub{DomainRepository: repository.NewSQLDomainRepository(db.DB)},
})
privateKey := testSSHPrivateKey(t)
createBody, err := json.Marshal(sshKeyRequest{Name: "生产私钥", PrivateKey: privateKey})
if err != nil {
t.Fatalf("编码 SSH 私钥请求失败:%v", err)
}
createRequest := httptest.NewRequest(http.MethodPost, "/api/v1/ssh-keys", strings.NewReader(string(createBody)))
createRequest.Header.Set("Content-Type", "application/json")
createResponse := httptest.NewRecorder()
serveAdminHTTP(server, createResponse, createRequest)
if createResponse.Code != http.StatusCreated {
t.Fatalf("创建 SSH 私钥失败:%d %s", createResponse.Code, createResponse.Body.String())
}
if strings.Contains(createResponse.Body.String(), "PRIVATE KEY") || strings.Contains(createResponse.Body.String(), "private_key") {
t.Fatalf("SSH 私钥创建响应泄露了敏感内容:%s", createResponse.Body.String())
}
var key sshkey.Metadata
if err := json.Unmarshal(createResponse.Body.Bytes(), &key); err != nil || key.ID == "" || key.Reference == "" {
t.Fatalf("SSH 私钥创建响应无效:%v %+v", err, key)
}
listResponse := httptest.NewRecorder()
serveAdminHTTP(server, listResponse, httptest.NewRequest(http.MethodGet, "/api/v1/ssh-keys", nil))
if listResponse.Code != http.StatusOK || !strings.Contains(listResponse.Body.String(), key.Reference) || strings.Contains(listResponse.Body.String(), "PRIVATE KEY") {
t.Fatalf("SSH 私钥列表响应无效或泄露敏感内容:%d %s", listResponse.Code, listResponse.Body.String())
}
serverBody := `{"name":"生产服务器","address":"192.0.2.60","port":22,"username":"deploy","private_key_ref":"` + key.Reference + `","host_key_fingerprint":"SHA256:test","certificate_path":"/etc/scert/cert.pem","private_key_path":"/etc/scert/key.pem","certificate_chain_path":"/etc/scert/fullchain.pem","web_server":"nginx"}`
serverRequest := httptest.NewRequest(http.MethodPost, "/api/v1/servers", strings.NewReader(serverBody))
serverRequest.Header.Set("Content-Type", "application/json")
serverResponse := httptest.NewRecorder()
serveAdminHTTP(server, serverResponse, serverRequest)
if serverResponse.Code != http.StatusCreated {
t.Fatalf("创建使用 SSH 私钥的服务器失败:%d %s", serverResponse.Code, serverResponse.Body.String())
}
var createdServer struct {
ID string `json:"id"`
}
if err := json.Unmarshal(serverResponse.Body.Bytes(), &createdServer); err != nil || createdServer.ID == "" {
t.Fatalf("服务器创建响应无效:%v %s", err, serverResponse.Body.String())
}
deleteUsedResponse := httptest.NewRecorder()
serveAdminHTTP(server, deleteUsedResponse, httptest.NewRequest(http.MethodDelete, "/api/v1/ssh-keys/"+key.ID, nil))
if deleteUsedResponse.Code != http.StatusConflict {
t.Fatalf("仍被使用的 SSH 私钥应禁止删除:%d %s", deleteUsedResponse.Code, deleteUsedResponse.Body.String())
}
deleteServerResponse := httptest.NewRecorder()
serveAdminHTTP(server, deleteServerResponse, httptest.NewRequest(http.MethodDelete, "/api/v1/servers/"+createdServer.ID, nil))
if deleteServerResponse.Code != http.StatusNoContent {
t.Fatalf("删除测试服务器失败:%d %s", deleteServerResponse.Code, deleteServerResponse.Body.String())
}
deleteKeyResponse := httptest.NewRecorder()
serveAdminHTTP(server, deleteKeyResponse, httptest.NewRequest(http.MethodDelete, "/api/v1/ssh-keys/"+key.ID, nil))
if deleteKeyResponse.Code != http.StatusNoContent {
t.Fatalf("删除未使用的 SSH 私钥失败:%d %s", deleteKeyResponse.Code, deleteKeyResponse.Body.String())
}
}
func TestSSHKeyAPIRejectsInvalidKeyWithoutEchoingIt(t *testing.T) {
store, err := secretstore.Open(t.TempDir())
if err != nil {
t.Fatalf("打开敏感信息存储失败:%v", err)
}
server := New(Dependencies{Config: readyTestConfig(t.TempDir()), Repository: &stubDomainRepository{}, SSHKeys: sshkey.NewService(store)})
secret := "invalid-private-key-sensitive-content"
body, _ := json.Marshal(sshKeyRequest{Name: "错误私钥", PrivateKey: secret})
request := httptest.NewRequest(http.MethodPost, "/api/v1/ssh-keys", strings.NewReader(string(body)))
request.Header.Set("Content-Type", "application/json")
response := httptest.NewRecorder()
serveAdminHTTP(server, response, request)
if response.Code != http.StatusBadRequest || strings.Contains(response.Body.String(), secret) {
t.Fatalf("无效 SSH 私钥响应不安全:%d %s", response.Code, response.Body.String())
}
}
func TestSSHKeyAPIRejectsOversizedRequestBody(t *testing.T) {
store, err := secretstore.Open(t.TempDir())
if err != nil {
t.Fatalf("failed to open secret store: %v", err)
}
server := New(Dependencies{Config: readyTestConfig(t.TempDir()), Repository: &stubDomainRepository{}, SSHKeys: sshkey.NewService(store)})
body := `{"name":"oversized request","private_key":"` + strings.Repeat("a", maxSSHKeyRequestBytes) + `"}`
request := httptest.NewRequest(http.MethodPost, "/api/v1/ssh-keys", strings.NewReader(body))
request.Header.Set("Content-Type", "application/json")
response := httptest.NewRecorder()
serveAdminHTTP(server, response, request)
if response.Code != http.StatusRequestEntityTooLarge {
t.Fatalf("oversized SSH key request should return 413: %d %s", response.Code, response.Body.String())
}
}
func TestSSHKeyAPIRejectsOversizedPrivateKeyAndPassphrase(t *testing.T) {
store, err := secretstore.Open(t.TempDir())
if err != nil {
t.Fatalf("failed to open secret store: %v", err)
}
server := New(Dependencies{Config: readyTestConfig(t.TempDir()), Repository: &stubDomainRepository{}, SSHKeys: sshkey.NewService(store)})
requests := []sshKeyRequest{
{Name: "oversized key", PrivateKey: strings.Repeat("a", sshkey.MaxPrivateKeyBytes+1)},
{Name: "oversized passphrase", PrivateKey: testSSHPrivateKey(t), Passphrase: strings.Repeat("p", 4097)},
}
for _, input := range requests {
body, err := json.Marshal(input)
if err != nil {
t.Fatalf("failed to encode limit test request: %v", err)
}
request := httptest.NewRequest(http.MethodPost, "/api/v1/ssh-keys", strings.NewReader(string(body)))
request.Header.Set("Content-Type", "application/json")
response := httptest.NewRecorder()
serveAdminHTTP(server, response, request)
leaksPassphrase := input.Passphrase != "" && strings.Contains(response.Body.String(), input.Passphrase)
if response.Code != http.StatusBadRequest || strings.Contains(response.Body.String(), input.PrivateKey) || leaksPassphrase {
t.Fatalf("oversized input should be rejected safely: %d %s", response.Code, response.Body.String())
}
}
}
func testSSHPrivateKey(t *testing.T) string {
t.Helper()
_, key, err := ed25519.GenerateKey(rand.Reader)
if err != nil {
t.Fatalf("生成测试 SSH 私钥失败:%v", err)
}
encoded, err := x509.MarshalPKCS8PrivateKey(key)
if err != nil {
t.Fatalf("编码测试 SSH 私钥失败:%v", err)
}
return string(pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: encoded}))
}
func TestSSHKeyAPIRejectsUnknownFieldsAndTrailingJSON(t *testing.T) {
store, err := secretstore.Open(t.TempDir())
if err != nil {
t.Fatalf("打开敏感信息存储失败:%v", err)
}
server := New(Dependencies{Config: readyTestConfig(t.TempDir()), Repository: &stubDomainRepository{}, SSHKeys: sshkey.NewService(store)})
privateKey := testSSHPrivateKey(t)
tests := []struct {
name string
body string
}{
{
name: "未知字段",
body: `{"name":"测试私钥","private_key":` + mustJSONString(t, privateKey) + `,"unexpected":true}`,
},
{
name: "多段 JSON",
body: `{"name":"测试私钥","private_key":` + mustJSONString(t, privateKey) + `}{"name":"第二个私钥","private_key":` + mustJSONString(t, privateKey) + `}`,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
request := httptest.NewRequest(http.MethodPost, "/api/v1/ssh-keys", strings.NewReader(tt.body))
request.Header.Set("Content-Type", "application/json")
response := httptest.NewRecorder()
serveAdminHTTP(server, response, request)
if response.Code != http.StatusBadRequest {
t.Fatalf("%s 应返回 400,实际为 %d:%s", tt.name, response.Code, response.Body.String())
}
if strings.Contains(response.Body.String(), privateKey) || strings.Contains(response.Body.String(), "PRIVATE KEY") {
t.Fatalf("%s 响应泄露了私钥:%s", tt.name, response.Body.String())
}
})
}
}
func mustJSONString(t *testing.T, value string) string {
t.Helper()
encoded, err := json.Marshal(value)
if err != nil {
t.Fatalf("编码 JSON 字符串失败:%v", err)
}
return string(encoded)
}
+13 -79
View File
@@ -2,10 +2,7 @@ package httpapi
import (
"context"
"errors"
"fmt"
"net"
"syscall"
"strings"
"testing"
"git.pcux.cn/xuans/Scert/backend/internal/deployment"
@@ -19,80 +16,17 @@ func (f reloadTestFactory) Connect(ctx context.Context, item deployment.Server)
return f.connect(ctx, item)
}
type reloadTestClient struct{ deployment.Client }
func refusedReloadConnection() error {
return fmt.Errorf("%w", &net.OpError{Op: "dial", Net: "tcp", Err: syscall.ECONNREFUSED})
}
func TestSSHAfterReloadRetriesOnlyConnectionRefusal(t *testing.T) {
for _, tc := range []struct {
name string
err error
failures int
calls int
}{
{"ready", nil, 0, 1},
{"recovered", refusedReloadConnection(), 2, 3},
{"exhausted", refusedReloadConnection(), 5, 5},
{"authentication", errors.New("authentication"), 1, 1},
{"fingerprint", errors.New("fingerprint"), 1, 1},
{"timeout", &net.OpError{Op: "dial", Err: syscall.ETIMEDOUT}, 1, 1},
{"handshake", &net.OpError{Op: "read", Err: syscall.ECONNREFUSED}, 1, 1},
} {
t.Run(tc.name, func(t *testing.T) {
calls := 0
wantClient := &reloadTestClient{}
server := &Server{deploymentFactory: reloadTestFactory{connect: func(ctx context.Context, item deployment.Server) (deployment.Client, error) {
calls++
if item.AuthMethod != deployment.SSHAuthPrivateKey || item.HostKeyFingerprint != "SHA256:registered" {
t.Fatal(item.AuthMethod, item.HostKeyFingerprint)
}
if calls <= tc.failures {
return nil, tc.err
}
return wantClient, nil
}}}
client, err := server.connectSSHAfterReload(t.Context(), deployment.Server{
AuthMethod: deployment.SSHAuthPrivateKey, HostKeyFingerprint: "SHA256:registered",
})
if calls != tc.calls {
t.Fatalf("calls=%d; want=%d", calls, tc.calls)
}
if tc.calls <= tc.failures {
if !errors.Is(err, tc.err) || client != nil {
t.Fatal(client, err)
}
} else if err != nil || client != wantClient {
t.Fatal(client, err)
}
})
}
}
func TestSSHAfterReloadHonorsCancellation(t *testing.T) {
for _, cancelBeforeConnect := range []bool{false, true} {
ctx, cancel := context.WithCancel(t.Context())
calls := 0
server := &Server{deploymentFactory: reloadTestFactory{connect: func(context.Context, deployment.Server) (deployment.Client, error) {
calls++
cancel()
return nil, refusedReloadConnection()
}}}
if cancelBeforeConnect {
cancel()
}
client, err := server.connectSSHAfterReload(ctx, deployment.Server{})
cancel()
if !errors.Is(err, context.Canceled) || client != nil {
t.Fatal(client, err)
}
wantCalls := 1
if cancelBeforeConnect {
wantCalls = 0
}
if calls != wantCalls {
t.Fatalf("calls=%d; want=%d", calls, wantCalls)
}
func TestSSHAfterReloadRejectsPrivateKeyAuthentication(t *testing.T) {
server := &Server{deploymentFactory: reloadTestFactory{connect: func(context.Context, deployment.Server) (deployment.Client, error) {
t.Fatal("private key authentication must not reach the deployment factory")
return nil, nil
}}}
client, err := server.connectSSHAfterReload(t.Context(), deployment.Server{
AuthMethod: deployment.SSHAuthPrivateKey,
PrivateKeyRef: "secret://ssh/private-key",
HostKeyFingerprint: "SHA256:registered",
})
if client != nil || err == nil || !strings.Contains(err.Error(), "SSH") {
t.Fatalf("private key authentication should be rejected: client=%v err=%v", client, err)
}
}