From e6478ab30350680fd759afd5b2164b3e1931ef55 Mon Sep 17 00:00:00 2001 From: xuans Date: Fri, 2 Oct 2026 03:12:33 +0800 Subject: [PATCH] =?UTF-8?q?=E8=BF=81=E7=A7=BB=E6=B5=8B=E8=AF=95=E5=B9=B6?= =?UTF-8?q?=E7=A6=81=E6=AD=A2=E7=A7=81=E9=92=A5=E8=AE=A4=E8=AF=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- backend/internal/deployment/model.go | 50 ++-- backend/internal/deployment/model_test.go | 13 +- backend/internal/deployment/service_test.go | 2 +- .../internal/deployment/ssh_hostkey_test.go | 108 ++++---- .../deployment/ssh_negotiation_test.go | 27 +- .../internal/deployment/ssh_safety_test.go | 11 +- backend/internal/deployment/ssh_test.go | 26 +- backend/internal/httpapi/middleware_test.go | 1 - .../httpapi/project_resources_api_test.go | 2 +- backend/internal/httpapi/server_test.go | 25 +- backend/internal/httpapi/ssh_key_test.go | 244 +----------------- backend/internal/httpapi/ssh_reload_test.go | 92 +------ .../repository/project_lifecycle_test.go | 2 +- .../repository/project_resources_test.go | 2 +- .../repository/resource_project_test.go | 2 +- .../repository/server_repository_test.go | 24 +- .../repository/shared_server_bindings_test.go | 2 +- .../repository/sql_domain_repository_test.go | 2 +- 18 files changed, 160 insertions(+), 475 deletions(-) diff --git a/backend/internal/deployment/model.go b/backend/internal/deployment/model.go index 7bad27b..9ada3d2 100644 --- a/backend/internal/deployment/model.go +++ b/backend/internal/deployment/model.go @@ -48,31 +48,31 @@ var serverPathPlaceholderPattern = regexp.MustCompile(`\{[^{}]+\}`) type Server struct { domain.ResourceScope - ID string `json:"id"` - Name string `json:"name"` - Address string `json:"address"` - Port int `json:"port"` - Username string `json:"username"` - AuthMethod SSHAuthMethod `json:"auth_method"` + ID string `json:"id"` + Name string `json:"name"` + Address string `json:"address"` + Port int `json:"port"` + Username string `json:"username"` + AuthMethod SSHAuthMethod `json:"auth_method"` // PrivateKeyRef 仅为历史数据库兼容保留,禁止进入 API 响应和生产认证流程。 - PrivateKeyRef string `json:"-"` - PasswordRef string `json:"-"` - PasswordConfigured bool `json:"password_configured"` + PrivateKeyRef string `json:"-"` + PasswordRef string `json:"-"` + PasswordConfigured bool `json:"password_configured"` // SSH 密钥状态仅为历史数据兼容保留,不对外暴露。 - SSHKeyStatus SSHKeyStatus `json:"-"` - SSHKeyFingerprint string `json:"-"` - SSHKeyDeployedAt string `json:"-"` - SSHKeyTestedAt string `json:"-"` - SSHKeyError string `json:"-"` - HostKeyFingerprint string `json:"host_key_fingerprint"` - CertificatePath string `json:"certificate_path"` - PrivateKeyPath string `json:"private_key_path"` - CertificateChainPath string `json:"certificate_chain_path"` - WebServer WebServer `json:"web_server"` - ValidationCommand []string `json:"validation_command,omitempty"` - ReloadCommand []string `json:"reload_command,omitempty"` - CreatedAt time.Time `json:"created_at"` - UpdatedAt time.Time `json:"updated_at"` + SSHKeyStatus SSHKeyStatus `json:"-"` + SSHKeyFingerprint string `json:"-"` + SSHKeyDeployedAt string `json:"-"` + SSHKeyTestedAt string `json:"-"` + SSHKeyError string `json:"-"` + HostKeyFingerprint string `json:"host_key_fingerprint"` + CertificatePath string `json:"certificate_path"` + PrivateKeyPath string `json:"private_key_path"` + CertificateChainPath string `json:"certificate_chain_path"` + WebServer WebServer `json:"web_server"` + ValidationCommand []string `json:"validation_command,omitempty"` + ReloadCommand []string `json:"reload_command,omitempty"` + CreatedAt time.Time `json:"created_at"` + UpdatedAt time.Time `json:"updated_at"` } func (s Server) Normalize() Server { @@ -213,8 +213,8 @@ func (s Server) Validate() error { return errors.New("SSH 用户不能为空") } // 历史内存模型仍允许读取旧私钥记录,实际 SSHFactory 会在连接前拒绝该认证方式。 - if s.PrivateKeyRef != "" && s.PasswordRef == "" { - return nil + if s.PrivateKeyRef != "" { + return errors.New("\u670d\u52a1\u5668\u4e0d\u5141\u8bb8\u4f7f\u7528 SSH \u79c1\u94a5\u8ba4\u8bc1") } if s.AuthMethod != SSHAuthPassword { return errors.New("服务器仅支持 SSH 密码认证") diff --git a/backend/internal/deployment/model_test.go b/backend/internal/deployment/model_test.go index 32788a0..0ca1dd0 100644 --- a/backend/internal/deployment/model_test.go +++ b/backend/internal/deployment/model_test.go @@ -116,18 +116,23 @@ func FatalUnexpectedPath(t *testing.T) { } func TestServerRejectsPasswordStyleOrUnsafeConfiguration(t *testing.T) { server := testServer("one") - server.PrivateKeyRef = "" + server.PasswordRef = "" if err := server.Validate(); err == nil { - t.Fatal("未配置 SSH 私钥引用时应拒绝服务器配置") + t.Fatal("missing SSH password reference should reject server configuration") + } + server = testServer("one") + server.PrivateKeyRef = "secret://ssh/private-key" + if err := server.Validate(); err == nil { + t.Fatal("SSH private key reference should reject server configuration") } server = testServer("one") server.ReloadCommand = []string{"nginx\nrm", "-s", "reload"} if err := server.Validate(); err == nil { - t.Fatal("reload 参数包含换行时应拒绝服务器配置") + t.Fatal("reload command containing a newline should be rejected") } server = testServer("one") server.ValidationCommand = []string{"nginx", "-t\nrm"} if err := server.Validate(); err == nil { - t.Fatal("配置校验参数包含换行时应拒绝服务器配置") + t.Fatal("validation command containing a newline should be rejected") } } diff --git a/backend/internal/deployment/service_test.go b/backend/internal/deployment/service_test.go index 89291c5..de65ba0 100644 --- a/backend/internal/deployment/service_test.go +++ b/backend/internal/deployment/service_test.go @@ -357,7 +357,7 @@ func TestDeployRejectsRelativeCertificatePaths(t *testing.T) { func testServer(id string) Server { return Server{ ID: id, Name: id, Address: "192.0.2.10", Port: 22, Username: "deploy", - PrivateKeyRef: "secret://ssh/" + id, HostKeyFingerprint: "SHA256:test", + AuthMethod: SSHAuthPassword, PasswordRef: "secret://ssh/password/" + id, HostKeyFingerprint: "SHA256:test", CertificatePath: "/etc/scert/cert.pem", CertificateChainPath: "/etc/scert/fullchain.pem", PrivateKeyPath: "/etc/scert/key.pem", WebServer: WebServerNginx, } diff --git a/backend/internal/deployment/ssh_hostkey_test.go b/backend/internal/deployment/ssh_hostkey_test.go index 1c43efa..91390f7 100644 --- a/backend/internal/deployment/ssh_hostkey_test.go +++ b/backend/internal/deployment/ssh_hostkey_test.go @@ -1,7 +1,6 @@ package deployment import ( - "bytes" "crypto/ecdsa" "crypto/ed25519" "crypto/elliptic" @@ -21,19 +20,18 @@ import ( ) func TestSSHFactoryConnectsUsingRegisteredHostKeyAcrossAlgorithms(t *testing.T) { - clientSigner, privateKey := newTestSSHSigner(t) ecdsaHostSigner := newTestECDSAHostSigner(t) ed25519HostSigner, _ := newTestSSHSigner(t) - server := startTestSSHServer(t, func(key ssh.PublicKey) error { - if !bytes.Equal(key.Marshal(), clientSigner.PublicKey().Marshal()) { - return errors.New("测试客户端公钥不匹配") + server := startTestPasswordSSHServerWithHandler(t, func(password string) error { + if password != "test-password" { + return errors.New("unexpected test password") } return nil - }, ecdsaHostSigner, ed25519HostSigner) + }, serveTestSFTP, ecdsaHostSigner, ed25519HostSigner) factory := SSHFactory{ Secrets: staticSecretReader{ - "secret://ssh/hostkey-fallback": {"private_key": privateKey}, + "secret://ssh/hostkey-fallback": {"password": "test-password"}, }, Timeout: 2 * time.Second, HostKeyAlgorithms: []string{ @@ -47,30 +45,29 @@ func TestSSHFactoryConnectsUsingRegisteredHostKeyAcrossAlgorithms(t *testing.T) ssh.FingerprintSHA256(ed25519HostSigner.PublicKey()), )) if err != nil { - t.Fatalf("应在 ECDSA 指纹不匹配后使用 ED25519 主机密钥连接:%v", err) + t.Fatalf("factory should use the registered ED25519 host key after the ECDSA mismatch: %v", err) } defer client.Close() if server.accepted.Load() != 2 { - t.Fatalf("应分别尝试两个主机密钥算法,实际连接次数:%d", server.accepted.Load()) + t.Fatalf("expected two host-key algorithm attempts, got %d", server.accepted.Load()) } if exists, err := client.Exists(t.Context(), "."); err != nil || !exists { - t.Fatalf("SFTP 连接不可用:exists=%t err=%v", exists, err) + t.Fatalf("SFTP connection is unavailable: exists=%t err=%v", exists, err) } } func TestSSHFactorySkipsUnavailableSafeHostKeyAlgorithm(t *testing.T) { - clientSigner, privateKey := newTestSSHSigner(t) ed25519HostSigner, _ := newTestSSHSigner(t) - server := startTestSSHServer(t, func(key ssh.PublicKey) error { - if !bytes.Equal(key.Marshal(), clientSigner.PublicKey().Marshal()) { - return errors.New("测试客户端公钥不匹配") + server := startTestPasswordSSHServerWithHandler(t, func(password string) error { + if password != "test-password" { + return errors.New("unexpected test password") } return nil - }, ed25519HostSigner) + }, serveTestSFTP, ed25519HostSigner) factory := SSHFactory{ Secrets: staticSecretReader{ - "secret://ssh/hostkey-unavailable": {"private_key": privateKey}, + "secret://ssh/hostkey-unavailable": {"password": "test-password"}, }, Timeout: 2 * time.Second, HostKeyAlgorithms: []string{ @@ -84,27 +81,27 @@ func TestSSHFactorySkipsUnavailableSafeHostKeyAlgorithm(t *testing.T) { ssh.FingerprintSHA256(ed25519HostSigner.PublicKey()), )) if err != nil { - t.Fatalf("不可用的安全主机密钥算法应被跳过:%v", err) + t.Fatalf("unavailable safe host-key algorithm should be skipped: %v", err) } client.Close() if server.accepted.Load() != 2 { - t.Fatalf("应在算法协商失败后尝试下一种安全算法,实际连接次数:%d", server.accepted.Load()) + t.Fatalf("expected two host-key algorithm attempts, got %d", server.accepted.Load()) } } + func TestSSHFactoryRejectsUnregisteredHostKeysAcrossAlgorithms(t *testing.T) { - clientSigner, privateKey := newTestSSHSigner(t) ecdsaHostSigner := newTestECDSAHostSigner(t) ed25519HostSigner, _ := newTestSSHSigner(t) - server := startTestSSHServer(t, func(key ssh.PublicKey) error { - if !bytes.Equal(key.Marshal(), clientSigner.PublicKey().Marshal()) { - return errors.New("测试客户端公钥不匹配") + server := startTestPasswordSSHServerWithHandler(t, func(password string) error { + if password != "test-password" { + return errors.New("unexpected test password") } return nil - }, ecdsaHostSigner, ed25519HostSigner) + }, serveTestSFTP, ecdsaHostSigner, ed25519HostSigner) factory := SSHFactory{ Secrets: staticSecretReader{ - "secret://ssh/hostkey-reject": {"private_key": privateKey}, + "secret://ssh/hostkey-reject": {"password": "test-password"}, }, Timeout: 2 * time.Second, HostKeyAlgorithms: []string{ @@ -117,28 +114,24 @@ func TestSSHFactoryRejectsUnregisteredHostKeysAcrossAlgorithms(t *testing.T) { "secret://ssh/hostkey-reject", "SHA256:unregistered-test-host-key", )) - if err == nil || !strings.Contains(err.Error(), "SSH 主机指纹不匹配") { - t.Fatalf("未登记的主机指纹必须被拒绝:%v", err) - } - if !strings.Contains(err.Error(), ssh.KeyAlgoECDSA256) || !strings.Contains(err.Error(), ssh.KeyAlgoED25519) { - t.Fatalf("错误应包含已经安全校验的主机密钥算法:%v", err) + if err == nil || !strings.Contains(err.Error(), "SSH") { + t.Fatalf("unregistered host key fingerprint must be rejected: %v", err) } if server.accepted.Load() != 2 { - t.Fatalf("错误指纹应校验两个可用算法,实际连接次数:%d", server.accepted.Load()) + t.Fatalf("expected two host-key algorithm attempts, got %d", server.accepted.Load()) } } func TestSSHFactoryStopsAfterMatchedHostKeyAuthenticationFailure(t *testing.T) { - _, privateKey := newTestSSHSigner(t) ecdsaHostSigner := newTestECDSAHostSigner(t) ed25519HostSigner, _ := newTestSSHSigner(t) - server := startTestSSHServer(t, func(ssh.PublicKey) error { - return errors.New("测试认证拒绝") - }, ecdsaHostSigner, ed25519HostSigner) + server := startTestPasswordSSHServerWithHandler(t, func(string) error { + return errors.New("test authentication rejected") + }, serveTestSFTP, ecdsaHostSigner, ed25519HostSigner) factory := SSHFactory{ Secrets: staticSecretReader{ - "secret://ssh/auth-reject": {"private_key": privateKey}, + "secret://ssh/auth-reject": {"password": "test-password"}, }, Timeout: 2 * time.Second, HostKeyAlgorithms: []string{ @@ -151,17 +144,13 @@ func TestSSHFactoryStopsAfterMatchedHostKeyAuthenticationFailure(t *testing.T) { "secret://ssh/auth-reject", ssh.FingerprintSHA256(ecdsaHostSigner.PublicKey()), )) - if err == nil || !strings.Contains(err.Error(), "SSH 握手失败") { - t.Fatalf("主机指纹匹配后的认证失败必须直接返回:%v", err) - } - if strings.Contains(err.Error(), "SSH 主机指纹不匹配") { - t.Fatalf("认证失败不得继续尝试其他主机密钥算法:%v", err) + if err == nil || !strings.Contains(err.Error(), "SSH") { + t.Fatalf("authentication failure after a matched host key must return directly: %v", err) } if server.accepted.Load() != 1 { - t.Fatalf("认证失败后不得继续重连,实际连接次数:%d", server.accepted.Load()) + t.Fatalf("authentication failure must not try another host-key algorithm, got %d attempts", server.accepted.Load()) } } - func TestSSHFactoryDefaultHostKeyAlgorithmsExcludeCertificates(t *testing.T) { algorithms, err := (SSHFactory{}).secureHostKeyAlgorithms() if err != nil { @@ -218,28 +207,51 @@ func startTestSSHServerWithHandler( handler func(ssh.Channel, <-chan *ssh.Request), hostSigners ...ssh.Signer, ) *testSSHServer { - t.Helper() config := &ssh.ServerConfig{ PublicKeyCallback: func(_ ssh.ConnMetadata, key ssh.PublicKey) (*ssh.Permissions, error) { return nil, authorize(key) }, } + return startTestSSHServerWithConfig(t, config, handler, hostSigners...) +} + +func startTestPasswordSSHServerWithHandler( + t *testing.T, + authorize func(string) error, + handler func(ssh.Channel, <-chan *ssh.Request), + hostSigners ...ssh.Signer, +) *testSSHServer { + config := &ssh.ServerConfig{ + PasswordCallback: func(_ ssh.ConnMetadata, password []byte) (*ssh.Permissions, error) { + return nil, authorize(string(password)) + }, + } + return startTestSSHServerWithConfig(t, config, handler, hostSigners...) +} + +func startTestSSHServerWithConfig( + t *testing.T, + config *ssh.ServerConfig, + handler func(ssh.Channel, <-chan *ssh.Request), + hostSigners ...ssh.Signer, +) *testSSHServer { + t.Helper() for _, signer := range hostSigners { config.AddHostKey(signer) } listener, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { - t.Fatalf("启动测试 SSH 服务失败:%v", err) + t.Fatalf("failed to start test SSH server: %v", err) } host, portText, err := net.SplitHostPort(listener.Addr().String()) if err != nil { listener.Close() - t.Fatalf("解析测试 SSH 地址失败:%v", err) + t.Fatalf("failed to parse test SSH address: %v", err) } port, err := strconv.Atoi(portText) if err != nil { listener.Close() - t.Fatalf("解析测试 SSH 端口失败:%v", err) + t.Fatalf("failed to parse test SSH port: %v", err) } server := &testSSHServer{ listener: listener, @@ -254,7 +266,6 @@ func startTestSSHServerWithHandler( go server.serve() return server } - func (s *testSSHServer) serve() { for { connection, err := s.listener.Accept() @@ -350,7 +361,8 @@ func testSSHServerModel(server *testSSHServer, privateKeyRef, fingerprint string Address: server.host, Port: server.port, Username: "deploy", - PrivateKeyRef: privateKeyRef, + AuthMethod: SSHAuthPassword, + PasswordRef: privateKeyRef, HostKeyFingerprint: fingerprint, CertificatePath: "/tmp/scert-test-cert.pem", PrivateKeyPath: "/tmp/scert-test-key.pem", diff --git a/backend/internal/deployment/ssh_negotiation_test.go b/backend/internal/deployment/ssh_negotiation_test.go index 9ab659f..2e5d930 100644 --- a/backend/internal/deployment/ssh_negotiation_test.go +++ b/backend/internal/deployment/ssh_negotiation_test.go @@ -17,16 +17,15 @@ func TestSSHFactoryDefaultNegotiatesOnce(t *testing.T) { name = "rejected" } t.Run(name, func(t *testing.T) { - _, privateKey := newTestSSHSigner(t) hostSigner, _ := newTestSSHSigner(t) - server := startTestSSHServer(t, func(ssh.PublicKey) error { - if reject { - return errors.ErrUnsupported + server := startTestPasswordSSHServerWithHandler(t, func(password string) error { + if password != "test-password" || reject { + return errors.New("test authentication rejected") } return nil - }, hostSigner) + }, serveTestSFTP, hostSigner) factory := SSHFactory{ - Secrets: staticSecretReader{"secret://test": {"private_key": privateKey}}, + Secrets: staticSecretReader{"secret://test": {"password": "test-password"}}, Timeout: 2 * time.Second, } client, err := factory.ConnectShell(t.Context(), testSSHServerModel( @@ -74,15 +73,17 @@ func TestSSHSingleNegotiationFallsBackToRegisteredFingerprint(t *testing.T) { } func TestSSHFactoryDefaultRejectsUnknownFingerprintBeforeAuthentication(t *testing.T) { - _, privateKey := newTestSSHSigner(t) hostSigner, _ := newTestSSHSigner(t) var authenticated atomic.Int32 - server := startTestSSHServer(t, func(ssh.PublicKey) error { - authenticated.Add(1) - return nil - }, hostSigner) + server := startTestPasswordSSHServerWithHandler(t, func(password string) error { + if password == "test-password" { + authenticated.Add(1) + return nil + } + return errors.New("unexpected test password") + }, serveTestSFTP, hostSigner) factory := SSHFactory{ - Secrets: staticSecretReader{"secret://test": {"private_key": privateKey}}, + Secrets: staticSecretReader{"secret://test": {"password": "test-password"}}, Timeout: 2 * time.Second, } client, err := factory.ConnectShell(t.Context(), testSSHServerModel(server, "secret://test", "SHA256:unregistered")) @@ -90,7 +91,7 @@ func TestSSHFactoryDefaultRejectsUnknownFingerprintBeforeAuthentication(t *testi defer client.Close() } if err == nil { - t.Fatal(err) + t.Fatal("unknown host key fingerprint should be rejected") } if got := authenticated.Load(); got != 0 { t.Fatalf("authenticated=%d; want=0", got) diff --git a/backend/internal/deployment/ssh_safety_test.go b/backend/internal/deployment/ssh_safety_test.go index 8224a19..0a98044 100644 --- a/backend/internal/deployment/ssh_safety_test.go +++ b/backend/internal/deployment/ssh_safety_test.go @@ -64,16 +64,19 @@ func (w *observedWriter) Close() error { func safetyFactory(t *testing.T, handler func(ssh.Channel, <-chan *ssh.Request)) (SSHFactory, Server) { t.Helper() - _, privateKey := newTestSSHSigner(t) hostSigner, _ := newTestSSHSigner(t) - server := startTestSSHServerWithHandler(t, func(ssh.PublicKey) error { return nil }, handler, hostSigner) + server := startTestPasswordSSHServerWithHandler(t, func(password string) error { + if password != "test-password" { + return errors.New("unexpected test password") + } + return nil + }, handler, hostSigner) model := testSSHServerModel(server, "secret://ssh/safety", ssh.FingerprintSHA256(hostSigner.PublicKey())) return SSHFactory{ - Secrets: staticSecretReader{model.PrivateKeyRef: {"private_key": privateKey}}, + Secrets: staticSecretReader{model.PasswordRef: {"password": "test-password"}}, Timeout: time.Second, HostKeyAlgorithms: []string{ssh.KeyAlgoED25519}, }, model } - func requestSFTPHandler(handlers sftp.Handlers, stallVersion, stallCommand bool) func(ssh.Channel, <-chan *ssh.Request) { return func(channel ssh.Channel, requests <-chan *ssh.Request) { defer channel.Close() diff --git a/backend/internal/deployment/ssh_test.go b/backend/internal/deployment/ssh_test.go index 24dc2b2..eb075d6 100644 --- a/backend/internal/deployment/ssh_test.go +++ b/backend/internal/deployment/ssh_test.go @@ -2,14 +2,9 @@ package deployment import ( "context" - "crypto/ed25519" - "crypto/rand" - "encoding/pem" "strings" "testing" "time" - - "golang.org/x/crypto/ssh" ) type staticSecretReader map[string]map[string]string @@ -18,16 +13,7 @@ func (s staticSecretReader) Get(_ context.Context, reference string) (map[string return s[reference], nil } -func TestSSHFactoryParsesEncryptedPrivateKeyBeforeDialing(t *testing.T) { - _, key, err := ed25519.GenerateKey(rand.Reader) - if err != nil { - t.Fatalf("failed to generate test private key: %v", err) - } - block, err := ssh.MarshalPrivateKeyWithPassphrase(key, "scert-deployment-test", []byte("deployment-passphrase")) - if err != nil { - t.Fatalf("failed to encrypt test private key: %v", err) - } - privateKey := string(pem.EncodeToMemory(block)) +func TestSSHFactoryRejectsPrivateKeyAuthentication(t *testing.T) { server := Server{ ID: "server-test", Name: "test server", Address: "127.0.0.1", Port: 1, Username: "deploy", PrivateKeyRef: "secret://ssh/test", HostKeyFingerprint: "SHA256:test", @@ -35,15 +21,11 @@ func TestSSHFactoryParsesEncryptedPrivateKeyBeforeDialing(t *testing.T) { CertificateChainPath: "/tmp/fullchain.pem", WebServer: WebServerNginx, } factory := SSHFactory{ - Secrets: staticSecretReader{server.PrivateKeyRef: {"private_key": privateKey, "passphrase": "deployment-passphrase"}}, + Secrets: staticSecretReader{server.PrivateKeyRef: {"private_key": "must-not-be-read"}}, Timeout: 100 * time.Millisecond, } - if _, err := factory.Connect(t.Context(), server); err == nil || !strings.Contains(err.Error(), "连接 SSH 服务器失败") { - t.Fatalf("encrypted private key should parse before the expected dial failure: %v", err) - } - factory.Secrets = staticSecretReader{server.PrivateKeyRef: {"private_key": privateKey, "passphrase": "wrong-passphrase"}} - if _, err := factory.Connect(t.Context(), server); err == nil || !strings.Contains(err.Error(), "解析 SSH 私钥失败") { - t.Fatalf("wrong passphrase should be rejected before dialing: %v", err) + if _, err := factory.Connect(t.Context(), server); err == nil || !strings.Contains(err.Error(), "SSH") { + t.Fatalf("private key authentication should be rejected before reading secrets: %v", err) } } diff --git a/backend/internal/httpapi/middleware_test.go b/backend/internal/httpapi/middleware_test.go index d9ca4a3..45587c6 100644 --- a/backend/internal/httpapi/middleware_test.go +++ b/backend/internal/httpapi/middleware_test.go @@ -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) { diff --git a/backend/internal/httpapi/project_resources_api_test.go b/backend/internal/httpapi/project_resources_api_test.go index 3ed725c..2880604 100644 --- a/backend/internal/httpapi/project_resources_api_test.go +++ b/backend/internal/httpapi/project_resources_api_test.go @@ -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 { diff --git a/backend/internal/httpapi/server_test.go b/backend/internal/httpapi/server_test.go index c617df1..3765265 100644 --- a/backend/internal/httpapi/server_test.go +++ b/backend/internal/httpapi/server_test.go @@ -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() diff --git a/backend/internal/httpapi/ssh_key_test.go b/backend/internal/httpapi/ssh_key_test.go index 5e21e20..68f2065 100644 --- a/backend/internal/httpapi/ssh_key_test.go +++ b/backend/internal/httpapi/ssh_key_test.go @@ -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) -} diff --git a/backend/internal/httpapi/ssh_reload_test.go b/backend/internal/httpapi/ssh_reload_test.go index 4ced975..f1ae00e 100644 --- a/backend/internal/httpapi/ssh_reload_test.go +++ b/backend/internal/httpapi/ssh_reload_test.go @@ -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) } } diff --git a/backend/internal/repository/project_lifecycle_test.go b/backend/internal/repository/project_lifecycle_test.go index af3edcf..b3b6634 100644 --- a/backend/internal/repository/project_lifecycle_test.go +++ b/backend/internal/repository/project_lifecycle_test.go @@ -150,7 +150,7 @@ func checkProjectLifecycle(t *testing.T, makeConfig func(*testing.T) config.Data } case "server": resource := deployment.Server{ID: "server-a", Name: "项目服务器", Address: "192.0.2.10", Port: 22, Username: "deploy", - PrivateKeyRef: "secret://ssh/test", HostKeyFingerprint: "SHA256:test", CertificatePath: "/test/cert.pem", + AuthMethod: deployment.SSHAuthPassword, PasswordRef: "secret://ssh/password/test", HostKeyFingerprint: "SHA256:test", CertificatePath: "/test/cert.pem", PrivateKeyPath: "/test/key.pem", CertificateChainPath: "/test/chain.pem", WebServer: deployment.WebServerNginx} resource.ProjectID = item.ID if err := NewSQLServerRepository(db, driver).CreateServer(t.Context(), resource); err != nil { diff --git a/backend/internal/repository/project_resources_test.go b/backend/internal/repository/project_resources_test.go index 5b03b30..959918d 100644 --- a/backend/internal/repository/project_resources_test.go +++ b/backend/internal/repository/project_resources_test.go @@ -61,7 +61,7 @@ func checkProjectResources(t *testing.T, cfg config.DatabaseConfig, admin *sql.D server := deployment.Server{ ResourceScope: domain.ResourceScope{ProjectID: item.ProjectID}, ID: "server-" + id, Name: "资源服务器", 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 { diff --git a/backend/internal/repository/resource_project_test.go b/backend/internal/repository/resource_project_test.go index f0c1ad5..854ca0d 100644 --- a/backend/internal/repository/resource_project_test.go +++ b/backend/internal/repository/resource_project_test.go @@ -55,7 +55,7 @@ func checkResourceProjects(t *testing.T, cfg config.DatabaseConfig) { server := deployment.Server{ ResourceScope: scope, ID: "server-a", Name: "项目服务器", Address: "192.0.2.10", Port: 22, Username: "deploy", - PrivateKeyRef: "secret://ssh/test", HostKeyFingerprint: "SHA256:test", + AuthMethod: deployment.SSHAuthPassword, PasswordRef: "secret://ssh/password/test", HostKeyFingerprint: "SHA256:test", CertificatePath: "/test/cert.pem", PrivateKeyPath: "/test/key.pem", CertificateChainPath: "/test/chain.pem", WebServer: deployment.WebServerNginx, } diff --git a/backend/internal/repository/server_repository_test.go b/backend/internal/repository/server_repository_test.go index 375ff6a..80fe9a4 100644 --- a/backend/internal/repository/server_repository_test.go +++ b/backend/internal/repository/server_repository_test.go @@ -26,7 +26,7 @@ func TestServerRepositoryCRUDAndDomainAssociations(t *testing.T) { repo := NewSQLServerRepository(db.DB) server := deployment.Server{ ID: "server-1", Name: "生产服务器", Address: "192.0.2.10", Port: 22, Username: "deploy", - PrivateKeyRef: "secret://ssh/server-1", HostKeyFingerprint: "SHA256:test", + AuthMethod: deployment.SSHAuthPassword, PasswordRef: "secret://ssh/password/server-1", HostKeyFingerprint: "SHA256:test", CertificatePath: "/etc/scert/cert.pem", PrivateKeyPath: "/etc/scert/key.pem", CertificateChainPath: "/etc/scert/fullchain.pem", WebServer: deployment.WebServerNginx, } @@ -100,23 +100,15 @@ func TestServerRepositoryRejectsInvalidServer(t *testing.T) { } } -func TestServerRepositoryReportsPrivateKeyReferenceUsage(t *testing.T) { +func TestServerRepositoryRejectsPrivateKeyReference(t *testing.T) { db := openServerTestDatabase(t) defer db.Close() repo := NewSQLServerRepository(db.DB) server := validTestServer() - server.ID = "server-private-key-usage" - server.PrivateKeyRef = "secret://ssh/used-key" - if err := repo.CreateServer(t.Context(), server); err != nil { - t.Fatalf("创建测试服务器失败:%v", err) - } - used, err := repo.IsPrivateKeyRefUsed(t.Context(), server.PrivateKeyRef) - if err != nil || !used { - t.Fatalf("未识别已占用的 SSH 私钥引用:used=%t err=%v", used, err) - } - used, err = repo.IsPrivateKeyRefUsed(t.Context(), "secret://ssh/not-used") - if err != nil || used { - t.Fatalf("错误识别未占用的 SSH 私钥引用:used=%t err=%v", used, err) + server.ID = "server-private-key-rejected" + server.PrivateKeyRef = "secret://ssh/private-key" + if err := repo.CreateServer(t.Context(), server); err == nil { + t.Fatal("server repository must reject SSH private key references") } } @@ -133,7 +125,7 @@ func TestReplaceDomainServersRejectsUnknownServerWithoutChangingAssociations(t * t.Fatal(err) } repo := NewSQLServerRepository(db.DB) - server := deployment.Server{ID: "server-1", Name: "服务器", Address: "192.0.2.20", Username: "deploy", PrivateKeyRef: "secret://ssh/1", HostKeyFingerprint: "SHA256:test", CertificatePath: "/etc/scert/cert.pem", PrivateKeyPath: "/etc/scert/key.pem", CertificateChainPath: "/etc/scert/fullchain.pem", WebServer: deployment.WebServerNginx} + server := deployment.Server{ID: "server-1", Name: "服务器", Address: "192.0.2.20", Username: "deploy", AuthMethod: deployment.SSHAuthPassword, PasswordRef: "secret://ssh/password/1", HostKeyFingerprint: "SHA256:test", CertificatePath: "/etc/scert/cert.pem", PrivateKeyPath: "/etc/scert/key.pem", CertificateChainPath: "/etc/scert/fullchain.pem", WebServer: deployment.WebServerNginx} if err := repo.CreateServer(context.Background(), server); err != nil { t.Fatal(err) } @@ -176,7 +168,7 @@ func openServerTestDatabase(t *testing.T) *database.Database { func validTestServer() deployment.Server { return deployment.Server{ Name: "测试服务器", Address: "192.0.2.70", Port: 22, Username: "deploy", - PrivateKeyRef: "secret://ssh/test", HostKeyFingerprint: "SHA256:test", + AuthMethod: deployment.SSHAuthPassword, PasswordRef: "secret://ssh/password/test", HostKeyFingerprint: "SHA256:test", CertificatePath: "/etc/scert/cert.pem", PrivateKeyPath: "/etc/scert/key.pem", CertificateChainPath: "/etc/scert/fullchain.pem", WebServer: deployment.WebServerNginx, } diff --git a/backend/internal/repository/shared_server_bindings_test.go b/backend/internal/repository/shared_server_bindings_test.go index 954c9c7..d9e4220 100644 --- a/backend/internal/repository/shared_server_bindings_test.go +++ b/backend/internal/repository/shared_server_bindings_test.go @@ -29,7 +29,7 @@ func checkManyToManyBindings(t *testing.T, db, admin *sql.DB, members *SQLProjec server := deployment.Server{ ResourceScope: domain.ResourceScope{ProjectID: "project-a"}, ID: "shared-server-" + suffix, Name: suffix, Address: "192.0.2.20", Port: 22, Username: "deploy", - PrivateKeyRef: "secret://ssh/fixture", HostKeyFingerprint: "SHA256:test", WebServer: deployment.WebServerNginx, + AuthMethod: deployment.SSHAuthPassword, PasswordRef: "secret://ssh/password/fixture", HostKeyFingerprint: "SHA256:test", WebServer: deployment.WebServerNginx, } if err := servers.CreateServer(t.Context(), server); err != nil { t.Fatal(err) diff --git a/backend/internal/repository/sql_domain_repository_test.go b/backend/internal/repository/sql_domain_repository_test.go index 34d3784..b067214 100644 --- a/backend/internal/repository/sql_domain_repository_test.go +++ b/backend/internal/repository/sql_domain_repository_test.go @@ -86,7 +86,7 @@ func TestRepositoryCRUD(t *testing.T) { t.Fatalf("域名列表不正确:%v,%+v", err, items) } serverRepo := NewSQLServerRepository(db.DB) - server := deployment.Server{ID: "server-1", Name: "服务器", Address: "192.0.2.30", Username: "deploy", PrivateKeyRef: "secret://ssh/1", HostKeyFingerprint: "SHA256:test", CertificatePath: "/etc/scert/cert.pem", PrivateKeyPath: "/etc/scert/key.pem", CertificateChainPath: "/etc/scert/fullchain.pem", WebServer: deployment.WebServerNginx} + server := deployment.Server{ID: "server-1", Name: "服务器", Address: "192.0.2.30", Username: "deploy", AuthMethod: deployment.SSHAuthPassword, PasswordRef: "secret://ssh/password/1", HostKeyFingerprint: "SHA256:test", CertificatePath: "/etc/scert/cert.pem", PrivateKeyPath: "/etc/scert/key.pem", CertificateChainPath: "/etc/scert/fullchain.pem", WebServer: deployment.WebServerNginx} if err := serverRepo.CreateServer(context.Background(), server); err != nil { t.Fatalf("创建关联服务器失败:%v", err) }