25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
feat(cassandra): add TLS store support
以谶38be5ba35cbf
diff --git a/agents/drivers/cassandra-go/README.md b/agents/drivers/cassandra-go/README.mdindex 32cf684988..6e0bec7cc0 100644--- a/agents/drivers/cassandra-go/README.md+++ b/agents/drivers/cassandra-go/README.md@@ -13,7 +13,8 @@ multi-session JSON-RPC protocol without a JVM.- Astra validation: secure-connect bundle parsing and transport configuration;live Astra credentials were not available- Authentication: username/password and Kerberos/GSSAPI-- TLS: CA verification, optional client certificate/key, hostname verification+- TLS: CA verification, optional client certificate/key, JKS/PKCS#12 stores,+ hostname verification- Cloud: DataStax Astra secure connect bundles- Configuration: Java Driver 4 HOCON `configfile` mapping plus native extensions- Metadata: keyspaces, tables, columns, indexes, CQL table DDL, completion search@@ -38,6 +39,8 @@ syntax.| `enablessl` | TLS enablement || `sslenginefactory` | the standard `DefaultSslEngineFactory` maps to native TLS || `hostnameverification` | TLS hostname verification; enabled by default |+| `truststorepath`, `truststorepassword` | JKS/PKCS#12 server trust configuration |+| `keystorepath`, `keystorepassword` | JKS/PKCS#12 client certificate configuration || `user`, `password` | password authentication || `configfile` | Java Driver 4 HOCON configuration; overrides URL options except contact points and keyspace || `usekrb5` | Kerberos/GSSAPI authentication using password, keytab, or FILE credential cache |@@ -48,8 +51,8 @@ syntax.The Agent rejects custom Java implementation classes because they cannot beloaded by a native binary. This includes custom authentication, SSL, retry,-reconnection, and load-balancing classes. Java JKS/PKCS12 truststores and-keystores are not read directly; use the native PEM paths described below.+reconnection, and load-balancing classes. The default SSL engine's JKS and+PKCS#12 truststores and keystores are supported directly.## Java Driver HOCON configuration@@ -66,7 +69,8 @@ Mapped Java Driver paths include:- `advanced.socket.tcp-no-delay` and `keep-alive`- `advanced.protocol.version`, retry policy, and reconnection policy- `advanced.auth-provider` plaintext and Instaclustr Kerberos options-- `advanced.ssl-engine-factory` default TLS and hostname validation+- `advanced.ssl-engine-factory` default TLS, hostname validation, truststore,+ and keystore settingsNative-only settings can be placed under `dbx.cassandra`:@@ -133,7 +137,8 @@ go test -run TestCassandraIntegration -vOptional variables include `CASSANDRA_TEST_URL_PARAMS`, `CASSANDRA_TEST_SSL`,`CASSANDRA_TEST_CA_CERT_PATH`, `CASSANDRA_TEST_CLIENT_CERT_PATH`, and-`CASSANDRA_TEST_CLIENT_KEY_PATH`.+`CASSANDRA_TEST_CLIENT_KEY_PATH`. Truststore and keystore settings can also be+provided through `CASSANDRA_TEST_URL_PARAMS`.See `bench/README.md` for the archived JDBC comparison workflow and measuredCassandra 4.1.10 results.diff --git a/agents/drivers/cassandra-go/config.go b/agents/drivers/cassandra-go/config.goindex 39bd11d2e0..29b3d2d945 100644--- a/agents/drivers/cassandra-go/config.go+++ b/agents/drivers/cassandra-go/config.go@@ -31,6 +31,10 @@ type cassandraConfig struct {caCertPath stringclientCertPath stringclientKeyPath string+ truststorePath string+ truststorePassword string+ keystorePath string+ keystorePassword stringhostVerification booltcpNoDelay boolkeepAlive bool@@ -61,6 +65,10 @@ func parseCassandraConfig(cp connectParams) (cassandraConfig, error) {caCertPath: cp.CACertPath,clientCertPath: cp.ClientCertPath,clientKeyPath: cp.ClientKeyPath,+ truststorePath: cp.TruststorePath,+ truststorePassword: cp.TruststorePassword,+ keystorePath: cp.KeystorePath,+ keystorePassword: cp.KeystorePassword,hostVerification: true,tcpNoDelay: true,retryCount: 3,@@ -224,6 +232,14 @@ func applyCassandraURLParams(config *cassandraConfig, params url.Values) error {return fmt.Errorf("invalid host verification option: %w", err)}config.hostVerification = enabled+ case "truststorepath":+ config.truststorePath = value+ case "truststorepassword":+ config.truststorePassword = value+ case "keystorepath":+ config.keystorePath = value+ case "keystorepassword":+ config.keystorePassword = valuecase "tcpnodelay":enabled, err := strconv.ParseBool(value)if err != nil {@@ -406,12 +422,20 @@ func (config cassandraConfig) clusterConfig(keyspace string) (*gocql.ClusterConfcluster.Authenticator = gocql.PasswordAuthenticator{Username: config.username, Password: config.password}}if config.secureConnectBundle == "" && config.ssl {- cluster.SslOpts = &gocql.SslOptions{+ sslOptions := &gocql.SslOptions{CaPath: config.caCertPath,CertPath: config.clientCertPath,KeyPath: config.clientKeyPath,EnableHostVerification: config.hostVerification,}+ if config.truststorePath != "" || config.keystorePath != "" {+ tlsConfig, err := buildCassandraTLSConfig(config)+ if err != nil {+ return nil, err+ }+ sslOptions.Config = tlsConfig+ }+ cluster.SslOpts = sslOptions}if config.debug {cluster.Logger = gocql.NewLogger(gocql.LogLevelDebug)@@ -435,6 +459,31 @@ func (config *cassandraConfig) finalize() error {if err != nil {return fmt.Errorf("invalid Cassandra secureconnectbundle: %w", err)}+ if config.secureConnectBundle == "" {+ config.truststorePath, err = normalizeLocalFilePath(config.truststorePath)+ if err != nil {+ return fmt.Errorf("invalid Cassandra truststore path: %w", err)+ }+ config.keystorePath, err = normalizeLocalFilePath(config.keystorePath)+ if err != nil {+ return fmt.Errorf("invalid Cassandra keystore path: %w", err)+ }+ if config.truststorePassword != "" && config.truststorePath == "" {+ return fmt.Errorf("Cassandra truststore password requires a truststore path")+ }+ if config.keystorePassword != "" && config.keystorePath == "" {+ return fmt.Errorf("Cassandra keystore password requires a keystore path")+ }+ if config.truststorePath != "" && strings.TrimSpace(config.caCertPath) != "" {+ return fmt.Errorf("Cassandra truststore cannot be combined with a PEM CA certificate")+ }+ if config.keystorePath != "" && (strings.TrimSpace(config.clientCertPath) != "" || strings.TrimSpace(config.clientKeyPath) != "") {+ return fmt.Errorf("Cassandra keystore cannot be combined with PEM client certificate settings")+ }+ if config.truststorePath != "" || config.keystorePath != "" {+ config.ssl = true+ }+ }if config.secureConnectBundle != "" && config.kerberos.enabled {return fmt.Errorf("Cassandra secure connect bundles cannot be combined with Kerberos authentication")}diff --git a/agents/drivers/cassandra-go/config_file.go b/agents/drivers/cassandra-go/config_file.goindex d20b0d7a69..45686f66f3 100644--- a/agents/drivers/cassandra-go/config_file.go+++ b/agents/drivers/cassandra-go/config_file.go@@ -263,13 +263,25 @@ func applyHOCONSSL(config *cassandraConfig, parsed *hocon.Config) error {config.hostVerification = valueconfig.ssl = true}- for _, path := range []string{prefix + "truststore-path", prefix + "keystore-path"} {- if value, ok, err := hoconString(parsed, path); err != nil {+ stringMappings := []struct {+ path string+ target *string+ }{+ {prefix + "truststore-path", &config.truststorePath},+ {prefix + "truststore-password", &config.truststorePassword},+ {prefix + "keystore-path", &config.keystorePath},+ {prefix + "keystore-password", &config.keystorePassword},+ }+ for _, mapping := range stringMappings {+ if value, ok, err := hoconString(parsed, mapping.path); err != nil {return err- } else if ok && value != "" {- return fmt.Errorf("Java truststore and keystore files are not supported; use dbx.cassandra.tls PEM paths")+ } else if ok {+ *mapping.target = value}}+ if config.truststorePath != "" || config.keystorePath != "" {+ config.ssl = true+ }return nil}diff --git a/agents/drivers/cassandra-go/config_file_test.go b/agents/drivers/cassandra-go/config_file_test.goindex ee9aec2351..c56d7dbb03 100644--- a/agents/drivers/cassandra-go/config_file_test.go+++ b/agents/drivers/cassandra-go/config_file_test.go@@ -52,6 +52,10 @@ datastax-java-driver {ssl-engine-factory {class = DefaultSslEngineFactoryhostname-validation = false+ truststore-path = /certs/client.truststore+ truststore-password = trust-secret+ keystore-path = /certs/client.keystore+ keystore-password = key-secret}}}@@ -110,6 +114,12 @@ datastax-java-driver {if !config.ssl || config.hostVerification {t.Fatalf("unexpected TLS config: %#v", config)}+ if config.truststorePath != filepath.Clean("/certs/client.truststore") || config.truststorePassword != "trust-secret" {+ t.Fatalf("unexpected truststore config: %#v", config)+ }+ if config.keystorePath != filepath.Clean("/certs/client.keystore") || config.keystorePassword != "key-secret" {+ t.Fatalf("unexpected keystore config: %#v", config)+ }}func TestCassandraConfigFileSupportsKerberosLoginOptionCasing(t *testing.T) {diff --git a/agents/drivers/cassandra-go/go.mod b/agents/drivers/cassandra-go/go.modindex f2929f5d59..0d5a8a130d 100644--- a/agents/drivers/cassandra-go/go.mod+++ b/agents/drivers/cassandra-go/go.mod@@ -8,6 +8,8 @@ require (github.com/gurkankaymak/hocon v1.3.0github.com/jcmturner/gofork v1.7.6github.com/jcmturner/gokrb5/v8 v8.4.4+ github.com/pavlo-v-chernykh/keystore-go/v4 v4.5.0+ software.sslmate.com/src/go-pkcs12 v0.7.3)require (@@ -23,7 +25,7 @@ require (github.com/jcmturner/rpc/v2 v2.0.3 // indirectgo.uber.org/multierr v1.10.0 // indirectgo.uber.org/zap v1.27.0 // indirect- golang.org/x/crypto v0.6.0 // indirect- golang.org/x/net v0.7.0 // indirect+ golang.org/x/crypto v0.11.0 // indirect+ golang.org/x/net v0.10.0 // indirectgopkg.in/inf.v0 v0.9.1 // indirect)diff --git a/agents/drivers/cassandra-go/go.sum b/agents/drivers/cassandra-go/go.sumindex 511d4254cb..4716ad695e 100644--- a/agents/drivers/cassandra-go/go.sum+++ b/agents/drivers/cassandra-go/go.sum@@ -45,6 +45,8 @@ github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecgithub.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=+github.com/pavlo-v-chernykh/keystore-go/v4 v4.5.0 h1:2nosf3P75OZv2/ZO/9Px5ZgZ5gbKrzA3joN1QMfOGMQ=+github.com/pavlo-v-chernykh/keystore-go/v4 v4.5.0/go.mod h1:lAVhWwbNaveeJmxrxuSTxMgKpF6DjnuVpn6T8WiBwYQ=github.com/pierrec/lz4/v4 v4.1.8 h1:ieHkV+i2BRzngO4Wd/3HGowuZStgq6QkPsD1eolNAO4=github.com/pierrec/lz4/v4 v4.1.8/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=@@ -74,16 +76,18 @@ go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8=go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=-golang.org/x/crypto v0.6.0 h1:qfktjS5LUO+fFKeJXZ+ikTRijMmljikvG68fpMMruSc=golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58=+golang.org/x/crypto v0.11.0 h1:6Ewdq3tDic1mg5xRO4milcWCfMVQhI4NkqWWvqejpuA=+golang.org/x/crypto v0.11.0/go.mod h1:xgJhtzW8F9jGdVFWZESrid1U1bjeNy4zgy5cRr/CIio=golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=-golang.org/x/net v0.7.0 h1:rJrUqqhjsgNp7KqAIc25s9pZnjU7TUcSY7HcVZjdn1g=golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=+golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M=+golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=@@ -112,3 +116,5 @@ gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=+software.sslmate.com/src/go-pkcs12 v0.7.3 h1:JBQD3FDqYjTeyDAeZQklj2ar88ykBLtALloPJHyAauU=+software.sslmate.com/src/go-pkcs12 v0.7.3/go.mod h1:Qiz0EyvDRJjjxGyUQa2cCNZn/wMyzrRJ/qcDXOQazLI=diff --git a/agents/drivers/cassandra-go/main.go b/agents/drivers/cassandra-go/main.goindex b12fc1a4d3..fc264cb690 100644--- a/agents/drivers/cassandra-go/main.go+++ b/agents/drivers/cassandra-go/main.go@@ -35,18 +35,22 @@ type response struct {}type connectParams struct {- Host string `json:"host"`- Port int `json:"port"`- Database string `json:"database"`- Username string `json:"username"`- Password string `json:"password"`- URLParams string `json:"url_params"`- ConnectionString string `json:"connection_string"`- SSL bool `json:"ssl"`- CACertPath string `json:"ca_cert_path"`- ClientCertPath string `json:"client_cert_path"`- ClientKeyPath string `json:"client_key_path"`- SessionRole string `json:"sessionRole"`+ Host string `json:"host"`+ Port int `json:"port"`+ Database string `json:"database"`+ Username string `json:"username"`+ Password string `json:"password"`+ URLParams string `json:"url_params"`+ ConnectionString string `json:"connection_string"`+ SSL bool `json:"ssl"`+ CACertPath string `json:"ca_cert_path"`+ ClientCertPath string `json:"client_cert_path"`+ ClientKeyPath string `json:"client_key_path"`+ TruststorePath string `json:"truststore_path"`+ TruststorePassword string `json:"truststore_password"`+ KeystorePath string `json:"keystore_path"`+ KeystorePassword string `json:"keystore_password"`+ SessionRole string `json:"sessionRole"`}type queryOptions struct {diff --git a/agents/drivers/cassandra-go/tls_stores.go b/agents/drivers/cassandra-go/tls_stores.gonew file mode 100644index 0000000000..b8ab90feee--- /dev/null+++ b/agents/drivers/cassandra-go/tls_stores.go@@ -0,0 +1,181 @@+package main++import (+ "bytes"+ "crypto/tls"+ "crypto/x509"+ "encoding/binary"+ "errors"+ "fmt"+ "os"++ keystore "github.com/pavlo-v-chernykh/keystore-go/v4"+ pkcs12 "software.sslmate.com/src/go-pkcs12"+)++const jksMagic = 0xfeedfeed++func buildCassandraTLSConfig(config cassandraConfig) (*tls.Config, error) {+ tlsConfig := &tls.Config{InsecureSkipVerify: !config.hostVerification}+ if config.truststorePath != "" {+ certificates, err := loadTruststore(config.truststorePath, config.truststorePassword)+ if err != nil {+ return nil, fmt.Errorf("load Cassandra truststore %q: %w", config.truststorePath, err)+ }+ roots := x509.NewCertPool()+ for _, certificate := range certificates {+ roots.AddCert(certificate)+ }+ tlsConfig.RootCAs = roots+ }+ if config.keystorePath != "" {+ certificate, err := loadKeystore(config.keystorePath, config.keystorePassword)+ if err != nil {+ return nil, fmt.Errorf("load Cassandra keystore %q: %w", config.keystorePath, err)+ }+ tlsConfig.Certificates = []tls.Certificate{certificate}+ }+ return tlsConfig, nil+}++func loadTruststore(path string, password string) ([]*x509.Certificate, error) {+ data, err := os.ReadFile(path)+ if err != nil {+ return nil, err+ }+ if isJKS(data) {+ return loadJKSTruststore(data, password)+ }+ certificates, err := pkcs12.DecodeTrustStore(data, password)+ if err == nil && len(certificates) > 0 {+ return certificates, nil+ }+ _, certificate, chain, chainErr := pkcs12.DecodeChain(data, password)+ if chainErr != nil {+ if err != nil {+ return nil, fmt.Errorf("decode PKCS#12 truststore: %w", err)+ }+ return nil, fmt.Errorf("PKCS#12 truststore contains no trusted certificates")+ }+ return append([]*x509.Certificate{certificate}, chain...), nil+}++func loadKeystore(path string, password string) (tls.Certificate, error) {+ data, err := os.ReadFile(path)+ if err != nil {+ return tls.Certificate{}, err+ }+ if isJKS(data) {+ return loadJKSKeystore(data, password)+ }+ privateKey, certificate, caCertificates, err := pkcs12.DecodeChain(data, password)+ if err != nil {+ return tls.Certificate{}, fmt.Errorf("decode PKCS#12 keystore: %w", err)+ }+ chain := make([][]byte, 0, 1+len(caCertificates))+ chain = append(chain, certificate.Raw)+ for _, caCertificate := range caCertificates {+ chain = append(chain, caCertificate.Raw)+ }+ return tls.Certificate{Certificate: chain, PrivateKey: privateKey, Leaf: certificate}, nil+}++func isJKS(data []byte) bool {+ return len(data) >= 4 && binary.BigEndian.Uint32(data[:4]) == jksMagic+}++func loadJKS(data []byte, password string) (keystore.KeyStore, error) {+ store := keystore.New()+ passwordBytes := []byte(password)+ defer clear(passwordBytes)+ if err := store.Load(bytes.NewReader(data), passwordBytes); err != nil {+ return keystore.KeyStore{}, fmt.Errorf("decode JKS: %w", err)+ }+ return store, nil+}++func loadJKSTruststore(data []byte, password string) ([]*x509.Certificate, error) {+ store, err := loadJKS(data, password)+ if err != nil {+ return nil, err+ }+ certificates := make([]*x509.Certificate, 0)+ for _, alias := range store.Aliases() {+ switch {+ case store.IsTrustedCertificateEntry(alias):+ entry, err := store.GetTrustedCertificateEntry(alias)+ if err != nil {+ return nil, fmt.Errorf("read trusted certificate %q: %w", alias, err)+ }+ certificate, err := x509.ParseCertificate(entry.Certificate.Content)+ if err != nil {+ return nil, fmt.Errorf("parse trusted certificate %q: %w", alias, err)+ }+ certificates = append(certificates, certificate)+ case store.IsPrivateKeyEntry(alias):+ chain, err := store.GetPrivateKeyEntryCertificateChain(alias)+ if err != nil {+ return nil, fmt.Errorf("read certificate chain %q: %w", alias, err)+ }+ for _, entry := range chain {+ certificate, err := x509.ParseCertificate(entry.Content)+ if err != nil {+ return nil, fmt.Errorf("parse certificate chain %q: %w", alias, err)+ }+ certificates = append(certificates, certificate)+ }+ }+ }+ if len(certificates) == 0 {+ return nil, fmt.Errorf("JKS truststore contains no trusted certificates")+ }+ return certificates, nil+}++func loadJKSKeystore(data []byte, password string) (tls.Certificate, error) {+ store, err := loadJKS(data, password)+ if err != nil {+ return tls.Certificate{}, err+ }+ passwordBytes := []byte(password)+ defer clear(passwordBytes)+ for _, alias := range store.Aliases() {+ if !store.IsPrivateKeyEntry(alias) {+ continue+ }+ entry, err := store.GetPrivateKeyEntry(alias, passwordBytes)+ if err != nil {+ return tls.Certificate{}, fmt.Errorf("read private key %q: %w", alias, err)+ }+ privateKey, err := parsePrivateKey(entry.PrivateKey)+ if err != nil {+ return tls.Certificate{}, fmt.Errorf("parse private key %q: %w", alias, err)+ }+ chain := make([][]byte, 0, len(entry.CertificateChain))+ for _, certificate := range entry.CertificateChain {+ chain = append(chain, certificate.Content)+ }+ if len(chain) == 0 {+ return tls.Certificate{}, fmt.Errorf("private key %q has no certificate chain", alias)+ }+ leaf, err := x509.ParseCertificate(chain[0])+ if err != nil {+ return tls.Certificate{}, fmt.Errorf("parse client certificate %q: %w", alias, err)+ }+ return tls.Certificate{Certificate: chain, PrivateKey: privateKey, Leaf: leaf}, nil+ }+ return tls.Certificate{}, fmt.Errorf("JKS keystore contains no private key entries")+}++func parsePrivateKey(data []byte) (any, error) {+ if value, err := x509.ParsePKCS8PrivateKey(data); err == nil {+ return value, nil+ }+ if value, err := x509.ParsePKCS1PrivateKey(data); err == nil {+ return value, nil+ }+ if value, err := x509.ParseECPrivateKey(data); err == nil {+ return value, nil+ }+ return nil, errors.New("unsupported private key encoding")+}diff --git a/agents/drivers/cassandra-go/tls_stores_test.go b/agents/drivers/cassandra-go/tls_stores_test.gonew file mode 100644index 0000000000..1968177bf0--- /dev/null+++ b/agents/drivers/cassandra-go/tls_stores_test.go@@ -0,0 +1,152 @@+package main++import (+ "bytes"+ "crypto/ecdsa"+ "crypto/elliptic"+ "crypto/rand"+ "crypto/x509"+ "crypto/x509/pkix"+ "math/big"+ "net/url"+ "os"+ "path/filepath"+ "testing"+ "time"++ keystore "github.com/pavlo-v-chernykh/keystore-go/v4"+ pkcs12 "software.sslmate.com/src/go-pkcs12"+)++const tlsStoreTestPassword = "changeit"++func TestLoadJKSStores(t *testing.T) {+ _, certificate, privateKeyDER := testTLSIdentity(t)+ store := keystore.New()+ if err := store.SetTrustedCertificateEntry("ca", keystore.TrustedCertificateEntry{+ CreationTime: time.Now(),+ Certificate: keystore.Certificate{Type: "X509", Content: certificate.Raw},+ }); err != nil {+ t.Fatal(err)+ }+ if err := store.SetPrivateKeyEntry("client", keystore.PrivateKeyEntry{+ CreationTime: time.Now(),+ PrivateKey: privateKeyDER,+ CertificateChain: []keystore.Certificate{+ {Type: "X509", Content: certificate.Raw},+ },+ }, []byte(tlsStoreTestPassword)); err != nil {+ t.Fatal(err)+ }+ var encoded bytes.Buffer+ if err := store.Store(&encoded, []byte(tlsStoreTestPassword)); err != nil {+ t.Fatal(err)+ }+ path := filepath.Join(t.TempDir(), "client.jks")+ if err := os.WriteFile(path, encoded.Bytes(), 0o600); err != nil {+ t.Fatal(err)+ }++ trusted, err := loadTruststore(path, tlsStoreTestPassword)+ if err != nil {+ t.Fatal(err)+ }+ identity, err := loadKeystore(path, tlsStoreTestPassword)+ if err != nil {+ t.Fatal(err)+ }+ if len(trusted) != 2 || identity.Leaf == nil {+ t.Fatalf("unexpected JKS contents: trusted=%d identity=%#v", len(trusted), identity)+ }+}++func TestLoadPKCS12Stores(t *testing.T) {+ privateKey, certificate, _ := testTLSIdentity(t)+ truststore, err := pkcs12.Modern.EncodeTrustStore([]*x509.Certificate{certificate}, tlsStoreTestPassword)+ if err != nil {+ t.Fatal(err)+ }+ keystoreData, err := pkcs12.Modern.Encode(privateKey, certificate, nil, tlsStoreTestPassword)+ if err != nil {+ t.Fatal(err)+ }+ directory := t.TempDir()+ truststorePath := filepath.Join(directory, "client-trust.p12")+ keystorePath := filepath.Join(directory, "client-key.p12")+ if err := os.WriteFile(truststorePath, truststore, 0o600); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(keystorePath, keystoreData, 0o600); err != nil {+ t.Fatal(err)+ }++ tlsConfig, err := buildCassandraTLSConfig(cassandraConfig{+ truststorePath: truststorePath,+ truststorePassword: tlsStoreTestPassword,+ keystorePath: keystorePath,+ keystorePassword: tlsStoreTestPassword,+ hostVerification: true,+ })+ if err != nil {+ t.Fatal(err)+ }+ if tlsConfig.RootCAs == nil || len(tlsConfig.Certificates) != 1 || tlsConfig.InsecureSkipVerify {+ t.Fatalf("unexpected PKCS#12 TLS config: %#v", tlsConfig)+ }+}++func TestParseCassandraConfigRejectsStorePasswordWithoutPath(t *testing.T) {+ _, err := parseCassandraConfig(connectParams{Host: "localhost", TruststorePassword: "secret"})+ if err == nil {+ t.Fatal("expected truststore path validation error")+ }+}++func TestSecureConnectBundleIgnoresManualTLSStoreSettings(t *testing.T) {+ config, err := parseCassandraConfig(connectParams{+ Username: "token",+ Password: "secret",+ CACertPath: "ca.pem",+ URLParams: url.Values{+ "secureconnectbundle": []string{"bundle.zip"},+ "truststorepath": []string{"https://ignored.example/truststore"},+ "truststorepassword": []string{"ignored"},+ }.Encode(),+ })+ if err != nil {+ t.Fatal(err)+ }+ if config.secureConnectBundle != "bundle.zip" {+ t.Fatalf("unexpected secure connect bundle: %q", config.secureConnectBundle)+ }+}++func testTLSIdentity(t *testing.T) (*ecdsa.PrivateKey, *x509.Certificate, []byte) {+ t.Helper()+ privateKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)+ if err != nil {+ t.Fatal(err)+ }+ template := &x509.Certificate{+ SerialNumber: big.NewInt(1),+ Subject: pkix.Name{CommonName: "cassandra-client"},+ NotBefore: time.Now().Add(-time.Hour),+ NotAfter: time.Now().Add(time.Hour),+ KeyUsage: x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,+ ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth},+ IsCA: true,+ }+ certificateDER, err := x509.CreateCertificate(rand.Reader, template, template, &privateKey.PublicKey, privateKey)+ if err != nil {+ t.Fatal(err)+ }+ certificate, err := x509.ParseCertificate(certificateDER)+ if err != nil {+ t.Fatal(err)+ }+ privateKeyDER, err := x509.MarshalPKCS8PrivateKey(privateKey)+ if err != nil {+ t.Fatal(err)+ }+ return privateKey, certificate, privateKeyDER+}diff --git a/apps/desktop/src/components/connection/ConnectionDialog.vue b/apps/desktop/src/components/connection/ConnectionDialog.vueindex dd7fc9e95c..e9a20f7525 100644--- a/apps/desktop/src/components/connection/ConnectionDialog.vue+++ b/apps/desktop/src/components/connection/ConnectionDialog.vue@@ -62,6 +62,7 @@ import { SQLITE_DATABASE_FILE_EXTENSIONS } from "@/lib/database/databaseFileDeteimport { connectionAttemptOriginalErrorMessage, connectionAttemptTimeoutMessage, connectionAttemptTimeoutMs } from "@/lib/connection/connectionAttemptTimeout";import { consulAgentAddressesMatch } from "@/lib/consul/agentTarget";import { appendConnectionErrorHints, isJdbcMissingRuntimeDependencyError } from "@/lib/connection/connectionErrorHints";+import { buildCassandraExternalConfig, cassandraTlsConfigFromExternalConfig, type CassandraTlsConfig } from "@/lib/connection/cassandraTlsOptions";import { preventDialogDocumentSelectAll } from "@/lib/connection/dialogTextSelection";import { postgresLegacyTlsEnabled, postgresTlsModeForForm, setPostgresLegacyTlsEnabled } from "@/lib/connection/postgresTlsMode";import { buildMqKafkaConnectionExtra, mqKafkaConnectionTarget, resolveMqKafkaConnectionSource, type MqKafkaConnectionSource } from "@/lib/connection/mqKafkaConnection";@@ -396,6 +397,12 @@ const defaultForm = (): ConnectionForm => ({save_password: true,});+const cassandraTls = reactive<CassandraTlsConfig>(cassandraTlsConfigFromExternalConfig(undefined));++function resetCassandraTlsFields(externalConfig: unknown) {+ Object.assign(cassandraTls, cassandraTlsConfigFromExternalConfig(externalConfig));+}+const elasticsearchConnectionMode = ref<ElasticsearchConnectionMode>("direct");const elasticsearchKibanaBasePath = ref("");const elasticsearchConnectivityCheckPath = ref("");@@ -2333,6 +2340,9 @@ function applyProfile(val: string, preserveConnectionFields = false) {if (profile.type !== "elasticsearch" || previousDatabaseType !== "elasticsearch") {resetElasticsearchProxyFields();}+ if (profile.type !== "cassandra" || previousDatabaseType !== "cassandra") {+ resetCassandraTlsFields(undefined);+ }if (!preserveConnectionFields) {oracleTnsAdminPath.value = "";form.value.port = profile.port;@@ -2572,6 +2582,7 @@ watch(} else {resetMqFields();}+ resetCassandraTlsFields(config.db_type === "cassandra" ? config.external_config : undefined);if (config.db_type === "nacos") {hydrateNacosFields(config.external_config);} else {@@ -2643,6 +2654,7 @@ watch(selectedType.value = "mysql";customDriverName.value = "";resetMqFields();+ resetCassandraTlsFields(undefined);resetNacosFields();resetInfluxDbFields();resetElasticsearchProxyFields();@@ -3012,6 +3024,7 @@ const tlsCapableDatabaseTypes = new Set<DatabaseType>(["chromadb","influxdb","victoriametrics",+ "cassandra",]);const supportsTlsToggle = computed(() => tlsCapableDatabaseTypes.has(form.value.db_type));const supportsCaCertificatePath = computed(() => form.value.db_type === "clickhouse" || form.value.db_type === "victoriametrics");@@ -3922,6 +3935,20 @@ function connectionConfigForSubmit(id: string, generatedName = ""): ConnectionCoconfig.database = undefined;config.connection_string = undefined;config.url_params = "";+ } else if (config.db_type === "cassandra") {+ // Go 侧在配置了 truststore/keystore 时会自动启用 TLS,前端保持一致:有 store 配置就不丢弃 external_config。+ const cassandraHasTlsStore = Boolean(cassandraTls.truststore_path.trim() || cassandraTls.truststore_password) || Boolean(cassandraTls.keystore_path.trim() || cassandraTls.keystore_password);+ if (!config.ssl && !cassandraHasTlsStore) {+ config.external_config = undefined;+ } else {+ if (cassandraTls.truststore_password && !cassandraTls.truststore_path.trim()) {+ throw new Error(t("connection.cassandraTruststorePasswordRequiresPath"));+ }+ if (cassandraTls.keystore_password && !cassandraTls.keystore_path.trim()) {+ throw new Error(t("connection.cassandraKeystorePasswordRequiresPath"));+ }+ config.external_config = buildCassandraExternalConfig(cassandraTls);+ }} else if (config.db_type === "nacos") {const nacosConfig = buildNacosAdminConfig();config.external_config = nacosConfig;@@ -5476,6 +5503,23 @@ async function browseCaCertPath() {}}+async function browseCassandraStore(target: "truststore" | "keystore") {+ if (!isTauriRuntime()) return;+ const { open } = await import("@tauri-apps/plugin-dialog");+ const selected = await open({+ title: target === "truststore" ? t("connection.cassandraTruststoreBrowse") : t("connection.cassandraKeystoreBrowse"),+ multiple: false,+ filters: [+ { name: "Java KeyStore / PKCS#12", extensions: ["jks", "p12", "pfx", "truststore", "keystore"] },+ { name: "All Files", extensions: ["*"] },+ ],+ });+ if (typeof selected === "string") {+ if (target === "truststore") cassandraTls.truststore_path = selected;+ else cassandraTls.keystore_path = selected;+ }+}+async function browseDamengSslFilesPath() {if (isTauriRuntime()) {const { open } = await import("@tauri-apps/plugin-dialog");@@ -7913,6 +7957,56 @@ function openExternalUrl(url: string) {</div></template>+ <template v-if="form.db_type === 'cassandra'">+ <div class="grid grid-cols-4 items-start gap-4">+ <Label :class="connectionLabelSmallPaddedClass">+ <span class="inline-flex items-center justify-end gap-1">+ <ShieldCheck class="h-3.5 w-3.5" />+ {{ t("connection.cassandraTruststore") }}+ </span>+ </Label>+ <div class="col-span-3 grid gap-2">+ <div class="flex items-center gap-1">+ <Input v-model="cassandraTls.truststore_path" class="flex-1" :placeholder="t('connection.cassandraTruststorePlaceholder')" :disabled="!tlsEnabled" />+ <Tooltip v-if="isDesktop">+ <TooltipTrigger as-child>+ <Button variant="outline" size="icon" class="h-9 w-9 shrink-0" :disabled="!tlsEnabled" @click="browseCassandraStore('truststore')">+ <FolderOpen class="h-4 w-4" />+ </Button>+ </TooltipTrigger>+ <TooltipContent>{{ t("connection.cassandraTruststoreBrowse") }}</TooltipContent>+ </Tooltip>+ </div>+ <PasswordInput v-model="cassandraTls.truststore_password" :placeholder="t('connection.cassandraTruststorePassword')" :disabled="!tlsEnabled" />+ <p class="text-[11px] leading-4 text-muted-foreground">{{ t("connection.cassandraTruststoreHint") }}</p>+ </div>+ </div>++ <div class="grid grid-cols-4 items-start gap-4">+ <Label :class="connectionLabelSmallPaddedClass">+ <span class="inline-flex items-center justify-end gap-1">+ <KeyRound class="h-3.5 w-3.5" />+ {{ t("connection.cassandraKeystore") }}+ </span>+ </Label>+ <div class="col-span-3 grid gap-2">+ <div class="flex items-center gap-1">+ <Input v-model="cassandraTls.keystore_path" class="flex-1" :placeholder="t('connection.cassandraKeystorePlaceholder')" :disabled="!tlsEnabled" />+ <Tooltip v-if="isDesktop">+ <TooltipTrigger as-child>+ <Button variant="outline" size="icon" class="h-9 w-9 shrink-0" :disabled="!tlsEnabled" @click="browseCassandraStore('keystore')">+ <FolderOpen class="h-4 w-4" />+ </Button>+ </TooltipTrigger>+ <TooltipContent>{{ t("connection.cassandraKeystoreBrowse") }}</TooltipContent>+ </Tooltip>+ </div>+ <PasswordInput v-model="cassandraTls.keystore_password" :placeholder="t('connection.cassandraKeystorePassword')" :disabled="!tlsEnabled" />+ <p class="text-[11px] leading-4 text-muted-foreground">{{ t("connection.cassandraKeystoreHint") }}</p>+ </div>+ </div>+ </template>+<div v-if="form.db_type === 'redis'" class="grid grid-cols-4 items-start gap-4"><Label :class="connectionLabelSmallClass">{{ t("connection.redisTlsInsecure") }}</Label><label class="col-span-3 flex items-start gap-2 cursor-pointer">diff --git a/apps/desktop/src/i18n/locales/az.ts b/apps/desktop/src/i18n/locales/az.tsindex 679eb573af..b839fe8bdb 100644--- a/apps/desktop/src/i18n/locales/az.ts+++ b/apps/desktop/src/i18n/locales/az.ts@@ -566,6 +566,18 @@ export default withEnglishFallback({caCertPath: "CA sertifikatı",caCertPathPlaceholder: "İstəyə bağlı, məsələn, ~/.yandex/RootCA.crt",caCertPathBrowse: "Sertifikat seç",+ cassandraTruststore: "Etibar anbarı",+ cassandraTruststorePlaceholder: "/path/to/client.truststore",+ cassandraTruststorePassword: "Etibar anbarı parolu",+ cassandraTruststoreBrowse: "Cassandra etibar anbarını seçin",+ cassandraTruststoreHint: "Cassandra server sertifikatlarını yoxlamaq üçün JKS və ya PKCS#12 etibar anbarı.",+ cassandraTruststorePasswordRequiresPath: "Parolu daxil etməzdən əvvəl Cassandra etibar anbarını seçin.",+ cassandraKeystore: "Müştəri açarlar anbarı",+ cassandraKeystorePlaceholder: "/path/to/client.keystore",+ cassandraKeystorePassword: "Açarlar anbarı parolu",+ cassandraKeystoreBrowse: "Cassandra müştəri açarlar anbarını seçin",+ cassandraKeystoreHint: "Müştəri sertifikatı ilə identifikasiya üçün istəyə bağlı JKS və ya PKCS#12 açarlar anbarı.",+ cassandraKeystorePasswordRequiresPath: "Parolu daxil etməzdən əvvəl Cassandra müştəri açarlar anbarını seçin.",damengSslFilesPath: "Sertifikat qovluğu",damengSslFilesPathPlaceholder: "/path/to/dmcert",damengSslFilesPathBrowse: "Sertifikat qovluğunu seçin",diff --git a/apps/desktop/src/i18n/locales/en.ts b/apps/desktop/src/i18n/locales/en.tsindex 424d2ba0f4..50052e9d72 100644--- a/apps/desktop/src/i18n/locales/en.ts+++ b/apps/desktop/src/i18n/locales/en.ts@@ -567,6 +567,18 @@ export default {caCertPath: "CA Certificate",caCertPathPlaceholder: "Optional, e.g. ~/.yandex/RootCA.crt",caCertPathBrowse: "Browse certificate",+ cassandraTruststore: "Truststore",+ cassandraTruststorePlaceholder: "/path/to/client.truststore",+ cassandraTruststorePassword: "Truststore password",+ cassandraTruststoreBrowse: "Choose Cassandra truststore",+ cassandraTruststoreHint: "JKS or PKCS#12 truststore used to verify Cassandra server certificates.",+ cassandraTruststorePasswordRequiresPath: "Select a Cassandra truststore before entering its password.",+ cassandraKeystore: "Client Keystore",+ cassandraKeystorePlaceholder: "/path/to/client.keystore",+ cassandraKeystorePassword: "Keystore password",+ cassandraKeystoreBrowse: "Choose Cassandra client keystore",+ cassandraKeystoreHint: "Optional JKS or PKCS#12 keystore for client certificate authentication.",+ cassandraKeystorePasswordRequiresPath: "Select a Cassandra client keystore before entering its password.",damengSslFilesPath: "Certificate directory",damengSslFilesPathPlaceholder: "/path/to/dmcert",damengSslFilesPathBrowse: "Select certificate directory",diff --git a/apps/desktop/src/i18n/locales/es.ts b/apps/desktop/src/i18n/locales/es.tsindex ec9278faa2..f01b9f1265 100644--- a/apps/desktop/src/i18n/locales/es.ts+++ b/apps/desktop/src/i18n/locales/es.ts@@ -546,6 +546,18 @@ export default withEnglishFallback({caCertPath: "Certificado CA",caCertPathPlaceholder: "Opcional, p. ej. ~/.yandex/RootCA.crt",caCertPathBrowse: "Buscar certificado",+ cassandraTruststore: "Almacén de confianza",+ cassandraTruststorePlaceholder: "/ruta/al/client.truststore",+ cassandraTruststorePassword: "Contraseña del almacén de confianza",+ cassandraTruststoreBrowse: "Elegir almacén de confianza de Cassandra",+ cassandraTruststoreHint: "Almacén de confianza JKS o PKCS#12 usado para verificar los certificados del servidor Cassandra.",+ cassandraTruststorePasswordRequiresPath: "Selecciona un almacén de confianza de Cassandra antes de introducir su contraseña.",+ cassandraKeystore: "Almacén de claves del cliente",+ cassandraKeystorePlaceholder: "/ruta/al/client.keystore",+ cassandraKeystorePassword: "Contraseña del almacén de claves",+ cassandraKeystoreBrowse: "Elegir almacén de claves de cliente de Cassandra",+ cassandraKeystoreHint: "Almacén de claves JKS o PKCS#12 opcional para la autenticación con certificado de cliente.",+ cassandraKeystorePasswordRequiresPath: "Selecciona un almacén de claves de cliente de Cassandra antes de introducir su contraseña.",damengSslFilesPath: "Directorio de certificados",damengSslFilesPathPlaceholder: "/path/to/dmcert",damengSslFilesPathBrowse: "Seleccionar directorio de certificados",diff --git a/apps/desktop/src/i18n/locales/it.ts b/apps/desktop/src/i18n/locales/it.tsindex b81c87db2d..9c1df9adfe 100644--- a/apps/desktop/src/i18n/locales/it.ts+++ b/apps/desktop/src/i18n/locales/it.ts@@ -545,6 +545,18 @@ export default withEnglishFallback({caCertPath: "Certificato CA",caCertPathPlaceholder: "Opzionale, es. ~/.yandex/RootCA.crt",caCertPathBrowse: "Sfoglia certificato",+ cassandraTruststore: "Truststore",+ cassandraTruststorePlaceholder: "/percorso/di/client.truststore",+ cassandraTruststorePassword: "Password del truststore",+ cassandraTruststoreBrowse: "Scegli truststore Cassandra",+ cassandraTruststoreHint: "Truststore JKS o PKCS#12 usato per verificare i certificati del server Cassandra.",+ cassandraTruststorePasswordRequiresPath: "Seleziona un truststore Cassandra prima di inserirne la password.",+ cassandraKeystore: "Keystore client",+ cassandraKeystorePlaceholder: "/percorso/di/client.keystore",+ cassandraKeystorePassword: "Password del keystore",+ cassandraKeystoreBrowse: "Scegli keystore client Cassandra",+ cassandraKeystoreHint: "Keystore JKS o PKCS#12 facoltativo per l'autenticazione con certificato client.",+ cassandraKeystorePasswordRequiresPath: "Seleziona un keystore client Cassandra prima di inserirne la password.",damengSslFilesPath: "Directory certificati",damengSslFilesPathPlaceholder: "/path/to/dmcert",damengSslFilesPathBrowse: "Seleziona directory certificati",diff --git a/apps/desktop/src/i18n/locales/ja.ts b/apps/desktop/src/i18n/locales/ja.tsindex 7335d2a405..af9656e501 100644--- a/apps/desktop/src/i18n/locales/ja.ts+++ b/apps/desktop/src/i18n/locales/ja.ts@@ -545,6 +545,18 @@ export default withEnglishFallback({caCertPath: "CA証明書",caCertPathPlaceholder: "任意、例: ~/.yandex/RootCA.crt",caCertPathBrowse: "証明書を参照",+ cassandraTruststore: "トラストストア",+ cassandraTruststorePlaceholder: "/path/to/client.truststore",+ cassandraTruststorePassword: "トラストストアのパスワード",+ cassandraTruststoreBrowse: "Cassandra トラストストアを選択",+ cassandraTruststoreHint: "Cassandra サーバー証明書の検証に使用する JKS または PKCS#12 トラストストア。",+ cassandraTruststorePasswordRequiresPath: "パスワードを入力する前に Cassandra トラストストアを選択してください。",+ cassandraKeystore: "クライアントキーストア",+ cassandraKeystorePlaceholder: "/path/to/client.keystore",+ cassandraKeystorePassword: "キーストアのパスワード",+ cassandraKeystoreBrowse: "Cassandra クライアントキーストアを選択",+ cassandraKeystoreHint: "クライアント証明書認証用のオプションの JKS / PKCS#12 キーストア。",+ cassandraKeystorePasswordRequiresPath: "パスワードを入力する前に Cassandra クライアントキーストアを選択してください。",damengSslFilesPath: "証明書ディレクトリ",damengSslFilesPathPlaceholder: "/path/to/dmcert",damengSslFilesPathBrowse: "証明書ディレクトリを選択",diff --git a/apps/desktop/src/i18n/locales/ko.ts b/apps/desktop/src/i18n/locales/ko.tsindex deeb4a3adb..dd7989be2d 100644--- a/apps/desktop/src/i18n/locales/ko.ts+++ b/apps/desktop/src/i18n/locales/ko.ts@@ -561,6 +561,18 @@ export default withEnglishFallback({caCertPath: "CA 인증서",caCertPathPlaceholder: "선택, 예: ~/.yandex/RootCA.crt",caCertPathBrowse: "인증서 찾아보기",+ cassandraTruststore: "트러스트스토어",+ cassandraTruststorePlaceholder: "/path/to/client.truststore",+ cassandraTruststorePassword: "트러스트스토어 비밀번호",+ cassandraTruststoreBrowse: "Cassandra 트러스트스토어 선택",+ cassandraTruststoreHint: "Cassandra 서버 인증서를 검증하는 JKS 또는 PKCS#12 트러스트스토어.",+ cassandraTruststorePasswordRequiresPath: "비밀번호를 입력하기 전에 Cassandra 트러스트스토어를 먼저 선택하세요.",+ cassandraKeystore: "클라이언트 키스토어",+ cassandraKeystorePlaceholder: "/path/to/client.keystore",+ cassandraKeystorePassword: "키스토어 비밀번호",+ cassandraKeystoreBrowse: "Cassandra 클라이언트 키스토어 선택",+ cassandraKeystoreHint: "클라이언트 인증서 인증용 선택적 JKS / PKCS#12 키스토어.",+ cassandraKeystorePasswordRequiresPath: "비밀번호를 입력하기 전에 Cassandra 클라이언트 키스토어를 먼저 선택하세요.",damengSslFilesPath: "인증서 디렉터리",damengSslFilesPathPlaceholder: "/path/to/dmcert",damengSslFilesPathBrowse: "인증서 디렉터리 선택",diff --git a/apps/desktop/src/i18n/locales/pt-BR.ts b/apps/desktop/src/i18n/locales/pt-BR.tsindex 8f71dd6db3..6442e7ea83 100644--- a/apps/desktop/src/i18n/locales/pt-BR.ts+++ b/apps/desktop/src/i18n/locales/pt-BR.ts@@ -546,6 +546,18 @@ export default withEnglishFallback({caCertPath: "Certificado CA",caCertPathPlaceholder: "Opcional, ex.: ~/.yandex/RootCA.crt",caCertPathBrowse: "Procurar certificado",+ cassandraTruststore: "Truststore",+ cassandraTruststorePlaceholder: "/caminho/do/client.truststore",+ cassandraTruststorePassword: "Senha do truststore",+ cassandraTruststoreBrowse: "Escolher truststore do Cassandra",+ cassandraTruststoreHint: "Truststore JKS ou PKCS#12 usado para verificar os certificados do servidor Cassandra.",+ cassandraTruststorePasswordRequiresPath: "Selecione um truststore do Cassandra antes de informar a senha.",+ cassandraKeystore: "Keystore do cliente",+ cassandraKeystorePlaceholder: "/caminho/do/client.keystore",+ cassandraKeystorePassword: "Senha do keystore",+ cassandraKeystoreBrowse: "Escolher keystore de cliente do Cassandra",+ cassandraKeystoreHint: "Keystore JKS ou PKCS#12 opcional para autenticação por certificado de cliente.",+ cassandraKeystorePasswordRequiresPath: "Selecione um keystore de cliente do Cassandra antes de informar a senha.",damengSslFilesPath: "Diretório de certificados",damengSslFilesPathPlaceholder: "/path/to/dmcert",damengSslFilesPathBrowse: "Selecionar diretório de certificados",diff --git a/apps/desktop/src/i18n/locales/tr.ts b/apps/desktop/src/i18n/locales/tr.tsindex bbc9d8c583..8d10620187 100644--- a/apps/desktop/src/i18n/locales/tr.ts+++ b/apps/desktop/src/i18n/locales/tr.ts@@ -568,6 +568,18 @@ export default withEnglishFallback({caCertPath: "CA Sertifikası",caCertPathPlaceholder: "İsteğe bağlı, örn. ~/.yandex/RootCA.crt",caCertPathBrowse: "Sertifikaya gözat",+ cassandraTruststore: "Güven deposu",+ cassandraTruststorePlaceholder: "/yol/client.truststore",+ cassandraTruststorePassword: "Güven deposu parolası",+ cassandraTruststoreBrowse: "Cassandra güven deposunu seç",+ cassandraTruststoreHint: "Cassandra sunucu sertifikalarını doğrulamak için kullanılan JKS veya PKCS#12 güven deposu.",+ cassandraTruststorePasswordRequiresPath: "Parolayı girmeden önce bir Cassandra güven deposu seçin.",+ cassandraKeystore: "İstemci anahtar deposu",+ cassandraKeystorePlaceholder: "/yol/client.keystore",+ cassandraKeystorePassword: "Anahtar deposu parolası",+ cassandraKeystoreBrowse: "Cassandra istemci anahtar deposunu seç",+ cassandraKeystoreHint: "İstemci sertifikası kimlik doğrulaması için isteğe bağlı JKS veya PKCS#12 anahtar deposu.",+ cassandraKeystorePasswordRequiresPath: "Parolayı girmeden önce bir Cassandra istemci anahtar deposu seçin.",damengSslFilesPath: "Sertifika dizini",damengSslFilesPathPlaceholder: "/path/to/dmcert",damengSslFilesPathBrowse: "Sertifika dizinini seçin",diff --git a/apps/desktop/src/i18n/locales/zh-CN.ts b/apps/desktop/src/i18n/locales/zh-CN.tsindex 5c3e3df73c..42d8570f12 100644--- a/apps/desktop/src/i18n/locales/zh-CN.ts+++ b/apps/desktop/src/i18n/locales/zh-CN.ts@@ -492,6 +492,18 @@ export default withEnglishFallback({caCertPath: "CA 证书",caCertPathPlaceholder: "可选,例如 ~/.yandex/RootCA.crt",caCertPathBrowse: "选择证书",+ cassandraTruststore: "信任库",+ cassandraTruststorePlaceholder: "/path/to/client.truststore",+ cassandraTruststorePassword: "信任库密码",+ cassandraTruststoreBrowse: "选择 Cassandra 信任库",+ cassandraTruststoreHint: "用于验证 Cassandra 服务端证书的 JKS 或 PKCS#12 信任库。",+ cassandraTruststorePasswordRequiresPath: "输入密码前请先选择 Cassandra 信任库。",+ cassandraKeystore: "客户端密钥库",+ cassandraKeystorePlaceholder: "/path/to/client.keystore",+ cassandraKeystorePassword: "密钥库密码",+ cassandraKeystoreBrowse: "选择 Cassandra 客户端密钥库",+ cassandraKeystoreHint: "可选,用于客户端证书认证的 JKS 或 PKCS#12 密钥库。",+ cassandraKeystorePasswordRequiresPath: "输入密码前请先选择 Cassandra 客户端密钥库。",damengSslFilesPath: "证书目录",damengSslFilesPathPlaceholder: "/path/to/dmcert",damengSslFilesPathBrowse: "选择证书目录",diff --git a/apps/desktop/src/i18n/locales/zh-TW.ts b/apps/desktop/src/i18n/locales/zh-TW.tsindex 21aae73880..e429189faf 100644--- a/apps/desktop/src/i18n/locales/zh-TW.ts+++ b/apps/desktop/src/i18n/locales/zh-TW.ts@@ -546,6 +546,18 @@ export default withEnglishFallback({caCertPath: "CA 憑證",caCertPathPlaceholder: "可選,例如 ~/.yandex/RootCA.crt",caCertPathBrowse: "瀏覽憑證",+ cassandraTruststore: "信任庫",+ cassandraTruststorePlaceholder: "/path/to/client.truststore",+ cassandraTruststorePassword: "信任庫密碼",+ cassandraTruststoreBrowse: "選擇 Cassandra 信任庫",+ cassandraTruststoreHint: "用於驗證 Cassandra 伺服器憑證的 JKS 或 PKCS#12 信任庫。",+ cassandraTruststorePasswordRequiresPath: "輸入密碼前請先選擇 Cassandra 信任庫。",+ cassandraKeystore: "用戶端金鑰庫",+ cassandraKeystorePlaceholder: "/path/to/client.keystore",+ cassandraKeystorePassword: "金鑰庫密碼",+ cassandraKeystoreBrowse: "選擇 Cassandra 用戶端金鑰庫",+ cassandraKeystoreHint: "可選,用於用戶端憑證驗證的 JKS 或 PKCS#12 金鑰庫。",+ cassandraKeystorePasswordRequiresPath: "輸入密碼前請先選擇 Cassandra 用戶端金鑰庫。",damengSslFilesPath: "憑證目錄",damengSslFilesPathPlaceholder: "/path/to/dmcert",damengSslFilesPathBrowse: "選擇憑證目錄",diff --git a/apps/desktop/src/lib/connection/__tests__/cassandraTlsOptions.spec.ts b/apps/desktop/src/lib/connection/__tests__/cassandraTlsOptions.spec.tsnew file mode 100644index 0000000000..e1657767be--- /dev/null+++ b/apps/desktop/src/lib/connection/__tests__/cassandraTlsOptions.spec.ts@@ -0,0 +1,61 @@+import { describe, expect, it } from "vitest";+import { buildCassandraExternalConfig, cassandraTlsConfigFromExternalConfig } from "../cassandraTlsOptions";++describe("Cassandra TLS options", () => {+ it("reads validated truststore and keystore fields", () => {+ expect(+ cassandraTlsConfigFromExternalConfig({+ tls: {+ truststore_path: "/certs/client.truststore",+ truststore_password: "trust-secret",+ keystore_path: "/certs/client.keystore",+ keystore_password: "key-secret",+ ignored: true,+ },+ }),+ ).toEqual({+ truststore_path: "/certs/client.truststore",+ truststore_password: "trust-secret",+ keystore_path: "/certs/client.keystore",+ keystore_password: "key-secret",+ });+ });++ it("ignores malformed external values", () => {+ expect(cassandraTlsConfigFromExternalConfig({ tls: { truststore_path: 42 } })).toEqual({+ truststore_path: "",+ truststore_password: "",+ keystore_path: "",+ keystore_password: "",+ });+ });++ it("trims paths without changing passwords", () => {+ expect(+ buildCassandraExternalConfig({+ truststore_path: " /certs/client.p12 ",+ truststore_password: " trust-secret ",+ keystore_path: " /certs/client.jks ",+ keystore_password: " key-secret ",+ }),+ ).toEqual({+ tls: {+ truststore_path: "/certs/client.p12",+ truststore_password: " trust-secret ",+ keystore_path: "/certs/client.jks",+ keystore_password: " key-secret ",+ },+ });+ });++ it("omits empty TLS store configuration", () => {+ expect(+ buildCassandraExternalConfig({+ truststore_path: "",+ truststore_password: "",+ keystore_path: "",+ keystore_password: "",+ }),+ ).toBeUndefined();+ });+});diff --git a/apps/desktop/src/lib/connection/cassandraTlsOptions.ts b/apps/desktop/src/lib/connection/cassandraTlsOptions.tsnew file mode 100644index 0000000000..24372685a6--- /dev/null+++ b/apps/desktop/src/lib/connection/cassandraTlsOptions.ts@@ -0,0 +1,40 @@+export interface CassandraTlsConfig {+ truststore_path: string;+ truststore_password: string;+ keystore_path: string;+ keystore_password: string;+}++export interface CassandraExternalConfig {+ tls: CassandraTlsConfig;+}++function stringField(value: unknown, key: keyof CassandraTlsConfig): string {+ if (!value || typeof value !== "object") return "";+ const field = (value as Record<string, unknown>)[key];+ return typeof field === "string" ? field : "";+}++export function cassandraTlsConfigFromExternalConfig(value: unknown): CassandraTlsConfig {+ const tls = value && typeof value === "object" ? (value as Record<string, unknown>).tls : undefined;+ return {+ truststore_path: stringField(tls, "truststore_path"),+ truststore_password: stringField(tls, "truststore_password"),+ keystore_path: stringField(tls, "keystore_path"),+ keystore_password: stringField(tls, "keystore_password"),+ };+}++export function buildCassandraExternalConfig(tls: CassandraTlsConfig): CassandraExternalConfig | undefined {+ const truststorePath = tls.truststore_path.trim();+ const keystorePath = tls.keystore_path.trim();+ if (!truststorePath && !tls.truststore_password && !keystorePath && !tls.keystore_password) return undefined;+ return {+ tls: {+ truststore_path: truststorePath,+ truststore_password: tls.truststore_password,+ keystore_path: keystorePath,+ keystore_password: tls.keystore_password,+ },+ };+}diff --git a/crates/dbx-core/src/agent_connection.rs b/crates/dbx-core/src/agent_connection.rsindex eb107f4c67..1528757a94 100644--- a/crates/dbx-core/src/agent_connection.rs+++ b/crates/dbx-core/src/agent_connection.rs@@ -47,6 +47,19 @@ fn h2_uses_custom_driver(config: &ConnectionConfig) -> bool {&& config.driver_profile.as_deref().is_some_and(|profile| profile.eq_ignore_ascii_case("h2-custom"))}+fn cassandra_tls_field<'a>(config: &'a ConnectionConfig, field: &str) -> &'a str {+ if config.db_type != DatabaseType::Cassandra {+ return "";+ }+ config+ .external_config+ .as_ref()+ .and_then(|value| value.get("tls"))+ .and_then(|value| value.get(field))+ .and_then(serde_json::Value::as_str)+ .unwrap_or("")+}+pub fn agent_connect_params(config: &ConnectionConfig,host: &str,@@ -120,6 +133,10 @@ pub fn agent_connect_params_with_role("ca_cert_path": config.ca_cert_path,"client_cert_path": config.client_cert_path,"client_key_path": config.client_key_path,+ "truststore_path": cassandra_tls_field(config, "truststore_path"),+ "truststore_password": cassandra_tls_field(config, "truststore_password"),+ "keystore_path": cassandra_tls_field(config, "keystore_path"),+ "keystore_password": cassandra_tls_field(config, "keystore_password"),"connect_timeout_secs": config.effective_connect_timeout_secs(),"etcd_endpoints": etcd_endpoints,"zookeeper_connect_string": zookeeper_connect_string,@@ -777,6 +794,27 @@ mod tests {assert_eq!(params["sessionRole"], "metadata");}+ #[test]+ fn cassandra_agent_connect_params_include_tls_stores() {+ let mut cfg = config(DatabaseType::Cassandra, Some("app"));+ cfg.ssl = true;+ cfg.external_config = Some(serde_json::json!({+ "tls": {+ "truststore_path": "/certs/client.truststore",+ "truststore_password": "trust-secret",+ "keystore_path": "/certs/client.keystore",+ "keystore_password": "key-secret"+ }+ }));++ let params = agent_connect_params(&cfg, "cassandra.example.com", 9042, "app").unwrap();++ assert_eq!(params["truststore_path"], "/certs/client.truststore");+ assert_eq!(params["truststore_password"], "trust-secret");+ assert_eq!(params["keystore_path"], "/certs/client.keystore");+ assert_eq!(params["keystore_password"], "key-secret");+ }+#[test]fn oracle_form_connections_use_orcl_when_database_is_omitted() {for (mode, expected_url) in [diff --git a/crates/dbx-core/src/cloud_sync.rs b/crates/dbx-core/src/cloud_sync.rsindex 26555def7e..06000269fd 100644--- a/crates/dbx-core/src/cloud_sync.rs+++ b/crates/dbx-core/src/cloud_sync.rs@@ -13,8 +13,9 @@ use std::net::{IpAddr, Ipv4Addr};use crate::ai::AiConfigItem;use crate::connection_secrets::{- MQ_AUTH_API_KEY_VALUE_KEY, MQ_AUTH_CLIENT_SECRET_KEY, MQ_AUTH_PASSWORD_KEY, MQ_AUTH_TOKEN_KEY,- MQ_TOKEN_SIGNING_KEY, NACOS_AUTH_PASSWORD_KEY, NACOS_RNACOS_CONSOLE_PASSWORD_KEY,+ CASSANDRA_KEYSTORE_PASSWORD_KEY, CASSANDRA_TRUSTSTORE_PASSWORD_KEY, MQ_AUTH_API_KEY_VALUE_KEY,+ MQ_AUTH_CLIENT_SECRET_KEY, MQ_AUTH_PASSWORD_KEY, MQ_AUTH_TOKEN_KEY, MQ_TOKEN_SIGNING_KEY,+ NACOS_AUTH_PASSWORD_KEY, NACOS_RNACOS_CONSOLE_PASSWORD_KEY,};use crate::models::connection::{ConnectionConfig, DatabaseType, TransportLayerConfig};use crate::saved_sql::SavedSqlLibrary;@@ -42,6 +43,8 @@ const SECRET_KEYS: &[&str] = &[MQ_TOKEN_SIGNING_KEY,NACOS_AUTH_PASSWORD_KEY,NACOS_RNACOS_CONSOLE_PASSWORD_KEY,+ CASSANDRA_TRUSTSTORE_PASSWORD_KEY,+ CASSANDRA_KEYSTORE_PASSWORD_KEY,];const SSH_TUNNEL_SECRET_PREFIX: &str = "ssh_tunnels.";const TRANSPORT_LAYER_SECRET_PREFIX: &str = "transport_layers.";@@ -969,6 +972,7 @@ fn scrub_connection_secrets(config: &mut ConnectionConfig) {scrub_mqtt_auth_secrets(config);scrub_mq_external_config_secrets(config);scrub_nacos_auth_secrets(config);+ scrub_cassandra_tls_secrets(config);}fn scrub_mqtt_auth_secrets(config: &mut ConnectionConfig) {@@ -1044,6 +1048,7 @@ async fn build_sensitive_payload(push_secret(&mut connection_secrets, &config.id, "connection_string", connection_string);}push_mq_external_config_secrets(&mut connection_secrets, config);+ push_cassandra_tls_secrets(&mut connection_secrets, config);if config.save_password {push_nacos_external_config_secrets(&mut connection_secrets, config);}@@ -1098,6 +1103,50 @@ fn scrub_mq_external_config_secrets(config: &mut ConnectionConfig) {}}+fn push_cassandra_tls_secrets(secrets: &mut Vec<ConnectionSecretSnapshot>, config: &ConnectionConfig) {+ if config.db_type != DatabaseType::Cassandra {+ return;+ }+ let Some(tls) = config+ .external_config+ .as_ref()+ .and_then(|external_config| external_config.get("tls"))+ .and_then(serde_json::Value::as_object)+ else {+ return;+ };+ push_json_secret(+ secrets,+ &config.id,+ CASSANDRA_TRUSTSTORE_PASSWORD_KEY,+ tls,+ "truststore_password",+ );+ push_json_secret(+ secrets,+ &config.id,+ CASSANDRA_KEYSTORE_PASSWORD_KEY,+ tls,+ "keystore_password",+ );+}++fn scrub_cassandra_tls_secrets(config: &mut ConnectionConfig) {+ if config.db_type != DatabaseType::Cassandra {+ return;+ }+ let Some(tls) = config+ .external_config+ .as_mut()+ .and_then(|external_config| external_config.get_mut("tls"))+ .and_then(serde_json::Value::as_object_mut)+ else {+ return;+ };+ scrub_json_secret(tls, "truststore_password");+ scrub_json_secret(tls, "keystore_password");+}+fn push_nacos_external_config_secrets(secrets: &mut Vec<ConnectionSecretSnapshot>, config: &ConnectionConfig) {if config.db_type != DatabaseType::Nacos {return;@@ -1615,7 +1664,10 @@ mod tests {SnippetProvider, SnippetSyncClient, SnippetSyncConfig, WebDavClient, WebDavConfig, DEFAULT_SNIPPET_FILE_NAME,};use crate::ai::{AiApiStyle, AiAuthMethod, AiConfig, AiConfigItem};- use crate::connection_secrets::{NACOS_AUTH_PASSWORD_KEY, NACOS_RNACOS_CONSOLE_PASSWORD_KEY};+ use crate::connection_secrets::{+ CASSANDRA_KEYSTORE_PASSWORD_KEY, CASSANDRA_TRUSTSTORE_PASSWORD_KEY, NACOS_AUTH_PASSWORD_KEY,+ NACOS_RNACOS_CONSOLE_PASSWORD_KEY,+ };use crate::models::connection::{default_redis_key_separator, ConnectionConfig, DatabaseType, SshTunnelConfig, TransportLayerConfig,};@@ -1818,6 +1870,22 @@ mod tests {}}+ fn cassandra_connection(id: &str) -> ConnectionConfig {+ let mut config = postgres_connection(id, "");+ config.name = "Cassandra".to_string();+ config.db_type = DatabaseType::Cassandra;+ config.port = 9042;+ config.external_config = Some(serde_json::json!({+ "tls": {+ "truststore_path": "/certs/client.truststore",+ "truststore_password": "trust-secret",+ "keystore_path": "/certs/client.keystore",+ "keystore_password": "key-secret"+ }+ }));+ config+ }+fn nacos_connection(id: &str, password: &str) -> ConnectionConfig {ConnectionConfig {docs_notes_path: None,@@ -2161,6 +2229,33 @@ mod tests {assert!(super::SECRET_KEYS.contains(&"init_script"));}+ #[tokio::test]+ async fn cassandra_tls_store_passwords_move_to_sensitive_sync_payload() {+ let config = cassandra_connection("cassandra");+ let mut public_config = config.clone();+ scrub_connection_secrets(&mut public_config);+ let tls = public_config+ .external_config+ .as_ref()+ .and_then(|external_config| external_config.get("tls"))+ .unwrap();+ assert_eq!(tls["truststore_password"], "");+ assert_eq!(tls["keystore_password"], "");++ let storage = Storage::open(&temp_db_path("cassandra-sensitive-payload")).await.unwrap();+ let payload = build_sensitive_payload(&storage, &[config], &[]).await.unwrap();+ assert!(payload.connection_secrets.iter().any(|secret| {+ secret.connection_id == "cassandra"+ && secret.key == CASSANDRA_TRUSTSTORE_PASSWORD_KEY+ && secret.secret == "trust-secret"+ }));+ assert!(payload.connection_secrets.iter().any(|secret| {+ secret.connection_id == "cassandra"+ && secret.key == CASSANDRA_KEYSTORE_PASSWORD_KEY+ && secret.secret == "key-secret"+ }));+ }+#[test]fn encrypted_sensitive_payload_round_trips() {let payload = SensitiveSyncPayload {diff --git a/crates/dbx-core/src/connection_secrets.rs b/crates/dbx-core/src/connection_secrets.rsindex 9a4ed22372..b51c197a17 100644--- a/crates/dbx-core/src/connection_secrets.rs+++ b/crates/dbx-core/src/connection_secrets.rs@@ -24,6 +24,9 @@ pub const NACOS_AUTH_PASSWORD_KEY: &str = "nacos.auth.password";pub const NACOS_RNACOS_CONSOLE_PASSWORD_KEY: &str = "nacos.auth.rnacos_console_password";pub const MQTT_AUTH_SECRET_PREFIX: &str = "mqtt.auth.";pub const MQTT_AUTH_PASSWORD_KEY: &str = "mqtt.auth.password";+pub const CASSANDRA_TLS_SECRET_PREFIX: &str = "cassandra.tls.";+pub const CASSANDRA_TRUSTSTORE_PASSWORD_KEY: &str = "cassandra.tls.truststore_password";+pub const CASSANDRA_KEYSTORE_PASSWORD_KEY: &str = "cassandra.tls.keystore_password";pub trait ConnectionSecretStore {fn set_secret(&self, connection_id: &str, key: &str, secret: &str) -> Result<(), String>;@@ -112,6 +115,7 @@ pub fn save_connections_to_file(persist_mq_auth_secrets(store, config)?;persist_mq_token_signing_secret(store, config)?;persist_mqtt_auth_secrets(store, config)?;+ persist_cassandra_tls_secrets(store, config)?;// New configs persist transport-layer secrets only. Remove legacy transport secret slots after the// migrated layer values have been written so old configs do not keep two sources of truth.@@ -181,6 +185,7 @@ pub fn load_connections_from_file(hydrate_mq_auth_secrets(store, config, &mut needs_rewrite)?;hydrate_mq_token_signing_secret(store, config, &mut needs_rewrite)?;hydrate_mqtt_auth_secrets(store, config, &mut needs_rewrite)?;+ hydrate_cassandra_tls_secrets(store, config, &mut needs_rewrite)?;}if needs_rewrite {@@ -360,6 +365,7 @@ fn delete_removed_connection_secrets(delete_secret_prefix(store, &config.id, MQ_AUTH_SECRET_PREFIX)?;delete_secret_prefix(store, &config.id, MQ_TOKEN_SIGNING_SECRET_PREFIX)?;delete_secret_prefix(store, &config.id, MQTT_AUTH_SECRET_PREFIX)?;+ delete_secret_prefix(store, &config.id, CASSANDRA_TLS_SECRET_PREFIX)?;}Ok(())}@@ -554,6 +560,87 @@ fn scrub_mq_token_signing_secret(config: &mut ConnectionConfig) {scrub_json_secret(signing, "key");}+fn persist_cassandra_tls_secrets(+ store: &dyn ConnectionSecretStore,+ config: &ConnectionConfig,+) -> Result<(), String> {+ if config.db_type != DatabaseType::Cassandra {+ return delete_secret_prefix(store, &config.id, CASSANDRA_TLS_SECRET_PREFIX);+ }+ let Some(tls) = cassandra_tls_object(config.external_config.as_ref()) else {+ return delete_secret_prefix(store, &config.id, CASSANDRA_TLS_SECRET_PREFIX);+ };+ persist_secret(+ store,+ &config.id,+ CASSANDRA_TRUSTSTORE_PASSWORD_KEY,+ tls.get("truststore_password")+ .and_then(serde_json::Value::as_str)+ .unwrap_or(""),+ )?;+ persist_secret(+ store,+ &config.id,+ CASSANDRA_KEYSTORE_PASSWORD_KEY,+ tls.get("keystore_password")+ .and_then(serde_json::Value::as_str)+ .unwrap_or(""),+ )+}++fn hydrate_cassandra_tls_secrets(+ store: &dyn ConnectionSecretStore,+ config: &mut ConnectionConfig,+ needs_rewrite: &mut bool,+) -> Result<(), String> {+ if config.db_type != DatabaseType::Cassandra {+ return Ok(());+ }+ let connection_id = config.id.clone();+ let Some(tls) = cassandra_tls_object_mut(config.external_config.as_mut()) else {+ return Ok(());+ };+ hydrate_json_secret(+ store,+ &connection_id,+ CASSANDRA_TRUSTSTORE_PASSWORD_KEY,+ tls,+ "truststore_password",+ needs_rewrite,+ )?;+ hydrate_json_secret(+ store,+ &connection_id,+ CASSANDRA_KEYSTORE_PASSWORD_KEY,+ tls,+ "keystore_password",+ needs_rewrite,+ )+}++fn scrub_cassandra_tls_secrets(config: &mut ConnectionConfig) {+ if config.db_type != DatabaseType::Cassandra {+ return;+ }+ let Some(tls) = cassandra_tls_object_mut(config.external_config.as_mut()) else {+ return;+ };+ scrub_json_secret(tls, "truststore_password");+ scrub_json_secret(tls, "keystore_password");+}++fn cassandra_tls_object(+ value: Option<&serde_json::Value>,+) -> Option<&serde_json::Map<String, serde_json::Value>> {+ value?.get("tls")?.as_object()+}++fn cassandra_tls_object_mut(+ value: Option<&mut serde_json::Value>,+) -> Option<&mut serde_json::Map<String, serde_json::Value>> {+ value?.get_mut("tls")?.as_object_mut()+}+// ── MQTT 密钥持久化 ──────────────────────────────────────────────fn persist_mqtt_auth_secrets(store: &dyn ConnectionSecretStore, config: &ConnectionConfig) -> Result<(), String> {@@ -745,6 +832,7 @@ fn sanitize_connections(configs: &[ConnectionConfig]) -> Vec<ConnectionConfig> {scrub_mq_auth_secrets(&mut config);scrub_mq_token_signing_secret(&mut config);scrub_mqtt_auth_secrets(&mut config);+ scrub_cassandra_tls_secrets(&mut config);config}).collect()@@ -757,9 +845,11 @@ pub fn secret_account(connection_id: &str, key: &str) -> String {#[cfg(test)]mod tests {use super::{- load_connections_from_file, save_connections_to_file, ConnectionSecretStore, CONNECTION_STRING_KEY,- INIT_SCRIPT_KEY, MAIN_PASSWORD_KEY, MQTT_AUTH_PASSWORD_KEY, MQ_AUTH_PASSWORD_KEY, MQ_AUTH_TOKEN_KEY,- MQ_TOKEN_SIGNING_KEY, REDIS_SENTINEL_PASSWORD_KEY, SSH_PASSWORD_KEY,+ load_connections_from_file, save_connections_to_file, ConnectionSecretStore,+ CASSANDRA_KEYSTORE_PASSWORD_KEY, CASSANDRA_TRUSTSTORE_PASSWORD_KEY,+ CONNECTION_STRING_KEY, INIT_SCRIPT_KEY, MAIN_PASSWORD_KEY, MQTT_AUTH_PASSWORD_KEY,+ MQ_AUTH_PASSWORD_KEY, MQ_AUTH_TOKEN_KEY, MQ_TOKEN_SIGNING_KEY, REDIS_SENTINEL_PASSWORD_KEY,+ SSH_PASSWORD_KEY,};use crate::models::connection::{ConnectionConfig, DatabaseType, HttpTunnelConfig, SshTunnelConfig, TransportLayerConfig,@@ -1127,6 +1217,57 @@ mod tests {assert_eq!(auth.get("token").and_then(serde_json::Value::as_str), Some("mq-token-secret"));}+ #[test]+ fn save_connections_moves_cassandra_store_passwords_to_secret_store_and_restores_them() {+ let path = temp_connections_file("cassandra-tls");+ let store = MemorySecretStore::default();+ let mut config = connection("cassandra", "", "");+ config.db_type = DatabaseType::Cassandra;+ config.external_config = Some(serde_json::json!({+ "tls": {+ "truststore_path": "/certs/client.truststore",+ "truststore_password": "trust-secret",+ "keystore_path": "/certs/client.keystore",+ "keystore_password": "key-secret"+ }+ }));++ save_connections_to_file(&path, &[config], &store).unwrap();++ assert_eq!(+ store+ .get_existing("cassandra", CASSANDRA_TRUSTSTORE_PASSWORD_KEY)+ .as_deref(),+ Some("trust-secret")+ );+ assert_eq!(+ store+ .get_existing("cassandra", CASSANDRA_KEYSTORE_PASSWORD_KEY)+ .as_deref(),+ Some("key-secret")+ );+ let persisted_json = std::fs::read_to_string(&path).unwrap();+ assert!(!persisted_json.contains("trust-secret"));+ assert!(!persisted_json.contains("key-secret"));++ let loaded = load_connections_from_file(&path, &store).unwrap();+ let tls = loaded[0]+ .external_config+ .as_ref()+ .and_then(|value| value.get("tls"))+ .unwrap();+ assert_eq!(+ tls.get("truststore_password")+ .and_then(serde_json::Value::as_str),+ Some("trust-secret")+ );+ assert_eq!(+ tls.get("keystore_password")+ .and_then(serde_json::Value::as_str),+ Some("key-secret")+ );+ }+#[test]fn save_connections_moves_mq_basic_and_oauth_secrets_to_secret_store_and_restores_them() {let path = temp_connections_file("mq-auth-multiple");diff --git a/crates/dbx-core/src/storage.rs b/crates/dbx-core/src/storage.rsindex e07c4f3b60..db853123bc 100644--- a/crates/dbx-core/src/storage.rs+++ b/crates/dbx-core/src/storage.rs@@ -15,6 +15,7 @@ use crate::ai::{AiRunStatus,};use crate::connection_secrets::{+ CASSANDRA_KEYSTORE_PASSWORD_KEY, CASSANDRA_TLS_SECRET_PREFIX, CASSANDRA_TRUSTSTORE_PASSWORD_KEY,MQ_AUTH_API_KEY_VALUE_KEY, MQ_AUTH_CLIENT_SECRET_KEY, MQ_AUTH_PASSWORD_KEY, MQ_AUTH_SECRET_PREFIX,MQ_AUTH_TOKEN_KEY, MQ_TOKEN_SIGNING_KEY, MQ_TOKEN_SIGNING_SECRET_PREFIX, NACOS_AUTH_PASSWORD_KEY,NACOS_AUTH_SECRET_PREFIX, NACOS_RNACOS_CONSOLE_PASSWORD_KEY,@@ -1362,6 +1363,17 @@ fn scrub_nacos_auth_secrets(config: &mut ConnectionConfig) {}}+fn scrub_cassandra_tls_secrets(config: &mut ConnectionConfig) {+ if config.db_type != DatabaseType::Cassandra {+ return;+ }+ let Some(tls) = cassandra_tls_object_mut(config.external_config.as_mut()) else {+ return;+ };+ scrub_json_secret(tls, "truststore_password");+ scrub_json_secret(tls, "keystore_password");+}+fn delete_secret_prefix_in_tx(tx: &rusqlite::Transaction<'_>,connection_id: &str,@@ -3190,6 +3202,7 @@ fn sanitized_connection_config(config: &ConnectionConfig) -> ConnectionConfig {scrub_mq_auth_secrets(&mut sanitized);scrub_mq_token_signing_secret(&mut sanitized);scrub_nacos_auth_secrets(&mut sanitized);+ scrub_cassandra_tls_secrets(&mut sanitized);sanitized}@@ -3265,7 +3278,8 @@ fn persist_connection_in_tx(tx: &rusqlite::Transaction<'_>, config: &ConnectionC}persist_mq_auth_secrets_in_tx(tx, &config)?;persist_mq_token_signing_secret_in_tx(tx, &config)?;- persist_nacos_auth_secrets_in_tx(tx, &config)+ persist_nacos_auth_secrets_in_tx(tx, &config)?;+ persist_cassandra_tls_secrets_in_tx(tx, &config)}fn insert_connection_copy_next_to_source(entries: &mut Vec<serde_json::Value>, source_id: &str, copy_id: &str) -> bool {@@ -3400,6 +3414,7 @@ impl Storage {scrub_mq_auth_secrets(&mut sanitized);scrub_mq_token_signing_secret(&mut sanitized);scrub_nacos_auth_secrets(&mut sanitized);+ scrub_cassandra_tls_secrets(&mut sanitized);let json = serde_json::to_string(&sanitized).map_err(|e| e.to_string())?;tx.execute("INSERT INTO connections (id, config_json) VALUES (?1, ?2)", params![config_id, json])@@ -3721,13 +3736,17 @@ impl Storage {let needs_mq_auth_rewrite = self.hydrate_mq_auth_secrets(&id, &mut config).await?;let needs_mq_token_signing_rewrite = self.hydrate_mq_token_signing_secret(&id, &mut config).await?;let needs_nacos_auth_rewrite = self.hydrate_nacos_auth_secret(&id, &mut config).await?;- let needs_external_secret_rewrite =- needs_mq_auth_rewrite || needs_mq_token_signing_rewrite || needs_nacos_auth_rewrite;+ let needs_cassandra_tls_rewrite = self.hydrate_cassandra_tls_secrets(&id, &mut config).await?;+ let needs_external_secret_rewrite = needs_mq_auth_rewrite+ || needs_mq_token_signing_rewrite+ || needs_nacos_auth_rewrite+ || needs_cassandra_tls_rewrite;if needs_external_secret_rewrite {let mut sanitized = config.clone().canonicalized();scrub_mq_auth_secrets(&mut sanitized);scrub_mq_token_signing_secret(&mut sanitized);scrub_nacos_auth_secrets(&mut sanitized);+ scrub_cassandra_tls_secrets(&mut sanitized);let sanitized_json = serde_json::to_string(&sanitized).map_err(|e| e.to_string())?;let update_id = id.clone();self.with_conn(move |conn| {@@ -3838,6 +3857,36 @@ impl Storage {}Ok(rewritten)}++ async fn hydrate_cassandra_tls_secrets(+ &self,+ connection_id: &str,+ config: &mut ConnectionConfig,+ ) -> Result<bool, String> {+ if config.db_type != DatabaseType::Cassandra {+ return Ok(false);+ }+ let Some(tls) = cassandra_tls_object_mut(config.external_config.as_mut()) else {+ return Ok(false);+ };+ let truststore_rewrite = hydrate_mq_json_secret(+ self,+ connection_id,+ CASSANDRA_TRUSTSTORE_PASSWORD_KEY,+ tls,+ "truststore_password",+ )+ .await?;+ let keystore_rewrite = hydrate_mq_json_secret(+ self,+ connection_id,+ CASSANDRA_KEYSTORE_PASSWORD_KEY,+ tls,+ "keystore_password",+ )+ .await?;+ Ok(truststore_rewrite || keystore_rewrite)+ }}// Saved SQL@@ -5104,6 +5153,36 @@ fn persist_nacos_auth_secrets_in_tx(tx: &rusqlite::Transaction<'_>, config: &ConOk(())}+fn persist_cassandra_tls_secrets_in_tx(+ tx: &rusqlite::Transaction<'_>,+ config: &ConnectionConfig,+) -> Result<(), String> {+ if config.db_type != DatabaseType::Cassandra {+ delete_secret_prefix_in_tx(tx, &config.id, CASSANDRA_TLS_SECRET_PREFIX)?;+ return Ok(());+ }+ let Some(tls) = cassandra_tls_object(config.external_config.as_ref()) else {+ delete_secret_prefix_in_tx(tx, &config.id, CASSANDRA_TLS_SECRET_PREFIX)?;+ return Ok(());+ };+ persist_secret_in_tx(+ tx,+ &config.id,+ CASSANDRA_TRUSTSTORE_PASSWORD_KEY,+ tls.get("truststore_password")+ .and_then(serde_json::Value::as_str)+ .unwrap_or(""),+ )?;+ persist_secret_in_tx(+ tx,+ &config.id,+ CASSANDRA_KEYSTORE_PASSWORD_KEY,+ tls.get("keystore_password")+ .and_then(serde_json::Value::as_str)+ .unwrap_or(""),+ )+}+fn persist_json_secret_if_present_in_tx(tx: &rusqlite::Transaction<'_>,connection_id: &str,@@ -5165,6 +5244,18 @@ fn mq_token_signing_object_mut(value?.get_mut("tokenSigning")?.as_object_mut()}+fn cassandra_tls_object(+ value: Option<&serde_json::Value>,+) -> Option<&serde_json::Map<String, serde_json::Value>> {+ value?.get("tls")?.as_object()+}++fn cassandra_tls_object_mut(+ value: Option<&mut serde_json::Value>,+) -> Option<&mut serde_json::Map<String, serde_json::Value>> {+ value?.get_mut("tls")?.as_object_mut()+}+fn nacos_auth_object(value: Option<&serde_json::Value>) -> Option<&serde_json::Map<String, serde_json::Value>> {value?.get("auth")?.as_object()}@@ -5224,7 +5315,8 @@ mod tests {};use crate::connection_secrets::NACOS_RNACOS_CONSOLE_PASSWORD_KEY;use crate::connection_secrets::{- MQ_AUTH_PASSWORD_KEY, MQ_AUTH_TOKEN_KEY, MQ_TOKEN_SIGNING_KEY, NACOS_AUTH_PASSWORD_KEY,+ CASSANDRA_KEYSTORE_PASSWORD_KEY, CASSANDRA_TRUSTSTORE_PASSWORD_KEY, MQ_AUTH_PASSWORD_KEY,+ MQ_AUTH_TOKEN_KEY, MQ_TOKEN_SIGNING_KEY, NACOS_AUTH_PASSWORD_KEY,};use crate::history::{HistoryConnectionFilter, HistoryDatabaseFilter, HistoryEntry, HistorySearchRequest};use crate::models::connection::{@@ -5842,6 +5934,71 @@ mod tests {.unwrap()}+ fn cassandra_connection(id: &str) -> ConnectionConfig {+ let mut config = plain_connection(id, "");+ config.name = "Cassandra".to_string();+ config.db_type = DatabaseType::Cassandra;+ config.port = 9042;+ config.ssl = true;+ config.external_config = Some(serde_json::json!({+ "tls": {+ "truststore_path": "/certs/client.truststore",+ "truststore_password": "trust-secret",+ "keystore_path": "/certs/client.keystore",+ "keystore_password": "key-secret"+ }+ }));+ config+ }++ #[tokio::test]+ async fn save_connections_moves_cassandra_tls_passwords_to_secret_table_and_restores_them() {+ let path = temp_db_path("cassandra-tls-secrets");+ let storage = Storage::open(&path).await.unwrap();++ storage.save_connections(&[cassandra_connection("cassandra")]).await.unwrap();++ let raw_json = raw_connection_json(&storage, "cassandra").await;+ assert!(!raw_json.contains("trust-secret"));+ assert!(!raw_json.contains("key-secret"));+ assert_eq!(+ storage+ .get_secret("cassandra", CASSANDRA_TRUSTSTORE_PASSWORD_KEY)+ .await+ .unwrap()+ .as_deref(),+ Some("trust-secret")+ );+ assert_eq!(+ storage+ .get_secret("cassandra", CASSANDRA_KEYSTORE_PASSWORD_KEY)+ .await+ .unwrap()+ .as_deref(),+ Some("key-secret")+ );++ let loaded = storage.load_connections().await.unwrap();+ let tls = loaded[0].external_config.as_ref().unwrap().get("tls").unwrap();+ assert_eq!(tls["truststore_password"], "trust-secret");+ assert_eq!(tls["keystore_password"], "key-secret");++ let mut disabled = cassandra_connection("cassandra");+ disabled.ssl = false;+ disabled.external_config = None;+ storage.save_connections(&[disabled]).await.unwrap();+ assert_eq!(+ storage.get_secret("cassandra", CASSANDRA_TRUSTSTORE_PASSWORD_KEY).await.unwrap(),+ None+ );+ assert_eq!(+ storage.get_secret("cassandra", CASSANDRA_KEYSTORE_PASSWORD_KEY).await.unwrap(),+ None+ );++ let _ = std::fs::remove_file(path);+ }+#[tokio::test]async fn save_connections_does_not_persist_password_when_save_password_false() {let path = temp_db_path("save-password-false");