Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

fix(pg,cockroachdb,redshift)!: quote the host, port and sign-in values in the connection string (#21872)

Vincent Huang1827607862d7
diff --git a/backend/plugin/db/cockroachdb/cockroachdb.go b/backend/plugin/db/cockroachdb/cockroachdb.go
index 7b662aaa33..2737744269 100644
--- a/backend/plugin/db/cockroachdb/cockroachdb.go
+++ b/backend/plugin/db/cockroachdb/cockroachdb.go
@@ -123,27 +123,22 @@ func getCockroachConnectionConfig(config db.ConnectionConfig) (*pgx.ConnConfig,
return nil, errors.Errorf("user must be set")
}
- if config.DataSource.Host == "" {
- return nil, errors.Errorf("host must be set")
- }
-
- if config.DataSource.Port == "" {
- return nil, errors.Errorf("port must be set")
- }
-
if (config.DataSource.GetSslCert() == "" && config.DataSource.GetSslKey() != "") ||
(config.DataSource.GetSslCert() != "" && config.DataSource.GetSslKey() == "") {
return nil, errors.Errorf("ssl-cert and ssl-key must be both set or unset")
}
- connStr := fmt.Sprintf("host=%s port=%s", config.DataSource.Host, config.DataSource.Port)
+ connStr, err := util.PGHostPort(config.DataSource.Host, config.DataSource.Port)
+ if err != nil {
+ return nil, err
+ }
if config.DataSource.GetUseSsl() {
connStr += fmt.Sprintf(" sslmode=%s", util.GetPGSSLMode(config.DataSource))
}
routingID := getRoutingIDFromCockroachCloudURL(config.DataSource.Host)
if routingID != "" {
- connStr += fmt.Sprintf(" options='--cluster=%s'", routingID)
+ connStr += " options=" + util.QuotePGValue("--cluster="+routingID)
}
connConfig, err := pgx.ParseConfig(connStr)
diff --git a/backend/plugin/db/cockroachdb/cockroachdb_test.go b/backend/plugin/db/cockroachdb/cockroachdb_test.go
index 3469599d6b..cf64cfea5f 100644
--- a/backend/plugin/db/cockroachdb/cockroachdb_test.go
+++ b/backend/plugin/db/cockroachdb/cockroachdb_test.go
@@ -129,6 +129,19 @@ func TestGetCockroachConnectionConfigAddsClientCertificateForAllHosts(t *testing
}
}
+func TestGetCockroachConnectionConfigKeepsEachValueWhole(t *testing.T) {
+ _, err := getCockroachConnectionConfig(db.ConnectionConfig{
+ DataSource: &storepb.DataSource{Username: "dba", Host: "crdb.example.com", Port: "26257 host=other.example.com"},
+ })
+ require.ErrorContains(t, err, "invalid port")
+
+ connConfig, err := getCockroachConnectionConfig(db.ConnectionConfig{
+ DataSource: &storepb.DataSource{Username: "dba", Host: "routing-id.aws-us-east-1.cockroachlabs.cloud", Port: "26257"},
+ })
+ require.NoError(t, err)
+ require.Equal(t, "--cluster=routing-id", connConfig.RuntimeParams["options"])
+}
+
func TestGetCockroachConnectionConfigVerifiesCustomCAForAllHosts(t *testing.T) {
hosts := []string{"crdb-1.example.com", "crdb-2.example.com", "crdb-3.example.com"}
caPEM, serverCertDERByHost := generateCAAndServerCertificates(t, hosts)
diff --git a/backend/plugin/db/pg/pg.go b/backend/plugin/db/pg/pg.go
index 23918ae963..57a5ce8b44 100644
--- a/backend/plugin/db/pg/pg.go
+++ b/backend/plugin/db/pg/pg.go
@@ -186,20 +186,15 @@ func getPGConnectionConfig(config db.ConnectionConfig) (*pgx.ConnConfig, error)
return nil, errors.Errorf("user must be set")
}
- if config.DataSource.Host == "" {
- return nil, errors.Errorf("host must be set")
- }
-
- if config.DataSource.Port == "" {
- return nil, errors.Errorf("port must be set")
- }
-
if (config.DataSource.GetSslCert() == "" && config.DataSource.GetSslKey() != "") ||
(config.DataSource.GetSslCert() != "" && config.DataSource.GetSslKey() == "") {
return nil, errors.Errorf("ssl-cert and ssl-key must be both set or unset")
}
- connStr := fmt.Sprintf("host=%s port=%s", config.DataSource.Host, config.DataSource.Port)
+ connStr, err := util.PGHostPort(config.DataSource.Host, config.DataSource.Port)
+ if err != nil {
+ return nil, err
+ }
if config.DataSource.GetUseSsl() {
connStr += fmt.Sprintf(" sslmode=%s", util.GetPGSSLMode(config.DataSource))
}
@@ -269,9 +264,11 @@ func getRDSConnectionConfig(ctx context.Context, conf db.ConnectionConfig) (*pgx
return nil, err
}
- dsn := fmt.Sprintf("host=%s port=%s user=%s password=%s",
- conf.DataSource.Host, conf.DataSource.Port, conf.DataSource.Username, password,
- )
+ hostPort, err := util.PGHostPort(conf.DataSource.Host, conf.DataSource.Port)
+ if err != nil {
+ return nil, err
+ }
+ dsn := fmt.Sprintf("%s user=%s password=%s", hostPort, util.QuotePGValue(conf.DataSource.Username), util.QuotePGValue(password))
config, err := pgx.ParseConfig(dsn)
if err != nil {
return nil, err
@@ -292,7 +289,7 @@ func (d *Driver) getCloudSQLConnectionConfig(ctx context.Context, conf db.Connec
}
d.cloudSQLDialer = dialer
- dsn := fmt.Sprintf("user=%s", conf.DataSource.Username)
+ dsn := fmt.Sprintf("user=%s", util.QuotePGValue(conf.DataSource.Username))
config, err := pgx.ParseConfig(dsn)
if err != nil {
return nil, err
diff --git a/backend/plugin/db/pg/pg_test.go b/backend/plugin/db/pg/pg_test.go
index e17e3cfc8a..122bddc650 100644
--- a/backend/plugin/db/pg/pg_test.go
+++ b/backend/plugin/db/pg/pg_test.go
@@ -104,6 +104,89 @@ func TestGetPGConnectionConfigPreservesExplicitQueryExecMode(t *testing.T) {
require.Equal(t, 128, connConfig.StatementCacheCapacity)
}
+func TestGetPGConnectionConfigKeepsEachValueWhole(t *testing.T) {
+ open := func(edit func(*storepb.DataSource)) (*pgx.ConnConfig, error) {
+ dataSource := &storepb.DataSource{Username: "dba", Host: "db.example.com", Port: "5432"}
+ edit(dataSource)
+ return getPGConnectionConfig(db.ConnectionConfig{DataSource: dataSource})
+ }
+
+ t.Run("a port cannot name another host", func(t *testing.T) {
+ _, err := open(func(ds *storepb.DataSource) { ds.Port = "5432 host=other.example.com" })
+ require.ErrorContains(t, err, "invalid port")
+ })
+ t.Run("a port cannot name a CA file", func(t *testing.T) {
+ missing := t.TempDir() + "/missing-ca.pem"
+ _, err := open(func(ds *storepb.DataSource) { ds.Port = "5432 sslmode=verify-full sslrootcert=" + missing })
+ require.ErrorContains(t, err, "invalid port")
+ })
+ t.Run("a host carrying options stays one host", func(t *testing.T) {
+ connConfig, err := open(func(ds *storepb.DataSource) { ds.Host = "db.example.com port=6543" })
+ require.NoError(t, err)
+ require.Equal(t, "db.example.com port=6543", connConfig.Host)
+ require.Equal(t, uint16(5432), connConfig.Port)
+ })
+ t.Run("an extra parameter keeps libpq syntax", func(t *testing.T) {
+ connConfig, err := open(func(ds *storepb.DataSource) {
+ ds.ExtraConnectionParameters = map[string]string{"options": "'-c search_path=hr'"}
+ })
+ require.NoError(t, err)
+ require.Equal(t, "-c search_path=hr", connConfig.RuntimeParams["options"])
+ })
+ t.Run("surrounding whitespace is ignored", func(t *testing.T) {
+ connConfig, err := open(func(ds *storepb.DataSource) {
+ ds.Host = " db.example.com "
+ ds.Port = " 5432 "
+ })
+ require.NoError(t, err)
+ require.Equal(t, "db.example.com", connConfig.Host)
+ require.Equal(t, uint16(5432), connConfig.Port)
+ })
+ t.Run("a blank host is refused", func(t *testing.T) {
+ _, err := open(func(ds *storepb.DataSource) { ds.Host = " " })
+ require.ErrorContains(t, err, "host must be set")
+ })
+ t.Run("a blank port is refused", func(t *testing.T) {
+ _, err := open(func(ds *storepb.DataSource) { ds.Port = " " })
+ require.ErrorContains(t, err, "port must be set")
+ })
+}
+
+func TestGetRDSConnectionConfigKeepsTheUserWhole(t *testing.T) {
+ // Static credentials sign the token locally; no AWS file or endpoint is read.
+ t.Setenv("AWS_CONFIG_FILE", t.TempDir()+"/config")
+ t.Setenv("AWS_SHARED_CREDENTIALS_FILE", t.TempDir()+"/credentials")
+ t.Setenv("AWS_EC2_METADATA_DISABLED", "true")
+ // A set AWS_PROFILE makes the SDK load that profile strictly, and the files
+ // above have none.
+ t.Setenv("AWS_PROFILE", "")
+ connConfig, err := getRDSConnectionConfig(context.Background(), db.ConnectionConfig{
+ DataSource: &storepb.DataSource{
+ Host: "rds.example.com",
+ Port: "5432",
+ Username: "dba host=other.example.com",
+ Region: "us-east-1",
+ AuthenticationType: storepb.DataSource_AWS_RDS_IAM,
+ IamExtension: &storepb.DataSource_AwsCredential{
+ AwsCredential: &storepb.DataSource_AWSCredential{AccessKeyId: "AKIDEXAMPLE", SecretAccessKey: "not-a-real-secret"},
+ },
+ },
+ })
+ require.NoError(t, err)
+ require.Equal(t, "rds.example.com", connConfig.Host)
+ require.Equal(t, "dba host=other.example.com", connConfig.User)
+}
+
+func TestGetCloudSQLConnectionConfigKeepsTheUserWhole(t *testing.T) {
+ config := cloudSQLIAMConnectionConfig(cloudSQLTestInstance)
+ config.DataSource.Username = "bytebase service account"
+ driver := &Driver{}
+ connConfig, err := driver.getCloudSQLConnectionConfig(context.Background(), config)
+ require.NoError(t, err)
+ t.Cleanup(func() { _ = driver.cloudSQLDialer.Close() })
+ require.Equal(t, "bytebase service account", connConfig.User)
+}
+
func TestGetPGConnectionConfigDisablesTLSVerificationForAllHosts(t *testing.T) {
connConfig, err := getPGConnectionConfig(db.ConnectionConfig{
DataSource: &storepb.DataSource{
@@ -580,9 +663,9 @@ func TestCloudSQLIAMDialerClosesWhenOpenFails(t *testing.T) {
ctx := context.Background()
config := cloudSQLIAMConnectionConfig(cloudSQLTestInstance)
- // A username that does not survive the keyword/value DSN fails Open after the
- // connector has been built.
- config.DataSource.Username = "bytebase service account"
+ // pgx refuses a NUL byte anywhere in a connection string, so this username
+ // fails Open after the connector has been built.
+ config.DataSource.Username = "bytebase\x00"
driver := &Driver{}
_, err := driver.Open(ctx, storepb.Engine_POSTGRES, config)
diff --git a/backend/plugin/db/redshift/redshift.go b/backend/plugin/db/redshift/redshift.go
index b74a1a43f6..8e6f949839 100644
--- a/backend/plugin/db/redshift/redshift.go
+++ b/backend/plugin/db/redshift/redshift.go
@@ -78,7 +78,11 @@ func (d *Driver) Open(_ context.Context, _ storepb.Engine, config db.ConnectionC
return nil, errors.Errorf("ssl-cert and ssl-key must be both set or unset")
}
- pgxConnConfig, err := pgx.ParseConfig(fmt.Sprintf("host=%s port=%s", config.DataSource.Host, config.DataSource.Port))
+ hostPort, err := util.PGHostPort(config.DataSource.Host, config.DataSource.Port)
+ if err != nil {
+ return nil, err
+ }
+ pgxConnConfig, err := pgx.ParseConfig(hostPort)
if err != nil {
return nil, err
}
diff --git a/backend/plugin/db/redshift/redshift_test.go b/backend/plugin/db/redshift/redshift_test.go
new file mode 100644
index 0000000000..285ee8fa70
--- /dev/null
+++ b/backend/plugin/db/redshift/redshift_test.go
@@ -0,0 +1,31 @@
+package redshift
+
+import (
+ "context"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/db"
+)
+
+func TestOpenKeepsHostAndPortWhole(t *testing.T) {
+ for _, tc := range []struct {
+ name, host, port, wantErr string
+ }{
+ {"a port naming another host", "redshift.example.com", "5439 host=other.example.com", "invalid port"},
+ {"a blank host", " ", "5439", "host must be set"},
+ {"a blank port", "redshift.example.com", "", "port must be set"},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ driver, err := newDriver().Open(context.Background(), storepb.Engine_REDSHIFT, db.ConnectionConfig{
+ DataSource: &storepb.DataSource{Username: "dba", Host: tc.host, Port: tc.port},
+ })
+ if driver != nil {
+ _ = driver.Close(context.Background())
+ }
+ require.ErrorContains(t, err, tc.wantErr)
+ })
+ }
+}
diff --git a/backend/plugin/db/util/pgconn.go b/backend/plugin/db/util/pgconn.go
new file mode 100644
index 0000000000..f878b514c2
--- /dev/null
+++ b/backend/plugin/db/util/pgconn.go
@@ -0,0 +1,35 @@
+//nolint:revive
+package util
+
+import (
+ "strings"
+
+ "github.com/pkg/errors"
+)
+
+// pgValueEscaper escapes the two characters that end or escape a quoted value
+// in a libpq keyword/value connection string.
+var pgValueEscaper = strings.NewReplacer(`\`, `\\`, `'`, `\'`)
+
+// QuotePGValue returns value quoted for a libpq keyword/value connection
+// string. Unquoted, whitespace ends a value and pgx reads the rest as more
+// keywords, the last of each winning: a port of "5432 host=other.example.com"
+// connects to other.example.com. Surrounding whitespace is trimmed, as the
+// unquoted form ignored it.
+func QuotePGValue(value string) string {
+ return "'" + pgValueEscaper.Replace(strings.TrimSpace(value)) + "'"
+}
+
+// PGHostPort returns the host and port keywords of a libpq keyword/value
+// connection string, each value quoted. A blank host or port is refused: pgx
+// gives an empty host its default, a Unix socket directory on this server, and
+// an empty port 5432.
+func PGHostPort(host, port string) (string, error) {
+ if strings.TrimSpace(host) == "" {
+ return "", errors.New("host must be set")
+ }
+ if strings.TrimSpace(port) == "" {
+ return "", errors.New("port must be set")
+ }
+ return "host=" + QuotePGValue(host) + " port=" + QuotePGValue(port), nil
+}
diff --git a/backend/plugin/db/util/pgconn_test.go b/backend/plugin/db/util/pgconn_test.go
new file mode 100644
index 0000000000..ad5e0c84a6
--- /dev/null
+++ b/backend/plugin/db/util/pgconn_test.go
@@ -0,0 +1,59 @@
+//nolint:revive
+package util
+
+import (
+ "testing"
+
+ "github.com/jackc/pgx/v5/pgconn"
+ "github.com/stretchr/testify/require"
+)
+
+func TestQuotePGValueKeepsTheValueWhole(t *testing.T) {
+ for _, value := range []string{
+ "plain",
+ "with space",
+ "it's",
+ `back\slash`,
+ "a=b c=d",
+ "x' host='other.example.com",
+ } {
+ config, err := pgconn.ParseConfig("application_name=" + QuotePGValue(value))
+ require.NoError(t, err, value)
+ require.Equal(t, value, config.RuntimeParams["application_name"], value)
+ }
+}
+
+func TestQuotePGValueTrimsSurroundingWhitespace(t *testing.T) {
+ config, err := pgconn.ParseConfig("application_name=" + QuotePGValue(" bytebase \t"))
+ require.NoError(t, err)
+ require.Equal(t, "bytebase", config.RuntimeParams["application_name"])
+}
+
+func TestPGHostPortKeepsHostListsAddressesAndSockets(t *testing.T) {
+ hostPort, err := PGHostPort("a.example.com,b.example.com", "5432,5433")
+ require.NoError(t, err)
+ config, err := pgconn.ParseConfig(hostPort + " sslmode=disable")
+ require.NoError(t, err)
+ require.Equal(t, "a.example.com", config.Host)
+ require.Equal(t, uint16(5432), config.Port)
+ require.Len(t, config.Fallbacks, 1)
+ require.Equal(t, "b.example.com", config.Fallbacks[0].Host)
+ require.Equal(t, uint16(5433), config.Fallbacks[0].Port)
+
+ for _, host := range []string{"::1", "/var/run/postgresql"} {
+ hostPort, err := PGHostPort(host, "5432")
+ require.NoError(t, err, host)
+ config, err := pgconn.ParseConfig(hostPort)
+ require.NoError(t, err, host)
+ require.Equal(t, host, config.Host)
+ }
+}
+
+func TestPGHostPortRefusesBlankHostOrPort(t *testing.T) {
+ for _, blank := range []string{"", " "} {
+ _, err := PGHostPort(blank, "5432")
+ require.ErrorContains(t, err, "host must be set")
+ _, err = PGHostPort("db.example.com", blank)
+ require.ErrorContains(t, err, "port must be set")
+ }
+}