diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 824af06..a9b4be4 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -6,49 +6,61 @@ on: pull_request: branches: [main, master] +permissions: + contents: read + jobs: integration-test: - name: go-sqlsmith + name: go-sqlsmith (MySQL ${{ matrix.mysql }}) runs-on: ubuntu-24.04 - - services: - mysql: - image: mysql:5.7 - env: - MYSQL_ROOT_PASSWORD: root - ports: - - 3306:3306 - options: >- - --health-cmd="mysqladmin ping -h 127.0.0.1 -uroot -proot" - --health-interval=10s - --health-timeout=5s - --health-retries=5 + strategy: + matrix: + mysql: ['5.7', '8.4'] + env: + SQLSMITH_TEST_DB: sqlsmith_ci steps: - name: Checkout code - uses: actions/checkout@v4 + uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4 + with: + persist-credentials: false - name: Set up Go - uses: actions/setup-go@v5 + uses: actions/setup-go@40f1582b2485089dde7abd97c1529aa768e1baff # v5 with: - go-version: 1.21.0 + go-version-file: go.mod - - name: Wait for MySQL to be ready + - name: Start isolated MySQL with a schema-scoped account + env: + MYSQL_VERSION: ${{ matrix.mysql }} run: | - for i in {1..30}; do - if mysqladmin ping -h 127.0.0.1 -uroot -proot --silent; then - echo "MySQL is ready" - break + password="$(openssl rand -hex 32)" + echo "::add-mask::$password" + echo "SQLSMITH_PASSWORD=$password" >> "$GITHUB_ENV" + docker run -d --name sqlsmith-ci -p 127.0.0.1:3306:3306 \ + -e MYSQL_RANDOM_ROOT_PASSWORD=yes \ + -e MYSQL_DATABASE="$SQLSMITH_TEST_DB" \ + -e MYSQL_USER=sqlsmith -e MYSQL_PASSWORD="$password" \ + "mysql:$MYSQL_VERSION" + for i in {1..60}; do + if docker exec -e MYSQL_PWD="$password" sqlsmith-ci \ + mysql -usqlsmith -e 'SELECT 1' >/dev/null 2>&1; then + exit 0 fi - echo "Waiting for MySQL..." sleep 2 done + echo 'MySQL did not become ready' >&2 + exit 1 - - name: Install dependencies - run: go mod download + - name: Unit, security integration and race tests + run: go test -race ./... - name: Build run: make - - name: Run integration tests - run: make integration-test \ No newline at end of file + - name: Run integration binary against the disposable schema + run: make integration-test TEST_FLAGS='-host 127.0.0.1 -port 3306 -user sqlsmith -db sqlsmith_ci -clear' + + - name: Stop isolated MySQL + if: always() + run: docker rm -f sqlsmith-ci || true diff --git a/Makefile b/Makefile index f77dcd8..f25783e 100644 --- a/Makefile +++ b/Makefile @@ -1,3 +1,7 @@ +TEST_FLAGS ?= +LDFLAGS := +GOMOD := + GOARCH := $(if $(GOARCH),$(GOARCH),amd64) GO=GO15VENDOREXPERIMENT="1" CGO_ENABLED=1 GOOS=$(GOOS) GOARCH=$(GOARCH) GO111MODULE=on go GOTEST=GO15VENDOREXPERIMENT="1" CGO_ENABLED=1 GO111MODULE=on go test # go race detector requires cgo @@ -5,10 +9,10 @@ VERSION := $(if $(VERSION),$(VERSION),latest) GOBUILD=$(GO) build -ldflags '$(LDFLAGS)' sqlsmith: - $(GOBUILD) $(GOMOD) -o bin/sqlsmith cmd/*.go + $(GOBUILD) $(GOMOD) -o bin/sqlsmith ./cmd integration-test: - $(GOBUILD) $(GOMOD) -o bin/test tests/*.go - ./bin/test -socket /var/run/mysqld/mysqld.sock + $(GOBUILD) $(GOMOD) -o bin/test ./tests + ./bin/test $(TEST_FLAGS) .PHONY: sqlsmith diff --git a/README.md b/README.md index 67b3592..fd4d03f 100644 --- a/README.md +++ b/README.md @@ -35,3 +35,85 @@ func gosmith() { sql, err := ss.Walk(node) } ``` + +## CLI connection and test safety + +Use a database account scoped to a disposable test schema. The binaries no longer +need `SUPER` or change global `sql_mode`; the driver sets the existing generator +mode (`NO_ENGINE_SUBSTITUTION`) on each physical session, including worker and +reconnected sessions. Generated DDL and DML still run with the chosen account's +privileges. + +Both binaries accept the existing `-host`, `-port`, `-user`, `-passwd`, `-socket` +and `-db` options. Prefer `SQLSMITH_PASSWORD` or `-password-file` to putting a +password in process arguments. A password file may end with LF or CRLF; other +characters are preserved. A nonempty `-passwd` takes precedence over the +environment; `-password-file` takes precedence over the environment and cannot +be combined with a nonempty `-passwd`. Connection logs omit the password. + +Remote TCP connections require `-tls`, which verifies the server certificate +and hostname. Use `-tls-ca /path/to/ca.pem` for a private CA, and optionally +`-tls-server-name db.example` when the connection address differs from the +certificate name. There is no certificate-verification bypass. Local loopback +and Unix-socket connections continue to support plaintext. An isolated remote +test network without TLS requires explicit `-allow-insecure-transport`. +Passwordless disposable instances require explicit `-allow-empty-password`. +The existing `root` user default remains for local test compatibility; use +`-user sqlsmith` with a schema-scoped account for normal runs. + +For example, an administrator can provision a dedicated schema and grant only +its privileges to an existing test user: + +```sql +CREATE DATABASE sqlsmith_test; +GRANT SELECT, INSERT, UPDATE, DELETE, CREATE, DROP, ALTER, INDEX + ON sqlsmith_test.* TO 'sqlsmith'@''; +``` + +Run the fuzzer using a mounted password file: + +```sh +make +./bin/sqlsmith -host db.example -user sqlsmith -db sqlsmith_test \ + -password-file /run/secrets/mysql-password -tls -tls-ca /path/to/ca.pem +``` + +The integration binary replaces its selected schema and refuses to connect +unless `-clear` is supplied. It uses `-db` consistently instead of always +dropping the database named `test`. `make integration-test` no longer selects +the host MySQL socket implicitly; pass the intended disposable target: + +```sh +make integration-test TEST_FLAGS='-host 127.0.0.1 -port 3306 -user sqlsmith -db sqlsmith_test -password-file /run/secrets/mysql-password -clear' +``` + +The same `-clear` opt-in remains available on `bin/sqlsmith`. Bootstrap +statements and successful worker DDL have timestamped audit context without +connection credentials. + +## Security regression tests + +`go test ./...` covers SQL identifier and literal round trips, comment-safe +optimizer hints, reservation boundaries, stable function generation and +connection options. To include real-database tests (also under `-race`), supply +a disposable schema already granted to the `sqlsmith` account: + +```sh +SQLSMITH_TEST_DB=sqlsmith_test SQLSMITH_TEST_PORT=3306 \ +SQLSMITH_TEST_PASSWORD_FILE=/run/secrets/mysql-password \ + go test -race ./... +``` + +`SQLSMITH_PASSWORD` can be used instead of `SQLSMITH_TEST_PASSWORD_FILE`. +`SQLSMITH_TEST_SOCKET` selects a local socket. `SQLSMITH_TEST_TLS_CA` additionally +enables the live TLS handshake tests over TCP: a trusted certificate succeeds, +while an untrusted CA or wrong hostname fails. CI exercises MySQL 5.7 and 8.4 +with a generated password and a schema-scoped user. + +The library's public SQL generation signatures remain unchanged. Identifiers +are quoted rather than restricted to ASCII: reserved words, spaces, Unicode +and embedded backticks remain usable. Optional optimizer hints are omitted +when a referenced identifier contains a comment terminator. Use one mutable +`SQLSmith` instance per goroutine, or synchronize external access, including +access to its exported schema maps. The CLI synchronizes its shared generator +while allowing database executions to proceed concurrently. diff --git a/builtin/function.go b/builtin/function.go index 17d80c5..aff9de8 100644 --- a/builtin/function.go +++ b/builtin/function.go @@ -29,6 +29,11 @@ func GenerateFuncCallExpr(table *types.Table, args int, stable bool) ast.ExprNod funcCallExpr := ast.FuncCallExpr{} fns := getValidArgsFunc(args, stable) + if len(fns) == 0 { + // Some modes have no function with this arity. A literal is still a + // valid expression and preserves the requested stability guarantee. + return ast.NewValueExpr(util.GenerateRandDataItem(), "", "") + } fn := copyFunc(fns[util.Rd(len(fns))]) funcCallExpr.FnName = ast.NewCIStr(fn.name) for i := 0; i < args; i++ { diff --git a/builtin/hint.go b/builtin/hint.go index 8ada90e..35dbafe 100644 --- a/builtin/hint.go +++ b/builtin/hint.go @@ -16,6 +16,7 @@ package builtin import ( "log" "math/rand" + "strings" "github.com/pingcap/tidb/pkg/parser/ast" @@ -84,6 +85,21 @@ var disabledHintKeywords = []*hintClass{ // GenerateHintExpr ... func GenerateHintExpr(table *types.Table) (h *ast.TableOptimizerHint) { + // Optimizer hints live inside a SQL comment. Backtick quoting cannot + // protect a comment terminator, so omit hints for these names only. + if table == nil || strings.Contains(table.Table, "*/") { + return nil + } + for _, t := range table.InnerTableList { + if t == nil || strings.Contains(t.Table, "*/") { + return nil + } + } + for _, index := range table.Indexes { + if strings.Contains(index, "*/") { + return nil + } + } enabledKeywords := hintKeywords if len(table.Indexes) > 0 { enabledKeywords = append(enabledKeywords, indexHintKeywords...) diff --git a/builtin/security_test.go b/builtin/security_test.go new file mode 100644 index 0000000..6849eb3 --- /dev/null +++ b/builtin/security_test.go @@ -0,0 +1,44 @@ +package builtin + +import ( + "testing" + + "github.com/chaos-mesh/go-sqlsmith/types" + "github.com/chaos-mesh/go-sqlsmith/util" + "github.com/pingcap/tidb/pkg/parser" + _ "github.com/pingcap/tidb/pkg/types/parser_driver" + "github.com/stretchr/testify/require" +) + +func TestHintCommentTerminator(t *testing.T) { + for _, table := range []*types.Table{ + {Table: "x*/WHERE 1=1/*"}, + {Table: "safe", InnerTableList: []*types.Table{{Table: "x*/WHERE 1=1/*"}}}, + {Table: "safe", Indexes: []string{"x*/WHERE 1=1/*"}}, + } { + require.Nil(t, GenerateHintExpr(table)) + } + safe := &types.Table{Table: "select", InnerTableList: []*types.Table{{Table: "has space"}}, Indexes: []string{"a`b"}} + generated := 0 + for i := 0; i < 100; i++ { + hint := GenerateHintExpr(safe) + if hint == nil { + continue + } + sql, err := util.BufferOut(hint) + require.NoError(t, err) + require.NotContains(t, sql, "*/") + generated++ + } + require.Positive(t, generated) +} + +func TestStableFunctionsWithEmptyArityCatalog(t *testing.T) { + for _, args := range []int{0, 1, 2, 3, 20} { + expr := GenerateFuncCallExpr(nil, args, true) + sql, err := util.BufferOut(expr) + require.NoError(t, err) + _, err = parser.New().ParseOneStmt("SELECT "+sql, "", "") + require.NoError(t, err, sql) + } +} diff --git a/cmd/connect.go b/cmd/connect.go index 5a683d5..da9e8e9 100644 --- a/cmd/connect.go +++ b/cmd/connect.go @@ -4,9 +4,12 @@ import ( "database/sql" "fmt" "math/rand" - "time" + "sync" "github.com/chaos-mesh/go-sqlsmith" + "github.com/chaos-mesh/go-sqlsmith/internal/dbutil" + "github.com/chaos-mesh/go-sqlsmith/util" + "github.com/go-sql-driver/mysql" "github.com/pingcap/errors" ) @@ -15,12 +18,13 @@ const ( ) type Connect struct { - dsn string + dbConfig *mysql.Config db *sql.DB dbs []*Executor config *SQLSmithConfig dbname string ss *sqlsmith.SQLSmith + smithMu sync.Mutex sum int points []int num2stmt map[int]string @@ -32,15 +36,16 @@ type Result struct { err error } -func NewConnect(dsn string, dbname string, config *SQLSmithConfig) (*Connect, error) { - db, err := sql.Open("mysql", dsn) +func NewConnect(dbConfig *mysql.Config, dbname string, config *SQLSmithConfig) (*Connect, error) { + db, err := dbutil.Open(dbConfig) if err != nil { return nil, err } + db.SetMaxOpenConns(2) ss := sqlsmith.New() ss.SetDB(dbname) c := &Connect{ - dsn: dsn, + dbConfig: dbConfig, db: db, config: config, dbname: dbname, @@ -50,26 +55,28 @@ func NewConnect(dsn string, dbname string, config *SQLSmithConfig) (*Connect, er stmt2num: make(map[string]int), } if err := c.InitSmithRates(); err != nil { + db.Close() return nil, errors.Trace(err) } return c, nil } -func (c *Connect) ReConnect(dsn string) error { - db, err := sql.Open("mysql", dsn) +func (c *Connect) ReConnect(dbConfig *mysql.Config) error { + db, err := dbutil.Open(dbConfig) if err != nil { return err } - c.dsn = dsn + db.SetMaxOpenConns(2) + if c.db != nil { + c.db.Close() + } + c.dbConfig = dbConfig c.db = db return nil } -func (c *Connect) Init(dsn string) { - c.MustExec(SQL_MODE) - time.Sleep(5 * time.Second) - c.dsn = dsn - if err := c.ReConnect(dsn); err != nil { +func (c *Connect) Init() { + if err := c.db.Ping(); err != nil { panic(err) } } @@ -77,9 +84,10 @@ func (c *Connect) Init(dsn string) { func (c *Connect) MustExec(query string, args ...interface{}) { _, err := c.db.Exec(query, args...) if err != nil { - logError(query, args) + logError("statement failed", dbutil.Target(c.dbConfig), fmt.Sprintf("sql=%q", query)) panic(err) } + log("statement succeeded", dbutil.Target(c.dbConfig), fmt.Sprintf("sql=%q", query)) } func (c *Connect) ReloadSchema() error { @@ -99,7 +107,9 @@ func (c *Connect) ReloadSchema() error { } indexes[table] = tableIndexes } + c.smithMu.Lock() c.ss.LoadSchema(schema, indexes) + c.smithMu.Unlock() return nil } @@ -118,11 +128,13 @@ func (c *Connect) FetchSchema(db string) ([][5]string, error) { schema [][5]string tablesInDB [][3]string ) - tables, err := c.db.Query(schemaSQL) + tables, err := c.db.Query(schemaSQL, db) if err != nil { return nil, errors.Trace(err) } + defer tables.Close() + // fetch tables need to be described for tables.Next() { var schemaName, tableName, tableType string @@ -134,6 +146,11 @@ func (c *Connect) FetchSchema(db string) ([][5]string, error) { } } + if err := tables.Err(); err != nil { + return nil, errors.Trace(err) + } + tables.Close() + // desc tables for _, table := range tablesInDB { var ( @@ -155,10 +172,11 @@ func (c *Connect) FetchSchema(db string) ([][5]string, error) { // FetchColumns get columns for given table func (c *Connect) FetchColumns(db, table string) ([][2]string, error) { var columns [][2]string - res, err := c.db.Query(fmt.Sprintf(tableSQL, db, table)) + res, err := c.db.Query(fmt.Sprintf(tableSQL, util.QuoteIdentifier(db), util.QuoteIdentifier(table))) if err != nil { return [][2]string{}, errors.Trace(err) } + defer res.Close() for res.Next() { var columnName, columnType string var col1, col2, col3, col4 interface{} @@ -167,17 +185,18 @@ func (c *Connect) FetchColumns(db, table string) ([][2]string, error) { } columns = append(columns, [2]string{columnName, columnType}) } - return columns, nil + return columns, errors.Trace(res.Err()) } // FetchIndexes get indexes for given table func (c *Connect) FetchIndexes(db, table string) ([]string, error) { var indexes []string - res, err := c.db.Query(fmt.Sprintf(indexSQL, db, table)) + res, err := c.db.Query(fmt.Sprintf(indexSQL, util.QuoteIdentifier(db), util.QuoteIdentifier(table))) if err != nil { return []string{}, errors.Trace(err) } + defer res.Close() columnTypes, err := res.ColumnTypes() if err != nil { return indexes, errors.Trace(err) @@ -210,16 +229,18 @@ func (c *Connect) FetchIndexes(db, table string) ([]string, error) { indexes = append(indexes, keyname) } } - return indexes, nil + return indexes, errors.Trace(res.Err()) } func (c *Connect) forkDB(concurrency int) error { c.dbs = make([]*Executor, concurrency) for i := 0; i < concurrency; i++ { - db, err := sql.Open("mysql", c.dsn) + db, err := dbutil.Open(c.dbConfig) if err != nil { return err } + db.SetMaxOpenConns(1) + db.SetMaxIdleConns(1) c.dbs[i] = &Executor{db: db} } return nil @@ -302,12 +323,16 @@ func (c *Connect) RunOnce(i int) (stmt string, err error) { exec = c.dbs[i] tp = c.RandStmt() ) + c.smithMu.Lock() switch tp { case TxnBegin: + c.smithMu.Unlock() return "", errors.Trace(exec.Begin()) case TxnCommit: + c.smithMu.Unlock() return "", errors.Trace(exec.Commit()) case TxnRollback: + c.smithMu.Unlock() return "", errors.Trace(exec.Rollback()) case DDLCreateTable: stmt, _, err = c.ss.CreateTableStmt() @@ -327,6 +352,8 @@ func (c *Connect) RunOnce(i int) (stmt string, err error) { stmt, _, err = c.ss.InsertStmt(false) } + c.smithMu.Unlock() + if err != nil { return } @@ -336,6 +363,7 @@ func (c *Connect) RunOnce(i int) (stmt string, err error) { } switch tp { case DDLCreateTable, DDLAlterTable, DDLCreateIndex: + log("worker DDL succeeded", fmt.Sprintf("worker=%d", i), dbutil.Target(c.dbConfig), fmt.Sprintf("sql=%q", stmt)) err = errors.Trace(c.ReloadSchema()) } diff --git a/cmd/main.go b/cmd/main.go index 8818dde..586960f 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -6,50 +6,59 @@ import ( "os" "os/signal" "syscall" + "time" - _ "github.com/go-sql-driver/mysql" + "github.com/chaos-mesh/go-sqlsmith/internal/dbutil" + "github.com/chaos-mesh/go-sqlsmith/util" + "github.com/go-sql-driver/mysql" ) var ( - host = flag.String("host", "127.0.0.1", "Database host") - port = flag.Int("port", 4000, "Database port") - user = flag.String("user", "root", "Database user") - passwd = flag.String("passwd", "", "Database password") - dbname = flag.String("db", "test", "Database name") - socket = flag.String("socket", "", "Database socket connect") - configPath = flag.String("config", "", "config path") - clearDB = flag.Bool("clear", false, "clear database and create a new one") - conc = flag.Int("concurrency", 1, "concurrency, there may be error such as write conflict when it's larger than 1") + host = flag.String("host", "127.0.0.1", "Database host") + port = flag.Int("port", 4000, "Database port") + user = flag.String("user", "root", "Database user") + passwd = flag.String("passwd", "", "Database password") + dbname = flag.String("db", "test", "Database name") + socket = flag.String("socket", "", "Database socket connect") + configPath = flag.String("config", "", "config path") + clearDB = flag.Bool("clear", false, "clear database and create a new one") + conc = flag.Int("concurrency", 1, "concurrency, there may be error such as write conflict when it's larger than 1") + passwordFile = flag.String("password-file", "", "Read database password from a file (or use SQLSMITH_PASSWORD)") + allowEmptyPassword = flag.Bool("allow-empty-password", false, "Allow passwordless authentication to a disposable test instance") + allowInsecureTransport = flag.Bool("allow-insecure-transport", false, "Allow plaintext TCP to an isolated remote test instance") + tlsEnabled = flag.Bool("tls", false, "Verify the database server using TLS") + tlsCA = flag.String("tls-ca", "", "PEM CA file for database TLS") + tlsServerName = flag.String("tls-server-name", "", "Expected database TLS certificate name") ) -func init() { - flag.Parse() -} - func log(l string, args ...interface{}) { - fmt.Fprintln(os.Stderr, append([]interface{}{"[TEST]", l}, args...)...) + fmt.Fprintln(os.Stderr, append([]interface{}{time.Now().UTC().Format(time.RFC3339), "[TEST]", l}, args...)...) } func logError(l string, args ...interface{}) { - fmt.Fprintln(os.Stderr, append([]interface{}{"[ERROR]", l}, args...)...) + fmt.Fprintln(os.Stderr, append([]interface{}{time.Now().UTC().Format(time.RFC3339), "[ERROR]", l}, args...)...) } -func getDSN() (string, string) { - var ( - dsn string - initDSN string - ) - if *socket == "" { - initDSN = fmt.Sprintf("%s:%s@tcp(%s:%d)/", *user, *passwd, *host, *port) - } else { - initDSN = fmt.Sprintf("%s:%s@unix(%s)/", *user, *passwd, *socket) - } - dsn = fmt.Sprintf("%s%s", initDSN, *dbname) - return initDSN, dsn +func getConfigs() (*mysql.Config, *mysql.Config, error) { + return dbutil.Configs(dbutil.Options{ + Host: *host, Port: *port, User: *user, Password: *passwd, + PasswordFile: *passwordFile, Database: *dbname, Socket: *socket, + TLS: *tlsEnabled, TLSCA: *tlsCA, TLSServerName: *tlsServerName, + AllowEmptyPassword: *allowEmptyPassword, AllowInsecureTransport: *allowInsecureTransport, + }) } func main() { - initDSN, dsn := getDSN() + flag.Parse() + if *conc < 1 { + logError("concurrency must be at least 1") + os.Exit(1) + } + bootstrapConfig, databaseConfig, err := getConfigs() + if err != nil { + logError("database configuration", err) + os.Exit(1) + } config := NewSQLSmithConfig() if *configPath != "" { if err := config.Load(*configPath); err != nil { @@ -57,19 +66,19 @@ func main() { } } - log("connect to dsn", initDSN) - connect, err := NewConnect(initDSN, *dbname, config) + log("connect", dbutil.Target(databaseConfig)) + connect, err := NewConnect(bootstrapConfig, *dbname, config) if err != nil { panic(err) } log("init environment") - connect.Init(initDSN) + connect.Init() if *clearDB { log("init database") - connect.MustExec(fmt.Sprintf(DB_DROP, *dbname)) - connect.MustExec(fmt.Sprintf(DB_CREATE, *dbname)) + connect.MustExec(fmt.Sprintf(DB_DROP, util.QuoteIdentifier(*dbname))) + connect.MustExec(fmt.Sprintf(DB_CREATE, util.QuoteIdentifier(*dbname))) } - if err := connect.ReConnect(dsn); err != nil { + if err := connect.ReConnect(databaseConfig); err != nil { panic(err) } diff --git a/cmd/security_integration_test.go b/cmd/security_integration_test.go new file mode 100644 index 0000000..2a707ea --- /dev/null +++ b/cmd/security_integration_test.go @@ -0,0 +1,231 @@ +package main + +import ( + "context" + "database/sql" + "os" + "strconv" + "sync" + "testing" + + sqlsmith "github.com/chaos-mesh/go-sqlsmith" + "github.com/chaos-mesh/go-sqlsmith/internal/dbutil" + "github.com/chaos-mesh/go-sqlsmith/util" + "github.com/pingcap/tidb/pkg/parser/ast" + "github.com/stretchr/testify/require" +) + +func integrationOptions(t *testing.T) dbutil.Options { + t.Helper() + name := os.Getenv("SQLSMITH_TEST_DB") + if name == "" { + t.Skip("set SQLSMITH_TEST_DB to a disposable database with a schema-scoped account") + } + port := 3306 + if value := os.Getenv("SQLSMITH_TEST_PORT"); value != "" { + var err error + port, err = strconv.Atoi(value) + require.NoError(t, err) + } + return dbutil.Options{Host: "127.0.0.1", Port: port, User: "sqlsmith", Database: name, + Socket: os.Getenv("SQLSMITH_TEST_SOCKET"), PasswordFile: os.Getenv("SQLSMITH_TEST_PASSWORD_FILE")} +} + +func liveConnect(t *testing.T, config *SQLSmithConfig) *Connect { + t.Helper() + opts := integrationOptions(t) + _, cfg, err := dbutil.Configs(opts) + require.NoError(t, err) + c, err := NewConnect(cfg, opts.Database, config) + require.NoError(t, err) + require.NoError(t, c.db.Ping()) + t.Cleanup(func() { + c.db.Close() + for _, exec := range c.dbs { + exec.db.Close() + } + }) + return c +} + +func TestLiveQuotedMetadataAndInsertBuilders(t *testing.T) { + c := liveConnect(t, NewSQLSmithConfig()) + table, column, index := "metadata` JOIN mysql_user ON 1=1 #", "value` /*data*/", "idx*/ WHERE 1=1 #" + quoted := util.QuoteIdentifier(table) + _, err := c.db.Exec("CREATE TABLE " + quoted + " (id INT PRIMARY KEY AUTO_INCREMENT, " + util.QuoteIdentifier(column) + " VARCHAR(255), KEY " + util.QuoteIdentifier(index) + " (" + util.QuoteIdentifier(column) + "))") + require.NoError(t, err) + t.Cleanup(func() { c.db.Exec("DROP TABLE IF EXISTS " + quoted) }) + columns, err := c.FetchColumns(c.dbname, table) + require.NoError(t, err) + require.Len(t, columns, 2) + require.Equal(t, column, columns[1][0]) + indexes, err := c.FetchIndexes(c.dbname, table) + require.NoError(t, err) + require.Contains(t, indexes, index) + schema, err := c.FetchSchema(c.dbname) + require.NoError(t, err) + var ownSchema [][5]string + for _, row := range schema { + if row[1] == table { + ownSchema = append(ownSchema, row) + } + } + ss := sqlsmith.New() + ss.SetDB(c.dbname) + ss.SetHint(true) + ss.LoadSchema(ownSchema, map[string][]string{table: indexes}) + sql, _, err := ss.InsertStmtStr(false) + require.NoError(t, err) + _, err = c.db.Exec(sql) + require.NoError(t, err, sql) + sql, _, err = ss.InsertStmt(false) + require.NoError(t, err) + _, err = c.db.Exec(sql) + require.NoError(t, err, sql) + batch, err := ss.BatchData(3, 2) + require.NoError(t, err) + for _, sql := range batch { + _, err = c.db.Exec(sql) + require.NoError(t, err, sql) + } + generator, err := ss.GenData(3, 2) + require.NoError(t, err) + for batch := generator.Next(); len(batch) != 0; batch = generator.Next() { + for _, sql := range batch { + _, err = c.db.Exec(sql) + require.NoError(t, err, sql) + } + } + for i := 0; i < 20; i++ { + selectTree := &ast.SelectStmt{ + SelectStmtOpts: &ast.SelectStmtOpts{}, Fields: &ast.FieldList{}, + From: &ast.TableRefsClause{TableRefs: &ast.Join{Left: &ast.TableName{}}}, + TableHints: []*ast.TableOptimizerHint{{}, {}}, + } + sql, _, err = ss.Walk(selectTree) + require.NoError(t, err) + rows, err := c.db.Query(sql) + require.NoError(t, err, sql) + require.NoError(t, rows.Close()) + } + drop := &ast.AlterTableStmt{Table: &ast.TableName{Name: ast.NewCIStr(table)}, Specs: []*ast.AlterTableSpec{{Tp: ast.AlterTableDropIndex, Name: index}}} + sql, err = util.BufferOut(drop) + require.NoError(t, err) + _, err = c.db.Exec(sql) + require.NoError(t, err, sql) + columns, err = c.FetchColumns(c.dbname, table) + require.NoError(t, err) + require.Len(t, columns, 2) + for i := 0; i < 10; i++ { + _, err = c.FetchColumns(c.dbname, "missing` table") + require.Error(t, err) + _, err = c.FetchIndexes(c.dbname, table) + require.NoError(t, err) + } + require.Zero(t, c.db.Stats().InUse) +} + +func TestLiveSessionModeSurvivesPoolAndReconnect(t *testing.T) { + c := liveConnect(t, NewSQLSmithConfig()) + var before string + require.NoError(t, c.db.QueryRow("SELECT @@GLOBAL.sql_mode").Scan(&before)) + check := func(db *sql.DB) { + t.Helper() + first, err := db.Conn(context.Background()) + require.NoError(t, err) + var mode string + require.NoError(t, first.QueryRowContext(context.Background(), "SELECT @@SESSION.sql_mode").Scan(&mode)) + require.Equal(t, "NO_ENGINE_SUBSTITUTION", mode) + if db.Stats().MaxOpenConnections > 1 { + second, err := db.Conn(context.Background()) + require.NoError(t, err) + require.NoError(t, second.QueryRowContext(context.Background(), "SELECT @@SESSION.sql_mode").Scan(&mode)) + require.Equal(t, "NO_ENGINE_SUBSTITUTION", mode) + require.NoError(t, second.Close()) + } + require.NoError(t, first.Close()) + } + check(c.db) + require.NoError(t, c.ReConnect(c.dbConfig)) + check(c.db) + require.NoError(t, c.forkDB(2)) + for _, exec := range c.dbs { + check(exec.db) + } + var after string + require.NoError(t, c.db.QueryRow("SELECT @@GLOBAL.sql_mode").Scan(&after)) + require.Equal(t, before, after) +} + +func TestLiveConcurrentGenerationAndReload(t *testing.T) { + c := liveConnect(t, &SQLSmithConfig{DMLInsert: 1}) + _, err := c.db.Exec("CREATE TABLE concurrent_fixture (id INT PRIMARY KEY AUTO_INCREMENT, value VARCHAR(255))") + require.NoError(t, err) + t.Cleanup(func() { c.db.Exec("DROP TABLE IF EXISTS concurrent_fixture") }) + require.NoError(t, c.ReloadSchema()) + // Keep this test's writes on its own fixture even if the disposable + // schema already contains tables from the integration binary. + c.ss.Databases[c.dbname].Online = true + c.ss.Databases[c.dbname].Tables["concurrent_fixture"].Online = true + require.NoError(t, c.forkDB(4)) + var wg sync.WaitGroup + failures := make(chan error, 100) + for worker := 0; worker < 4; worker++ { + wg.Add(1) + go func(worker int) { + defer wg.Done() + for i := 0; i < 20; i++ { + if _, err := c.RunOnce(worker); err != nil { + failures <- err + } + } + }(worker) + } + wg.Add(1) + go func() { + defer wg.Done() + for i := 0; i < 20; i++ { + if err := c.ReloadSchema(); err != nil { + failures <- err + } + } + }() + wg.Wait() + close(failures) + for err := range failures { + require.NoError(t, err) + } +} + +func TestLiveTLSVerification(t *testing.T) { + opts := integrationOptions(t) + opts.TLSCA = os.Getenv("SQLSMITH_TEST_TLS_CA") + if opts.TLSCA == "" { + t.Skip("set SQLSMITH_TEST_TLS_CA to the disposable server CA") + } + opts.TLS = true + opts.Socket = "" + _, cfg, err := dbutil.Configs(opts) + require.NoError(t, err) + db, err := dbutil.Open(cfg) + require.NoError(t, err) + defer db.Close() + require.NoError(t, db.Ping()) + var name, cipher string + require.NoError(t, db.QueryRow("SHOW STATUS LIKE 'Ssl_cipher'").Scan(&name, &cipher)) + require.NotEmpty(t, cipher) + opts.TLSServerName = "wrong-host.invalid" + _, cfg, err = dbutil.Configs(opts) + require.NoError(t, err) + wrong, err := dbutil.Open(cfg) + require.NoError(t, err) + defer wrong.Close() + require.Error(t, wrong.Ping()) + opts.TLSServerName, opts.TLSCA = "", "" + _, cfg, err = dbutil.Configs(opts) + require.NoError(t, err) + untrusted, err := dbutil.Open(cfg) + require.NoError(t, err) + defer untrusted.Close() + require.Error(t, untrusted.Ping()) +} diff --git a/cmd/sqls.go b/cmd/sqls.go index 1050e64..ad53895 100644 --- a/cmd/sqls.go +++ b/cmd/sqls.go @@ -1,12 +1,10 @@ package main const ( - SQL_MODE = `SET @@GLOBAL.SQL_MODE="NO_ENGINE_SUBSTITUTION"` - DB_DROP = `DROP DATABASE IF EXISTS %s` DB_CREATE = `CREATE DATABASE %s` - schemaSQL = "SELECT TABLE_SCHEMA, TABLE_NAME, TABLE_TYPE FROM information_schema.tables" + schemaSQL = "SELECT TABLE_SCHEMA, TABLE_NAME, TABLE_TYPE FROM information_schema.tables WHERE TABLE_SCHEMA = ?" tableSQL = "DESC %s.%s" indexSQL = "SHOW INDEX FROM %s.%s" ) diff --git a/data_gen.go b/data_gen.go index dcb7e54..ecb7050 100644 --- a/data_gen.go +++ b/data_gen.go @@ -20,11 +20,15 @@ import ( "github.com/chaos-mesh/go-sqlsmith/types" "github.com/chaos-mesh/go-sqlsmith/util" + "github.com/pingcap/tidb/pkg/parser/ast" ) // BatchData generate testing data by schema in given batch // return SQLs with insert statement func (s *SQLSmith) BatchData(total, batchSize int) ([]string, error) { + if total < 0 || batchSize <= 0 { + return nil, errors.New("total must be nonnegative and batch size must be positive") + } if s.currDB == "" { return []string{}, errors.New("no selected database") } @@ -35,6 +39,9 @@ func (s *SQLSmith) BatchData(total, batchSize int) ([]string, error) { var sqls []string for _, table := range database.Tables { + if database.Online && !table.Online { + continue + } var columns []*types.Column for _, column := range table.Columns { if column.Column == "id" { @@ -48,7 +55,11 @@ func (s *SQLSmith) BatchData(total, batchSize int) ([]string, error) { for i := 0; i < total; i++ { var line []string for _, column := range columns { - line = append(line, util.GenerateDataItemString(column.DataType)) + value, err := util.BufferOut(ast.NewValueExpr(util.GenerateDataItem(column.DataType), "", "")) + if err != nil { + return nil, err + } + line = append(line, value) } lines = append(lines, line) count++ @@ -68,10 +79,10 @@ func (s *SQLSmith) BatchData(total, batchSize int) ([]string, error) { func makeSQL(table *types.Table, columns []*types.Column, lines [][]string) string { var columnNames []string for _, column := range columns { - columnNames = append(columnNames, fmt.Sprintf("`%s`", column.Column)) + columnNames = append(columnNames, util.QuoteIdentifier(column.Column)) } - return fmt.Sprintf("INSERT INTO `%s` (%s) VALUES \n %s", - table.Table, + return fmt.Sprintf("INSERT INTO %s (%s) VALUES \n %s", + util.QuoteIdentifier(table.Table), strings.Join(columnNames, ", "), strings.Join(mapFn(lines, func(line []string) string { return fmt.Sprintf("(%s)", strings.Join(line, ", ")) diff --git a/data_generator.go b/data_generator.go index 714f8f1..80358f0 100644 --- a/data_generator.go +++ b/data_generator.go @@ -25,6 +25,9 @@ type DataGenerator struct { // GenData returns data generator func (s *SQLSmith) GenData(total, batch int) (*DataGenerator, error) { + if total < 0 || batch <= 0 { + return nil, errors.New("total must be nonnegative and batch size must be positive") + } if s.currDB == "" { return nil, errors.New("no selected database") } diff --git a/ddl_sql.go b/ddl_sql.go index 7f5702d..f64f9df 100644 --- a/ddl_sql.go +++ b/ddl_sql.go @@ -22,8 +22,7 @@ func (s *SQLSmith) CreateTableStmt() (string, string, error) { // AlterTableStmt alter table func (s *SQLSmith) AlterTableStmt(opt *DDLOptions) (string, error) { - s.setOnlineOtherTables(opt) - defer s.freeOnlineOtherTables() + defer s.setOnlineOtherTables(opt)() tree := s.alterTableStmt() stmt, _, err := s.Walk(tree) return stmt, err @@ -31,8 +30,7 @@ func (s *SQLSmith) AlterTableStmt(opt *DDLOptions) (string, error) { // CreateIndexStmt create index func (s *SQLSmith) CreateIndexStmt(opt *DDLOptions) (string, error) { - s.setOnlineOtherTables(opt) - defer s.freeOnlineOtherTables() + defer s.setOnlineOtherTables(opt)() tree := s.createIndexStmt() stmt, _, err := s.Walk(tree) return stmt, err diff --git a/dml_sql.go b/dml_sql.go index bcf4887..2ff8ed2 100644 --- a/dml_sql.go +++ b/dml_sql.go @@ -58,16 +58,21 @@ func (s *SQLSmith) InsertStmtStr(fn bool) (string, string, error) { if s.currDB == "" { return "", "", errors.New("no table selected") } - var table *types.Table - rdTableIndex := s.rd(len(s.Databases[s.currDB].Tables)) - tableIndex := 0 - for _, t := range s.Databases[s.currDB].Tables { - if rdTableIndex == tableIndex { - table = t - break + + db := s.Databases[s.currDB] + if db == nil { + return "", "", errors.New("selected database's schema not loaded") + } + var tables []*types.Table + for _, table := range db.Tables { + if table != nil && len(table.Columns) > 0 && (!db.Online || table.Online) { + tables = append(tables, table) } - tableIndex++ } + if len(tables) == 0 { + return "", "", errors.New("no eligible table in selected database") + } + table := tables[s.rd(len(tables))] var columns []*types.Column var columnNames []string @@ -76,7 +81,7 @@ func (s *SQLSmith) InsertStmtStr(fn bool) (string, string, error) { continue } columns = append(columns, column) - columnNames = append(columnNames, fmt.Sprintf("`%s`", column.Column)) + columnNames = append(columnNames, util.QuoteIdentifier(column.Column)) } var vals []string @@ -93,7 +98,7 @@ func (s *SQLSmith) InsertStmtStr(fn bool) (string, string, error) { } } sql := fmt.Sprintf("INSERT INTO %s(%s) VALUES(%s)", - table.Table, + util.QuoteIdentifier(table.Table), strings.Join(columnNames, ", "), strings.Join(vals, ", ")) return sql, table.Table, nil diff --git a/internal/dbutil/config.go b/internal/dbutil/config.go new file mode 100644 index 0000000..e92a2b3 --- /dev/null +++ b/internal/dbutil/config.go @@ -0,0 +1,105 @@ +// Package dbutil shares connection safety between the CLI tools. +package dbutil + +import ( + "crypto/tls" + "crypto/x509" + "database/sql" + "fmt" + "net" + "os" + "strconv" + "strings" + + "github.com/go-sql-driver/mysql" +) + +type Options struct { + Host, User, Password, PasswordFile, Database, Socket string + Port int + TLS bool + TLSCA, TLSServerName string + AllowEmptyPassword bool + AllowInsecureTransport bool +} + +// Configs returns bootstrap and database configurations. The driver applies sql_mode to +// every physical connection, including reconnects and worker connections. +func Configs(o Options) (*mysql.Config, *mysql.Config, error) { + password := o.Password + if o.PasswordFile != "" { + if password != "" { + return nil, nil, fmt.Errorf("use either -passwd or -password-file") + } + data, err := os.ReadFile(o.PasswordFile) + if err != nil { + return nil, nil, fmt.Errorf("read password file: %w", err) + } + password = strings.TrimSuffix(string(data), "\n") + if strings.HasSuffix(string(data), "\r\n") { + password = strings.TrimSuffix(password, "\r") + } + } else if password == "" { + password = os.Getenv("SQLSMITH_PASSWORD") + } + if password == "" && !o.AllowEmptyPassword { + return nil, nil, fmt.Errorf("empty database password: set SQLSMITH_PASSWORD, -password-file or -passwd; disposable passwordless instances require -allow-empty-password") + } + if o.Database == "" { + return nil, nil, fmt.Errorf("database name must not be empty") + } + if !o.TLS && (o.TLSCA != "" || o.TLSServerName != "") { + return nil, nil, fmt.Errorf("-tls-ca and -tls-server-name require -tls") + } + if !o.TLS && o.Socket == "" && !o.AllowInsecureTransport { + ip := net.ParseIP(o.Host) + if !strings.EqualFold(o.Host, "localhost") && (ip == nil || !ip.IsLoopback()) { + return nil, nil, fmt.Errorf("remote TCP connections require -tls; isolated plaintext test networks require -allow-insecure-transport") + } + } + + cfg := mysql.NewConfig() + cfg.User, cfg.Passwd = o.User, password + cfg.Net, cfg.Addr = "tcp", net.JoinHostPort(o.Host, strconv.Itoa(o.Port)) + if o.Socket != "" { + cfg.Net, cfg.Addr = "unix", o.Socket + } + // Preserve the generator's existing SQL semantics without a global SET. + cfg.Params = map[string]string{"sql_mode": "'NO_ENGINE_SUBSTITUTION'"} + if o.TLS { + tlsConfig := &tls.Config{MinVersion: tls.VersionTLS12, ServerName: o.TLSServerName} + if o.TLSCA != "" { + pem, err := os.ReadFile(o.TLSCA) + if err != nil { + return nil, nil, fmt.Errorf("read TLS CA: %w", err) + } + roots, err := x509.SystemCertPool() + if err != nil { + roots = x509.NewCertPool() + } + if !roots.AppendCertsFromPEM(pem) { + return nil, nil, fmt.Errorf("TLS CA file contains no certificates") + } + tlsConfig.RootCAs = roots + } + cfg.TLS = tlsConfig + } + bootstrap := cfg.Clone() + cfg.DBName = o.Database + return bootstrap, cfg, nil +} + +// Open avoids a DSN string round trip: mysql v1.7 cannot escape database names +// containing query delimiters. NewConnector passes the database as data. +func Open(cfg *mysql.Config) (*sql.DB, error) { + connector, err := mysql.NewConnector(cfg) + if err != nil { + return nil, err + } + return sql.OpenDB(connector), nil +} + +// Target returns audit context without authentication material. +func Target(cfg *mysql.Config) string { + return fmt.Sprintf("user=%q network=%q address=%q database=%q tls=%t", cfg.User, cfg.Net, cfg.Addr, cfg.DBName, cfg.TLS != nil) +} diff --git a/internal/dbutil/config_test.go b/internal/dbutil/config_test.go new file mode 100644 index 0000000..9df8295 --- /dev/null +++ b/internal/dbutil/config_test.go @@ -0,0 +1,66 @@ +package dbutil + +import ( + "crypto/tls" + "os" + "path/filepath" + "testing" + + "github.com/stretchr/testify/require" +) + +func TestPasswordSourcesAndSessionConfiguration(t *testing.T) { + t.Setenv("SQLSMITH_PASSWORD", "env-secret") + opts := Options{Host: "::1", Port: 4000, User: "limited", Database: "db?tls=skip-verify"} + bootstrap, cfg, err := Configs(opts) + require.NoError(t, err) + require.Equal(t, "env-secret", cfg.Passwd) + require.Equal(t, opts.Database, cfg.DBName) + require.Equal(t, "[::1]:4000", cfg.Addr) + require.Equal(t, "'NO_ENGINE_SUBSTITUTION'", cfg.Params["sql_mode"]) + require.False(t, cfg.MultiStatements) + require.Nil(t, cfg.TLS) + require.Empty(t, bootstrap.DBName) + require.Equal(t, cfg.Params, bootstrap.Params) + require.NotContains(t, Target(cfg), "env-secret") + opts.Password = "explicit-secret" + _, cfg, err = Configs(opts) + require.NoError(t, err) + require.Equal(t, "explicit-secret", cfg.Passwd) + opts.Password = "" + opts.PasswordFile = filepath.Join(t.TempDir(), "password") + require.NoError(t, os.WriteFile(opts.PasswordFile, []byte("file:@/? secret\r\n"), 0600)) + _, cfg, err = Configs(opts) + require.NoError(t, err) + require.Equal(t, "file:@/? secret", cfg.Passwd) + opts.PasswordFile = "" + t.Setenv("SQLSMITH_PASSWORD", "") + _, _, err = Configs(opts) + require.Error(t, err) + opts.AllowEmptyPassword = true + _, _, err = Configs(opts) + require.NoError(t, err) +} + +func TestVerifiedTLSConfiguration(t *testing.T) { + opts := Options{Host: "127.0.0.1", Port: 4000, User: "limited", Password: "test", Database: "test", TLS: true, TLSServerName: "database.example"} + _, cfg, err := Configs(opts) + require.NoError(t, err) + require.NotNil(t, cfg.TLS) + require.False(t, cfg.TLS.InsecureSkipVerify) + require.Equal(t, uint16(tls.VersionTLS12), cfg.TLS.MinVersion) + require.Equal(t, opts.TLSServerName, cfg.TLS.ServerName) + require.False(t, cfg.AllowFallbackToPlaintext) + opts.TLS = false + _, _, err = Configs(opts) + require.Error(t, err) +} + +func TestRemotePlaintextNeedsOptIn(t *testing.T) { + opts := Options{Host: "remote.example", Port: 4000, User: "limited", Password: "test", Database: "test"} + _, _, err := Configs(opts) + require.Error(t, err) + opts.AllowInsecureTransport = true + _, _, err = Configs(opts) + require.NoError(t, err) +} diff --git a/schema.go b/schema.go index 840a202..580ba2c 100644 --- a/schema.go +++ b/schema.go @@ -101,22 +101,28 @@ func (s *SQLSmith) EndTransaction() []string { } // setOnlineOtherTables is for avoiding online DDL -func (s *SQLSmith) setOnlineOtherTables(opt *DDLOptions) { - if opt.OnlineDDL { - return - } +func (s *SQLSmith) setOnlineOtherTables(opt *DDLOptions) func() { + previous := make(map[*types.Table]bool) db := s.GetDB(s.currDB) - for _, table := range opt.Tables { - if db.Tables[table] != nil { - db.Tables[table].OnlineOther = true + if opt != nil && opt.OnlineDDL { + // Explicit online DDL may use every table, without erasing reservations. + for _, table := range db.Tables { + previous[table] = table.OnlineOther + table.OnlineOther = false + } + } else if opt != nil { + for _, name := range opt.Tables { + if table := db.Tables[name]; table != nil { + if _, seen := previous[table]; !seen { + previous[table] = table.OnlineOther + } + table.OnlineOther = true + } } } -} - -// freeOnlineOtherTables clear online tables obtain by other instances -func (s *SQLSmith) freeOnlineOtherTables() { - db := s.GetDB(s.currDB) - for _, table := range db.Tables { - table.OnlineOther = false + return func() { + for table, online := range previous { + table.OnlineOther = online + } } } diff --git a/security_test.go b/security_test.go new file mode 100644 index 0000000..6537449 --- /dev/null +++ b/security_test.go @@ -0,0 +1,131 @@ +package sqlsmith + +import ( + "testing" + + "github.com/pingcap/tidb/pkg/parser" + "github.com/pingcap/tidb/pkg/parser/ast" + "github.com/stretchr/testify/require" +) + +type collectTables struct{ names []string } + +func (v *collectTables) Enter(n ast.Node) (ast.Node, bool) { + if table, ok := n.(*ast.TableName); ok { + v.names = append(v.names, table.Name.O) + } + return n, false +} +func (v *collectTables) Leave(n ast.Node) (ast.Node, bool) { return n, true } + +func TestStringInsertBuildersPreserveIdentifiers(t *testing.T) { + table, column := "t` VALUES (1) #", "c`x" + ss := New() + ss.SetDB("test") + ss.LoadSchema([][5]string{{"test", table, "BASE TABLE", column, "varchar"}}, nil) + check := func(sql string) { + parsed, err := parser.New().ParseOneStmt(sql, "", "") + require.NoError(t, err, sql) + insert := parsed.(*ast.InsertStmt) + require.Equal(t, table, insert.Table.TableRefs.Left.(*ast.TableSource).Source.(*ast.TableName).Name.O) + require.Len(t, insert.Columns, 1) + require.Equal(t, column, insert.Columns[0].Name.O) + } + sql, _, err := ss.InsertStmtStr(false) + require.NoError(t, err) + check(sql) + batch, err := ss.BatchData(3, 2) + require.NoError(t, err) + require.Len(t, batch, 2) + for _, sql := range batch { + check(sql) + } + gen, err := ss.GenData(3, 2) + require.NoError(t, err) + for batch := gen.Next(); len(batch) > 0; batch = gen.Next() { + for _, sql := range batch { + check(sql) + } + } +} + +func TestReservationsCoverNestedSelectsAndDDL(t *testing.T) { + ss := New() + ss.SetDB("test") + ss.LoadSchema([][5]string{ + {"test", "allowed", "BASE TABLE", "c", "int"}, + {"test", "excluded", "BASE TABLE", "c", "int"}, + }, nil) + db := ss.Databases["test"] + db.Online, db.Tables["allowed"].Online = true, true + for i := 0; i < 30; i++ { + + for _, tree := range []ast.Node{ss.selectStmt(3), ss.selectForUpdateStmt(3)} { + _, _, err := ss.Walk(tree) + require.NoError(t, err) + visitor := &collectTables{} + tree.Accept(visitor) + require.NotEmpty(t, visitor.names) + for _, name := range visitor.names { + require.Equal(t, "allowed", name) + } + } + } + batch, err := ss.BatchData(1, 1) + require.NoError(t, err) + require.Len(t, batch, 1) + insert, err := parser.New().ParseOneStmt(batch[0], "", "") + require.NoError(t, err) + require.Equal(t, "allowed", insert.(*ast.InsertStmt).Table.TableRefs.Left.(*ast.TableSource).Source.(*ast.TableName).Name.O) + sql, err := ss.CreateIndexStmt(&DDLOptions{Tables: []string{"excluded"}}) + require.NoError(t, err) + parsed, err := parser.New().ParseOneStmt(sql, "", "") + require.NoError(t, err) + require.Equal(t, "allowed", parsed.(*ast.CreateIndexStmt).Table.Name.O) + require.False(t, db.Tables["excluded"].OnlineOther) + db.Tables["excluded"].OnlineOther = true + _, err = ss.CreateIndexStmt(&DDLOptions{Tables: []string{"allowed"}}) + require.Error(t, err) + require.True(t, db.Tables["excluded"].OnlineOther) + require.False(t, db.Tables["allowed"].OnlineOther) + db.Tables["allowed"].OnlineOther = true + _, err = ss.CreateIndexStmt(&DDLOptions{OnlineDDL: true}) + require.NoError(t, err) + require.True(t, db.Tables["allowed"].OnlineOther) + require.True(t, db.Tables["excluded"].OnlineOther) + db.Tables["allowed"].Online = false + _, _, err = ss.SelectForUpdateStmt(1) + require.Error(t, err) +} + +func TestUnloadedSchemaReturnsErrors(t *testing.T) { + ss := New() + ss.SetDB("not_loaded") + _, _, err := ss.SelectStmt(1) + require.Error(t, err) + _, _, err = ss.InsertStmtStr(false) + require.Error(t, err) + _, err = ss.AlterTableStmt(nil) + require.Error(t, err) + _, _, err = ss.CreateTableStmt() + require.NoError(t, err) +} + +func TestUpdateHasWritableAssignment(t *testing.T) { + ss := New() + ss.SetDB("test") + ss.LoadSchema([][5]string{ + {"test", "one", "BASE TABLE", "id", "int"}, + {"test", "one", "BASE TABLE", "value", "varchar"}, + }, nil) + for i := 0; i < 100; i++ { + sql, _, err := ss.UpdateStmt() + require.NoError(t, err) + parsed, err := parser.New().ParseOneStmt(sql, "", "") + require.NoError(t, err, sql) + require.NotEmpty(t, parsed.(*ast.UpdateStmt).List) + } + delete(ss.Databases["test"].Tables["one"].Columns, "value") + _, _, err := ss.UpdateStmt() + require.Error(t, err) +} diff --git a/sqlsmith.go b/sqlsmith.go index eeeb120..2bfc377 100644 --- a/sqlsmith.go +++ b/sqlsmith.go @@ -25,7 +25,8 @@ import ( "github.com/chaos-mesh/go-sqlsmith/util" ) -// SQLSmith defines SQLSmith struct +// SQLSmith is a mutable SQL generator. Use one instance per goroutine or +// synchronize access, including access to its exported schema maps. type SQLSmith struct { depth int maxDepth int diff --git a/stateflow/walker.go b/stateflow/walker.go index de85522..afb23f7 100644 --- a/stateflow/walker.go +++ b/stateflow/walker.go @@ -14,6 +14,8 @@ package stateflow import ( + "fmt" + "github.com/pingcap/tidb/pkg/parser/ast" tidbTypes "github.com/pingcap/tidb/pkg/types" driver "github.com/pingcap/tidb/pkg/types/parser_driver" @@ -25,6 +27,50 @@ import ( // WalkTree parse func (s *StateFlow) WalkTree(node ast.Node) (ast.Node, string, error) { + // Filter once so nested SELECTs obey the same reservation as writes. + originalDB := s.db + defer func() { s.db = originalDB }() + ddl := false + switch node.(type) { + case *ast.CreateTableStmt: + case *ast.AlterTableStmt, *ast.CreateIndexStmt: + ddl = true + case *ast.SelectStmt, *ast.UpdateStmt, *ast.InsertStmt, *ast.DeleteStmt: + default: + return nil, "", fmt.Errorf("unsupported statement type %T", node) + } + if _, create := node.(*ast.CreateTableStmt); !create { + available := &types.Database{Tables: make(map[string]*types.Table)} + if s.db != nil { + available.Name, available.Online = s.db.Name, s.db.Online + for name, table := range s.db.Tables { + if table == nil || len(table.Columns) == 0 { + continue + } + + if _, update := node.(*ast.UpdateStmt); update { + writable := false + for _, column := range table.Columns { + if column.Column != "id" && column.Column != "uuid" { + writable = true + break + } + } + if !writable { + continue + } + } + if (ddl && table.OnlineOther) || (!ddl && s.db.Online && !table.Online) { + continue + } + available.Tables[name] = table + } + } + if len(available.Tables) == 0 { + return nil, "", fmt.Errorf("no eligible table in selected database") + } + s.db = available + } var ( t, err = s.walkTree(node) table = "" @@ -267,6 +313,21 @@ func (s *StateFlow) walkValueExpr(node *driver.ValueExpr, table *types.Table, co func (s *StateFlow) walkAssignmentList(list *[]*ast.Assignment, table *types.Table) { columns := s.randColumns(table) + writable := false + for _, column := range columns { + if column.Column != "id" && column.Column != "uuid" { + writable = true + break + } + } + if !writable { + for _, column := range table.Columns { + if column.Column != "id" && column.Column != "uuid" { + columns = append(columns, column) + break + } + } + } for _, column := range columns { // TODO: specify primary key in type Table // to avoid this hard coding diff --git a/tests/connect.go b/tests/connect.go index a6770d1..d1efc05 100644 --- a/tests/connect.go +++ b/tests/connect.go @@ -2,48 +2,54 @@ package main import ( "database/sql" - "time" + "fmt" + + "github.com/chaos-mesh/go-sqlsmith/internal/dbutil" + "github.com/go-sql-driver/mysql" ) type Connect struct { - dsn string - db *sql.DB + dbConfig *mysql.Config + db *sql.DB } -func NewConnect(dsn string) (*Connect, error) { - db, err := sql.Open("mysql", dsn) +func NewConnect(dbConfig *mysql.Config) (*Connect, error) { + db, err := dbutil.Open(dbConfig) if err != nil { return nil, err } + db.SetMaxOpenConns(2) return &Connect{ - dsn: dsn, - db: db, + dbConfig: dbConfig, + db: db, }, nil } func (c *Connect) MustExec(query string, args ...interface{}) { _, err := c.db.Exec(query, args...) if err != nil { - logError(query, args) + logError("statement failed", dbutil.Target(c.dbConfig), fmt.Sprintf("sql=%q", query)) panic(err) } + log("statement succeeded", dbutil.Target(c.dbConfig), fmt.Sprintf("sql=%q", query)) } -func (c *Connect) ReConnect(dsn string) error { - db, err := sql.Open("mysql", dsn) +func (c *Connect) ReConnect(dbConfig *mysql.Config) error { + db, err := dbutil.Open(dbConfig) if err != nil { return err } - c.dsn = dsn + db.SetMaxOpenConns(2) + if c.db != nil { + c.db.Close() + } + c.dbConfig = dbConfig c.db = db return nil } -func (c *Connect) Init(dsn string) { - c.MustExec(SQL_MODE) - time.Sleep(5 * time.Second) - c.dsn = dsn - if err := c.ReConnect(dsn); err != nil { +func (c *Connect) Init() { + if err := c.db.Ping(); err != nil { panic(err) } } diff --git a/tests/main.go b/tests/main.go index ce002e1..dee93d5 100644 --- a/tests/main.go +++ b/tests/main.go @@ -3,60 +3,71 @@ package main import ( "flag" "fmt" + "os" + "time" "github.com/chaos-mesh/go-sqlsmith" - _ "github.com/go-sql-driver/mysql" + "github.com/chaos-mesh/go-sqlsmith/internal/dbutil" + "github.com/chaos-mesh/go-sqlsmith/util" + "github.com/go-sql-driver/mysql" ) var ( - host = flag.String("host", "127.0.0.1", "Database host") - port = flag.Int("port", 4000, "Database port") - user = flag.String("user", "root", "Database user") - passwd = flag.String("passwd", "", "Database password") - dbname = flag.String("db", "test", "Database name") - socket = flag.String("socket", "", "Database socket connect") + clearDB = flag.Bool("clear", false, "Explicitly allow integration tests to replace the selected database") + host = flag.String("host", "127.0.0.1", "Database host") + port = flag.Int("port", 4000, "Database port") + user = flag.String("user", "root", "Database user") + passwd = flag.String("passwd", "", "Database password") + dbname = flag.String("db", "test", "Database name") + socket = flag.String("socket", "", "Database socket connect") + passwordFile = flag.String("password-file", "", "Read database password from a file (or use SQLSMITH_PASSWORD)") + allowEmptyPassword = flag.Bool("allow-empty-password", false, "Allow passwordless authentication to a disposable test instance") + allowInsecureTransport = flag.Bool("allow-insecure-transport", false, "Allow plaintext TCP to an isolated remote test instance") + tlsEnabled = flag.Bool("tls", false, "Verify the database server using TLS") + tlsCA = flag.String("tls-ca", "", "PEM CA file for database TLS") + tlsServerName = flag.String("tls-server-name", "", "Expected database TLS certificate name") ) -func init() { - flag.Parse() -} - func log(l string, args ...interface{}) { - fmt.Println(append([]interface{}{"[TEST]", l}, args...)...) + fmt.Fprintln(os.Stderr, append([]interface{}{time.Now().UTC().Format(time.RFC3339), "[TEST]", l}, args...)...) } func logError(l string, args ...interface{}) { - fmt.Println(append([]interface{}{"[ERROR]", l}, args...)...) + fmt.Fprintln(os.Stderr, append([]interface{}{time.Now().UTC().Format(time.RFC3339), "[ERROR]", l}, args...)...) } -func getDSN() (string, string) { - var ( - dsn string - initDSN string - ) - if *socket == "" { - initDSN = fmt.Sprintf("%s:%s@tcp(%s:%d)/", *user, *passwd, *host, *port) - } else { - initDSN = fmt.Sprintf("%s:%s@unix(%s)/", *user, *passwd, *socket) - } - dsn = fmt.Sprintf("%s%s", initDSN, *dbname) - return initDSN, dsn +func getConfigs() (*mysql.Config, *mysql.Config, error) { + return dbutil.Configs(dbutil.Options{ + Host: *host, Port: *port, User: *user, Password: *passwd, + PasswordFile: *passwordFile, Database: *dbname, Socket: *socket, + TLS: *tlsEnabled, TLSCA: *tlsCA, TLSServerName: *tlsServerName, + AllowEmptyPassword: *allowEmptyPassword, AllowInsecureTransport: *allowInsecureTransport, + }) } func main() { - initDSN, dsn := getDSN() + flag.Parse() + if !*clearDB { + logError("integration tests replace the selected database; pass -clear only for a disposable database") + os.Exit(1) + } + bootstrapConfig, databaseConfig, err := getConfigs() + if err != nil { + logError("database configuration", err) + os.Exit(1) + } - log("connect to dsn", initDSN) - connect, err := NewConnect(initDSN) + log("connect", dbutil.Target(databaseConfig)) + connect, err := NewConnect(bootstrapConfig) if err != nil { panic(err) } log("init environment") - connect.Init(initDSN) + connect.Init() log("init database") - connect.MustExec(DB_DROP) - connect.MustExec(DB_CREATE) - if err := connect.ReConnect(dsn); err != nil { + connect.MustExec(fmt.Sprintf(DB_DROP, util.QuoteIdentifier(*dbname))) + connect.MustExec(fmt.Sprintf(DB_CREATE, util.QuoteIdentifier(*dbname))) + if err := connect.ReConnect(databaseConfig); err != nil { panic(err) } @@ -67,7 +78,11 @@ func main() { connect.MustExec(COMMENTS_TABLE) ss := sqlsmith.New() - ss.LoadSchema(schema, indexes) + testSchema := append([][5]string(nil), schema...) + for i := range testSchema { + testSchema[i][0] = *dbname + } + ss.LoadSchema(testSchema, indexes) ss.SetDB(*dbname) // insert data @@ -132,7 +147,8 @@ func main() { logError(createSQL) panic(err) } - _, ok = tables[table] + _, exists := tables[table] + ok = !exists tables[table] = struct{}{} } connect.MustExec(createSQL) diff --git a/tests/sqls.go b/tests/sqls.go index d60c58b..f50aae2 100644 --- a/tests/sqls.go +++ b/tests/sqls.go @@ -1,10 +1,8 @@ package main const ( - SQL_MODE = `SET @@GLOBAL.SQL_MODE="NO_ENGINE_SUBSTITUTION"` - - DB_DROP = `DROP DATABASE IF EXISTS test` - DB_CREATE = `CREATE DATABASE test` + DB_DROP = `DROP DATABASE IF EXISTS %s` + DB_CREATE = `CREATE DATABASE %s` PULLS_DROP = `DROP TABLE IF EXISTS pulls` PULLS_TABLE = `CREATE TABLE pulls ( diff --git a/util/security_test.go b/util/security_test.go new file mode 100644 index 0000000..5c51033 --- /dev/null +++ b/util/security_test.go @@ -0,0 +1,43 @@ +package util_test + +import ( + "testing" + + "github.com/chaos-mesh/go-sqlsmith/util" + "github.com/pingcap/tidb/pkg/parser" + "github.com/pingcap/tidb/pkg/parser/ast" + _ "github.com/pingcap/tidb/pkg/types/parser_driver" + "github.com/stretchr/testify/require" +) + +func TestRestoreIdentifiersRemainSingleNames(t *testing.T) { + for _, name := range []string{"select", "has space", "中文", "a.b", "x` DROP COLUMN victim, ADD INDEX `y", "x*/WHERE 1=1/*"} { + t.Run(name, func(t *testing.T) { + node := &ast.AlterTableStmt{ + Table: &ast.TableName{Schema: ast.NewCIStr(name), Name: ast.NewCIStr(name)}, + Specs: []*ast.AlterTableSpec{{Tp: ast.AlterTableDropIndex, Name: name}}, + } + sql, err := util.BufferOut(node) + require.NoError(t, err) + parsed, err := parser.New().ParseOneStmt(sql, "", "") + require.NoError(t, err, sql) + alter := parsed.(*ast.AlterTableStmt) + require.Equal(t, name, alter.Table.Schema.O) + require.Equal(t, name, alter.Table.Name.O) + require.Len(t, alter.Specs, 1) + require.Equal(t, name, alter.Specs[0].Name) + }) + } +} + +func TestRestoreStringRoundTrip(t *testing.T) { + value := "quote\" and backslash\\ followed by \" OR 1=1 #" + node := &ast.SelectStmt{SelectStmtOpts: &ast.SelectStmtOpts{}, Fields: &ast.FieldList{ + Fields: []*ast.SelectField{{Expr: ast.NewValueExpr(value, "", "")}}, + }} + sql, err := util.BufferOut(node) + require.NoError(t, err) + parsed, err := parser.New().ParseOneStmt(sql, "", "") + require.NoError(t, err, sql) + require.Equal(t, value, parsed.(*ast.SelectStmt).Fields.Fields[0].Expr.(ast.ValueExpr).GetValue()) +} diff --git a/util/util.go b/util/util.go index 5f29068..9ddd509 100644 --- a/util/util.go +++ b/util/util.go @@ -15,6 +15,7 @@ package util import ( "bytes" + "strings" "time" "github.com/ngaut/log" @@ -25,13 +26,20 @@ import ( // BufferOut parser ast node to SQL string func BufferOut(node ast.Node) (string, error) { out := new(bytes.Buffer) - err := node.Restore(format.NewRestoreCtx(format.RestoreStringDoubleQuotes, out)) + flags := format.RestoreStringDoubleQuotes | format.RestoreNameBackQuotes + err := node.Restore(format.NewRestoreCtx(flags, out)) if err != nil { return "", err } return string(out.Bytes()), nil } +// QuoteIdentifier quotes one MySQL identifier, including embedded backticks. +// Qualified names must quote each component separately. +func QuoteIdentifier(name string) string { + return "`" + strings.ReplaceAll(name, "`", "``") + "`" +} + // TimeMustParse wrap time.Parse and panic when error func TimeMustParse(layout, value string) time.Time { t, err := time.Parse(layout, value)