PostgreSQL backup tool with Point-In-Time-Recovery and restore verification
TypeScript backupbackupsdatabasedatabase-backupdevopsdockergolangkubernetesmariadbmongodbmysqlpgpostgrespostgresqls3self-hostedsystem-administrationtoolsweb-ui
FEATURE (secutiry): Add read-only user creation before Postgresus backups
Rostislav Dugin51866437fdd2
diff --git a/.gitignore b/.gitignoreindex 1987e85a..9c96f2ab 100644--- a/.gitignore+++ b/.gitignore@@ -4,4 +4,5 @@ postgresus-data/pgdata/docker-compose.ymlnode_modules/-.idea\ No newline at end of file+.idea+/articles\ No newline at end of filediff --git a/backend/internal/features/databases/controller.go b/backend/internal/features/databases/controller.goindex 0e4f30a7..eae5a7c9 100644--- a/backend/internal/features/databases/controller.go+++ b/backend/internal/features/databases/controller.go@@ -26,7 +26,8 @@ func (c *DatabaseController) RegisterRoutes(router *gin.RouterGroup) {router.POST("/databases/test-connection-direct", c.TestDatabaseConnectionDirect)router.POST("/databases/:id/copy", c.CopyDatabase)router.GET("/databases/notifier/:id/is-using", c.IsNotifierUsing)-+ router.POST("/databases/is-readonly", c.IsUserReadOnly)+ router.POST("/databases/create-readonly-user", c.CreateReadOnlyUser)}// CreateDatabase@@ -330,3 +331,76 @@ func (c *DatabaseController) CopyDatabase(ctx *gin.Context) {ctx.JSON(http.StatusCreated, copiedDatabase)}++// IsUserReadOnly+// @Summary Check if database user is read-only+// @Description Check if current database credentials have only read (SELECT) privileges+// @Tags databases+// @Accept json+// @Produce json+// @Security BearerAuth+// @Param request body Database true "Database configuration to check"+// @Success 200 {object} IsReadOnlyResponse+// @Failure 400 {object} map[string]string+// @Failure 401 {object} map[string]string+// @Failure 403 {object} map[string]string+// @Router /databases/is-readonly [post]+func (c *DatabaseController) IsUserReadOnly(ctx *gin.Context) {+ user, ok := users_middleware.GetUserFromContext(ctx)+ if !ok {+ ctx.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})+ return+ }++ var request Database+ if err := ctx.ShouldBindJSON(&request); err != nil {+ ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})+ return+ }++ isReadOnly, err := c.databaseService.IsUserReadOnly(user, &request)+ if err != nil {+ ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})+ return+ }++ ctx.JSON(http.StatusOK, IsReadOnlyResponse{IsReadOnly: isReadOnly})+}++// CreateReadOnlyUser+// @Summary Create read-only database user+// @Description Create a new PostgreSQL user with read-only privileges for backup operations+// @Tags databases+// @Accept json+// @Produce json+// @Security BearerAuth+// @Param request body Database true "Database configuration to create user for"+// @Success 200 {object} CreateReadOnlyUserResponse+// @Failure 400 {object} map[string]string+// @Failure 401 {object} map[string]string+// @Failure 403 {object} map[string]string+// @Router /databases/create-readonly-user [post]+func (c *DatabaseController) CreateReadOnlyUser(ctx *gin.Context) {+ user, ok := users_middleware.GetUserFromContext(ctx)+ if !ok {+ ctx.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})+ return+ }++ var request Database+ if err := ctx.ShouldBindJSON(&request); err != nil {+ ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})+ return+ }++ username, password, err := c.databaseService.CreateReadOnlyUser(user, &request)+ if err != nil {+ ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})+ return+ }++ ctx.JSON(http.StatusOK, CreateReadOnlyUserResponse{+ Username: username,+ Password: password,+ })+}diff --git a/backend/internal/features/databases/databases/postgresql/model.go b/backend/internal/features/databases/databases/postgresql/model.goindex b8b5a4d3..e51a1673 100644--- a/backend/internal/features/databases/databases/postgresql/model.go+++ b/backend/internal/features/databases/databases/postgresql/model.go@@ -8,6 +8,7 @@ import ("postgresus-backend/internal/util/encryption""postgresus-backend/internal/util/tools""regexp"+ "strings""time""github.com/google/uuid"@@ -106,6 +107,384 @@ func (p *PostgresqlDatabase) EncryptSensitiveFields(return nil}+// IsUserReadOnly checks if the database user has read-only privileges.+//+// This method performs a comprehensive security check by examining:+// - Role-level attributes (superuser, createrole, createdb)+// - Database-level privileges (CREATE, TEMP)+// - Table-level write permissions (INSERT, UPDATE, DELETE, TRUNCATE, REFERENCES, TRIGGER)+//+// A user is considered read-only only if they have ZERO write privileges+// across all three levels. This ensures the database user follows the+// principle of least privilege for backup operations.+func (p *PostgresqlDatabase) IsUserReadOnly(+ ctx context.Context,+ logger *slog.Logger,+ encryptor encryption.FieldEncryptor,+ databaseID uuid.UUID,+) (bool, error) {+ password, err := decryptPasswordIfNeeded(p.Password, encryptor, databaseID)+ if err != nil {+ return false, fmt.Errorf("failed to decrypt password: %w", err)+ }++ connStr := buildConnectionStringForDB(p, *p.Database, password)++ conn, err := pgx.Connect(ctx, connStr)+ if err != nil {+ return false, fmt.Errorf("failed to connect to database: %w", err)+ }+ defer func() {+ if closeErr := conn.Close(ctx); closeErr != nil {+ logger.Error("Failed to close connection", "error", closeErr)+ }+ }()++ // LEVEL 1: Check role-level attributes+ var isSuperuser, canCreateRole, canCreateDB bool+ err = conn.QueryRow(ctx, `+ SELECT+ rolsuper,+ rolcreaterole,+ rolcreatedb+ FROM pg_roles+ WHERE rolname = current_user+ `).Scan(&isSuperuser, &canCreateRole, &canCreateDB)+ if err != nil {+ return false, fmt.Errorf("failed to check role attributes: %w", err)+ }++ if isSuperuser || canCreateRole || canCreateDB {+ return false, nil+ }++ // LEVEL 2: Check database-level privileges+ var canCreate, canTemp bool+ err = conn.QueryRow(ctx, `+ SELECT+ has_database_privilege(current_user, current_database(), 'CREATE') as can_create,+ has_database_privilege(current_user, current_database(), 'TEMP') as can_temp+ `).Scan(&canCreate, &canTemp)+ if err != nil {+ return false, fmt.Errorf("failed to check database privileges: %w", err)+ }++ if canCreate || canTemp {+ return false, nil+ }++ // LEVEL 2.5: Check schema-level CREATE privileges+ schemaRows, err := conn.Query(ctx, `+ SELECT DISTINCT nspname+ FROM pg_namespace n+ WHERE has_schema_privilege(current_user, n.nspname, 'CREATE')+ AND nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')+ `)+ if err != nil {+ return false, fmt.Errorf("failed to check schema privileges: %w", err)+ }+ defer schemaRows.Close()++ // If user has CREATE privilege on any schema, they're not read-only+ if schemaRows.Next() {+ return false, nil+ }++ if err := schemaRows.Err(); err != nil {+ return false, fmt.Errorf("error iterating schema privileges: %w", err)+ }++ // LEVEL 3: Check table-level write permissions+ rows, err := conn.Query(ctx, `+ SELECT DISTINCT privilege_type+ FROM information_schema.role_table_grants+ WHERE grantee = current_user+ AND table_schema NOT IN ('pg_catalog', 'information_schema')+ `)+ if err != nil {+ return false, fmt.Errorf("failed to check table privileges: %w", err)+ }+ defer rows.Close()++ writePrivileges := map[string]bool{+ "INSERT": true,+ "UPDATE": true,+ "DELETE": true,+ "TRUNCATE": true,+ "REFERENCES": true,+ "TRIGGER": true,+ }++ for rows.Next() {+ var privilege string+ if err := rows.Scan(&privilege); err != nil {+ return false, fmt.Errorf("failed to scan privilege: %w", err)+ }++ if writePrivileges[privilege] {+ return false, nil+ }+ }++ if err := rows.Err(); err != nil {+ return false, fmt.Errorf("error iterating privileges: %w", err)+ }++ return true, nil+}++// CreateReadOnlyUser creates a new PostgreSQL user with read-only privileges.+//+// This method performs the following operations atomically in a single transaction:+// 1. Creates a PostgreSQL user with a UUID-based password+// 2. Grants CONNECT privilege on the database+// 3. Grants USAGE on all non-system schemas+// 4. Grants SELECT on all existing tables and sequences+// 5. Sets default privileges for future tables and sequences+//+// Security features:+// - Username format: "postgresus-{8-char-uuid}" for uniqueness+// - Password: Full UUID (36 characters) for strong entropy+// - Transaction safety: All operations rollback on any failure+// - Retry logic: Up to 3 attempts if username collision occurs+// - Pre-validation: Checks CREATEROLE privilege before starting transaction+func (p *PostgresqlDatabase) CreateReadOnlyUser(+ ctx context.Context,+ logger *slog.Logger,+ encryptor encryption.FieldEncryptor,+ databaseID uuid.UUID,+) (string, string, error) {+ password, err := decryptPasswordIfNeeded(p.Password, encryptor, databaseID)+ if err != nil {+ return "", "", fmt.Errorf("failed to decrypt password: %w", err)+ }++ connStr := buildConnectionStringForDB(p, *p.Database, password)++ conn, err := pgx.Connect(ctx, connStr)+ if err != nil {+ return "", "", fmt.Errorf("failed to connect to database: %w", err)+ }+ defer func() {+ if closeErr := conn.Close(ctx); closeErr != nil {+ logger.Error("Failed to close connection", "error", closeErr)+ }+ }()++ // Pre-validate: Check if current user can create roles+ var canCreateRole, isSuperuser bool+ err = conn.QueryRow(ctx, `+ SELECT rolcreaterole, rolsuper+ FROM pg_roles+ WHERE rolname = current_user+ `).Scan(&canCreateRole, &isSuperuser)+ if err != nil {+ return "", "", fmt.Errorf("failed to check permissions: %w", err)+ }+ if !canCreateRole && !isSuperuser {+ return "", "", errors.New("current database user lacks CREATEROLE privilege")+ }++ // Retry logic for username collision+ maxRetries := 3+ for attempt := 0; attempt < maxRetries; attempt++ {+ username := fmt.Sprintf("postgresus-%s", uuid.New().String()[:8])+ newPassword := uuid.New().String()++ tx, err := conn.Begin(ctx)+ if err != nil {+ return "", "", fmt.Errorf("failed to begin transaction: %w", err)+ }++ success := false+ defer func() {+ if !success {+ if rollbackErr := tx.Rollback(ctx); rollbackErr != nil {+ logger.Error("Failed to rollback transaction", "error", rollbackErr)+ }+ }+ }()++ // Step 1: Create PostgreSQL user with LOGIN privilege+ _, err = tx.Exec(+ ctx,+ fmt.Sprintf(`CREATE USER "%s" WITH PASSWORD '%s' LOGIN`, username, newPassword),+ )+ if err != nil {+ if err.Error() != "" && attempt < maxRetries-1 {+ continue+ }+ return "", "", fmt.Errorf("failed to create user: %w", err)+ }++ // Step 1.5: Revoke CREATE privilege from PUBLIC role on public schema+ // This is necessary because all PostgreSQL users inherit CREATE privilege on the+ // public schema through the PUBLIC role. This is a one-time operation that affects+ // the entire database, making it more secure by default.+ // Note: This only affects the public schema; other schemas are unaffected.+ _, err = tx.Exec(ctx, `REVOKE CREATE ON SCHEMA public FROM PUBLIC`)+ if err != nil {+ logger.Error("Failed to revoke CREATE on public from PUBLIC", "error", err)+ if !strings.Contains(err.Error(), "schema \"public\" does not exist") &&+ !strings.Contains(err.Error(), "permission denied") {+ return "", "", fmt.Errorf("failed to revoke CREATE from PUBLIC: %w", err)+ }+ }++ // Now revoke from the specific user as well (belt and suspenders)+ _, err = tx.Exec(ctx, fmt.Sprintf(`REVOKE CREATE ON SCHEMA public FROM "%s"`, username))+ if err != nil {+ logger.Error(+ "Failed to revoke CREATE on public schema from user",+ "error",+ err,+ "username",+ username,+ )+ }++ // Step 2: Grant database connection privilege and revoke TEMP+ _, err = tx.Exec(+ ctx,+ fmt.Sprintf(`GRANT CONNECT ON DATABASE %s TO "%s"`, *p.Database, username),+ )+ if err != nil {+ return "", "", fmt.Errorf("failed to grant connect privilege: %w", err)+ }++ // Revoke TEMP privilege from PUBLIC role (like CREATE on public schema, TEMP is granted to PUBLIC by default)+ _, err = tx.Exec(ctx, fmt.Sprintf(`REVOKE TEMP ON DATABASE %s FROM PUBLIC`, *p.Database))+ if err != nil {+ logger.Warn("Failed to revoke TEMP from PUBLIC", "error", err)+ }++ // Also revoke from the specific user (belt and suspenders)+ _, err = tx.Exec(+ ctx,+ fmt.Sprintf(`REVOKE TEMP ON DATABASE %s FROM "%s"`, *p.Database, username),+ )+ if err != nil {+ logger.Warn("Failed to revoke TEMP privilege", "error", err, "username", username)+ }++ // Step 3: Discover all user-created schemas+ rows, err := tx.Query(ctx, `+ SELECT schema_name+ FROM information_schema.schemata+ WHERE schema_name NOT IN ('pg_catalog', 'information_schema')+ `)+ if err != nil {+ return "", "", fmt.Errorf("failed to get schemas: %w", err)+ }++ var schemas []string+ for rows.Next() {+ var schema string+ if err := rows.Scan(&schema); err != nil {+ rows.Close()+ return "", "", fmt.Errorf("failed to scan schema: %w", err)+ }+ schemas = append(schemas, schema)+ }+ rows.Close()++ if err := rows.Err(); err != nil {+ return "", "", fmt.Errorf("error iterating schemas: %w", err)+ }++ // Step 4: Grant USAGE on each schema and explicitly prevent CREATE+ for _, schema := range schemas {+ // Revoke CREATE specifically (handles inheritance from PUBLIC role)+ _, err = tx.Exec(+ ctx,+ fmt.Sprintf(`REVOKE CREATE ON SCHEMA "%s" FROM "%s"`, schema, username),+ )+ if err != nil {+ logger.Warn(+ "Failed to revoke CREATE on schema",+ "error",+ err,+ "schema",+ schema,+ "username",+ username,+ )+ }++ // Grant only USAGE (not CREATE)+ _, err = tx.Exec(+ ctx,+ fmt.Sprintf(`GRANT USAGE ON SCHEMA "%s" TO "%s"`, schema, username),+ )+ if err != nil {+ return "", "", fmt.Errorf("failed to grant usage on schema %s: %w", schema, err)+ }+ }++ // Step 5: Grant SELECT on ALL existing tables and sequences+ grantSelectSQL := fmt.Sprintf(`+ DO $$+ DECLARE+ schema_rec RECORD;+ BEGIN+ FOR schema_rec IN+ SELECT schema_name+ FROM information_schema.schemata+ WHERE schema_name NOT IN ('pg_catalog', 'information_schema')+ LOOP+ EXECUTE format('GRANT SELECT ON ALL TABLES IN SCHEMA %%I TO "%s"', schema_rec.schema_name);+ EXECUTE format('GRANT SELECT ON ALL SEQUENCES IN SCHEMA %%I TO "%s"', schema_rec.schema_name);+ END LOOP;+ END $$;+ `, username, username)++ _, err = tx.Exec(ctx, grantSelectSQL)+ if err != nil {+ return "", "", fmt.Errorf("failed to grant select on tables: %w", err)+ }++ // Step 6: Set default privileges for FUTURE tables and sequences+ defaultPrivilegesSQL := fmt.Sprintf(`+ DO $$+ DECLARE+ schema_rec RECORD;+ BEGIN+ FOR schema_rec IN+ SELECT schema_name+ FROM information_schema.schemata+ WHERE schema_name NOT IN ('pg_catalog', 'information_schema')+ LOOP+ EXECUTE format('ALTER DEFAULT PRIVILEGES IN SCHEMA %%I GRANT SELECT ON TABLES TO "%s"', schema_rec.schema_name);+ EXECUTE format('ALTER DEFAULT PRIVILEGES IN SCHEMA %%I GRANT SELECT ON SEQUENCES TO "%s"', schema_rec.schema_name);+ END LOOP;+ END $$;+ `, username, username)++ _, err = tx.Exec(ctx, defaultPrivilegesSQL)+ if err != nil {+ return "", "", fmt.Errorf("failed to set default privileges: %w", err)+ }++ // Step 7: Verify user creation before committing+ var verifyUsername string+ err = tx.QueryRow(ctx, fmt.Sprintf(`SELECT rolname FROM pg_roles WHERE rolname = '%s'`, username)).+ Scan(&verifyUsername)+ if err != nil {+ return "", "", fmt.Errorf("failed to verify user creation: %w", err)+ }++ if err := tx.Commit(ctx); err != nil {+ return "", "", fmt.Errorf("failed to commit transaction: %w", err)+ }++ success = true+ logger.Info("Read-only user created successfully", "username", username)+ return username, newPassword, nil+ }++ return "", "", errors.New("failed to generate unique username after 3 attempts")+}+// testSingleDatabaseConnection tests connection to a specific database for pg_dumpfunc testSingleDatabaseConnection(logger *slog.Logger,diff --git a/backend/internal/features/databases/databases/postgresql/readonly_user_test.go b/backend/internal/features/databases/databases/postgresql/readonly_user_test.gonew file mode 100644index 00000000..b55fee9c--- /dev/null+++ b/backend/internal/features/databases/databases/postgresql/readonly_user_test.go@@ -0,0 +1,323 @@+package postgresql++import (+ "context"+ "fmt"+ "log/slog"+ "os"+ "strconv"+ "strings"+ "testing"++ "github.com/google/uuid"+ "github.com/jmoiron/sqlx"+ _ "github.com/lib/pq"+ "github.com/stretchr/testify/assert"++ "postgresus-backend/internal/config"+ "postgresus-backend/internal/util/tools"+)++func Test_IsUserReadOnly_AdminUser_ReturnsFalse(t *testing.T) {+ env := config.GetEnv()+ cases := []struct {+ name string+ version string+ port string+ }{+ {"PostgreSQL 12", "12", env.TestPostgres12Port},+ {"PostgreSQL 13", "13", env.TestPostgres13Port},+ {"PostgreSQL 14", "14", env.TestPostgres14Port},+ {"PostgreSQL 15", "15", env.TestPostgres15Port},+ {"PostgreSQL 16", "16", env.TestPostgres16Port},+ {"PostgreSQL 17", "17", env.TestPostgres17Port},+ }++ for _, tc := range cases {+ t.Run(tc.name, func(t *testing.T) {+ t.Parallel()++ container := connectToPostgresContainer(t, tc.port)+ defer container.DB.Close()++ pgModel := createPostgresModel(container)+ logger := slog.New(slog.NewTextHandler(os.Stdout, nil))+ ctx := context.Background()++ isReadOnly, err := pgModel.IsUserReadOnly(ctx, logger, nil, uuid.New())+ assert.NoError(t, err)+ assert.False(t, isReadOnly, "Admin user should not be read-only")+ })+ }+}++func Test_CreateReadOnlyUser_UserCanReadButNotWrite(t *testing.T) {+ env := config.GetEnv()+ cases := []struct {+ name string+ version string+ port string+ }{+ {"PostgreSQL 12", "12", env.TestPostgres12Port},+ {"PostgreSQL 13", "13", env.TestPostgres13Port},+ {"PostgreSQL 14", "14", env.TestPostgres14Port},+ {"PostgreSQL 15", "15", env.TestPostgres15Port},+ {"PostgreSQL 16", "16", env.TestPostgres16Port},+ {"PostgreSQL 17", "17", env.TestPostgres17Port},+ }++ for _, tc := range cases {+ t.Run(tc.name, func(t *testing.T) {+ t.Parallel()++ container := connectToPostgresContainer(t, tc.port)+ defer container.DB.Close()++ _, err := container.DB.Exec(`+ DROP TABLE IF EXISTS readonly_test CASCADE;+ DROP TABLE IF EXISTS hack_table CASCADE;+ DROP TABLE IF EXISTS future_table CASCADE;+ CREATE TABLE readonly_test (+ id SERIAL PRIMARY KEY,+ data TEXT NOT NULL+ );+ INSERT INTO readonly_test (data) VALUES ('test1'), ('test2');+ `)+ assert.NoError(t, err)++ pgModel := createPostgresModel(container)+ logger := slog.New(slog.NewTextHandler(os.Stdout, nil))+ ctx := context.Background()++ username, password, err := pgModel.CreateReadOnlyUser(ctx, logger, nil, uuid.New())+ assert.NoError(t, err)+ assert.NotEmpty(t, username)+ assert.NotEmpty(t, password)+ assert.True(t, strings.HasPrefix(username, "postgresus-"))++ readOnlyModel := &PostgresqlDatabase{+ Version: pgModel.Version,+ Host: pgModel.Host,+ Port: pgModel.Port,+ Username: username,+ Password: password,+ Database: pgModel.Database,+ IsHttps: false,+ }++ isReadOnly, err := readOnlyModel.IsUserReadOnly(ctx, logger, nil, uuid.New())+ assert.NoError(t, err)+ assert.True(t, isReadOnly, "Created user should be read-only")++ readOnlyDSN := fmt.Sprintf(+ "host=%s port=%d user=%s password=%s dbname=%s sslmode=disable",+ container.Host,+ container.Port,+ username,+ password,+ container.Database,+ )+ readOnlyConn, err := sqlx.Connect("postgres", readOnlyDSN)+ assert.NoError(t, err)+ defer readOnlyConn.Close()++ var count int+ err = readOnlyConn.Get(&count, "SELECT COUNT(*) FROM readonly_test")+ assert.NoError(t, err)+ assert.Equal(t, 2, count)++ _, err = readOnlyConn.Exec("INSERT INTO readonly_test (data) VALUES ('should-fail')")+ assert.Error(t, err)+ assert.Contains(t, err.Error(), "permission denied")++ _, err = readOnlyConn.Exec("UPDATE readonly_test SET data = 'hacked' WHERE id = 1")+ assert.Error(t, err)+ assert.Contains(t, err.Error(), "permission denied")++ _, err = readOnlyConn.Exec("DELETE FROM readonly_test WHERE id = 1")+ assert.Error(t, err)+ assert.Contains(t, err.Error(), "permission denied")++ _, err = readOnlyConn.Exec("CREATE TABLE hack_table (id INT)")+ assert.Error(t, err)+ assert.Contains(t, err.Error(), "permission denied")++ // Clean up: Drop user with CASCADE to handle default privilege dependencies+ _, err = container.DB.Exec(fmt.Sprintf(`DROP OWNED BY "%s" CASCADE`, username))+ if err != nil {+ t.Logf("Warning: Failed to drop owned objects: %v", err)+ }++ _, err = container.DB.Exec(fmt.Sprintf(`DROP USER IF EXISTS "%s"`, username))+ assert.NoError(t, err)+ })+ }+}++func Test_ReadOnlyUser_FutureTables_HaveSelectPermission(t *testing.T) {+ env := config.GetEnv()+ container := connectToPostgresContainer(t, env.TestPostgres16Port)+ defer container.DB.Close()++ pgModel := createPostgresModel(container)+ logger := slog.New(slog.NewTextHandler(os.Stdout, nil))+ ctx := context.Background()++ username, password, err := pgModel.CreateReadOnlyUser(ctx, logger, nil, uuid.New())+ assert.NoError(t, err)++ _, err = container.DB.Exec(`+ CREATE TABLE future_table (+ id SERIAL PRIMARY KEY,+ data TEXT NOT NULL+ );+ INSERT INTO future_table (data) VALUES ('future_data');+ `)+ assert.NoError(t, err)++ readOnlyDSN := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable",+ container.Host, container.Port, username, password, container.Database)+ readOnlyConn, err := sqlx.Connect("postgres", readOnlyDSN)+ assert.NoError(t, err)+ defer readOnlyConn.Close()++ var data string+ err = readOnlyConn.Get(&data, "SELECT data FROM future_table LIMIT 1")+ assert.NoError(t, err)+ assert.Equal(t, "future_data", data)++ // Clean up: Drop user with CASCADE to handle default privilege dependencies+ _, err = container.DB.Exec(fmt.Sprintf(`DROP OWNED BY "%s" CASCADE`, username))+ if err != nil {+ t.Logf("Warning: Failed to drop owned objects: %v", err)+ }++ _, err = container.DB.Exec(fmt.Sprintf(`DROP USER IF EXISTS "%s"`, username))+ assert.NoError(t, err)+}++func Test_ReadOnlyUser_MultipleSchemas_AllAccessible(t *testing.T) {+ env := config.GetEnv()+ container := connectToPostgresContainer(t, env.TestPostgres16Port)+ defer container.DB.Close()++ _, err := container.DB.Exec(`+ CREATE SCHEMA IF NOT EXISTS schema_a;+ CREATE SCHEMA IF NOT EXISTS schema_b;+ CREATE TABLE schema_a.table_a (id INT, data TEXT);+ CREATE TABLE schema_b.table_b (id INT, data TEXT);+ INSERT INTO schema_a.table_a VALUES (1, 'data_a');+ INSERT INTO schema_b.table_b VALUES (2, 'data_b');+ `)+ assert.NoError(t, err)++ pgModel := createPostgresModel(container)+ logger := slog.New(slog.NewTextHandler(os.Stdout, nil))+ ctx := context.Background()++ username, password, err := pgModel.CreateReadOnlyUser(ctx, logger, nil, uuid.New())+ assert.NoError(t, err)++ readOnlyDSN := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable",+ container.Host, container.Port, username, password, container.Database)+ readOnlyConn, err := sqlx.Connect("postgres", readOnlyDSN)+ assert.NoError(t, err)+ defer readOnlyConn.Close()++ var dataA string+ err = readOnlyConn.Get(&dataA, "SELECT data FROM schema_a.table_a LIMIT 1")+ assert.NoError(t, err)+ assert.Equal(t, "data_a", dataA)++ var dataB string+ err = readOnlyConn.Get(&dataB, "SELECT data FROM schema_b.table_b LIMIT 1")+ assert.NoError(t, err)+ assert.Equal(t, "data_b", dataB)++ // Clean up: Drop user with CASCADE to handle default privilege dependencies+ _, err = container.DB.Exec(fmt.Sprintf(`DROP OWNED BY "%s" CASCADE`, username))+ if err != nil {+ t.Logf("Warning: Failed to drop owned objects: %v", err)+ }++ _, err = container.DB.Exec(fmt.Sprintf(`DROP USER IF EXISTS "%s"`, username))+ assert.NoError(t, err)+ _, err = container.DB.Exec(`DROP SCHEMA schema_a CASCADE; DROP SCHEMA schema_b CASCADE;`)+ assert.NoError(t, err)+}++type PostgresContainer struct {+ Host string+ Port int+ Username string+ Password string+ Database string+ DB *sqlx.DB+}++func connectToPostgresContainer(t *testing.T, port string) *PostgresContainer {+ dbName := "testdb"+ password := "testpassword"+ username := "testuser"+ host := "localhost"++ portInt, err := strconv.Atoi(port)+ assert.NoError(t, err)++ dsn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable",+ host, portInt, username, password, dbName)++ db, err := sqlx.Connect("postgres", dsn)+ assert.NoError(t, err)++ var versionStr string+ err = db.Get(&versionStr, "SELECT version()")+ assert.NoError(t, err)++ return &PostgresContainer{+ Host: host,+ Port: portInt,+ Username: username,+ Password: password,+ Database: dbName,+ DB: db,+ }+}++func createPostgresModel(container *PostgresContainer) *PostgresqlDatabase {+ var versionStr string+ err := container.DB.Get(&versionStr, "SELECT version()")+ if err != nil {+ return nil+ }++ version := extractPostgresVersion(versionStr)++ return &PostgresqlDatabase{+ Version: version,+ Host: container.Host,+ Port: container.Port,+ Username: container.Username,+ Password: container.Password,+ Database: &container.Database,+ IsHttps: false,+ }+}++func extractPostgresVersion(versionStr string) tools.PostgresqlVersion {+ if strings.Contains(versionStr, "PostgreSQL 12") {+ return tools.GetPostgresqlVersionEnum("12")+ } else if strings.Contains(versionStr, "PostgreSQL 13") {+ return tools.GetPostgresqlVersionEnum("13")+ } else if strings.Contains(versionStr, "PostgreSQL 14") {+ return tools.GetPostgresqlVersionEnum("14")+ } else if strings.Contains(versionStr, "PostgreSQL 15") {+ return tools.GetPostgresqlVersionEnum("15")+ } else if strings.Contains(versionStr, "PostgreSQL 16") {+ return tools.GetPostgresqlVersionEnum("16")+ } else if strings.Contains(versionStr, "PostgreSQL 17") {+ return tools.GetPostgresqlVersionEnum("17")+ }++ return tools.GetPostgresqlVersionEnum("16")+}diff --git a/backend/internal/features/databases/dto.go b/backend/internal/features/databases/dto.gonew file mode 100644index 00000000..16c80622--- /dev/null+++ b/backend/internal/features/databases/dto.go@@ -0,0 +1,10 @@+package databases++type CreateReadOnlyUserResponse struct {+ Username string `json:"username"`+ Password string `json:"password"`+}++type IsReadOnlyResponse struct {+ IsReadOnly bool `json:"isReadOnly"`+}diff --git a/backend/internal/features/databases/service.go b/backend/internal/features/databases/service.goindex 5ac99c3e..4fe065b6 100644--- a/backend/internal/features/databases/service.go+++ b/backend/internal/features/databases/service.go@@ -1,6 +1,7 @@package databasesimport (+ "context""errors""fmt""log/slog"@@ -456,3 +457,148 @@ func (s *DatabaseService) OnBeforeWorkspaceDeletion(workspaceID uuid.UUID) errorreturn nil}++func (s *DatabaseService) IsUserReadOnly(+ user *users_models.User,+ database *Database,+) (bool, error) {+ var usingDatabase *Database++ if database.ID != uuid.Nil {+ existingDatabase, err := s.dbRepository.FindByID(database.ID)+ if err != nil {+ return false, err+ }++ if existingDatabase.WorkspaceID == nil {+ return false, errors.New("cannot check user for database without workspace")+ }++ canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(+ *existingDatabase.WorkspaceID,+ user,+ )+ if err != nil {+ return false, err+ }+ if !canAccess {+ return false, errors.New("insufficient permissions to access this database")+ }++ if database.WorkspaceID != nil && *existingDatabase.WorkspaceID != *database.WorkspaceID {+ return false, errors.New("database does not belong to this workspace")+ }++ existingDatabase.Update(database)++ if err := existingDatabase.Validate(); err != nil {+ return false, err+ }++ usingDatabase = existingDatabase+ } else {+ if database.WorkspaceID != nil {+ canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(*database.WorkspaceID, user)+ if err != nil {+ return false, err+ }+ if !canAccess {+ return false, errors.New("insufficient permissions to access this workspace")+ }+ }++ usingDatabase = database+ }++ if usingDatabase.Type != DatabaseTypePostgres {+ return false, errors.New("read-only check only supported for PostgreSQL databases")+ }++ ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)+ defer cancel()++ return usingDatabase.Postgresql.IsUserReadOnly(+ ctx,+ s.logger,+ s.fieldEncryptor,+ usingDatabase.ID,+ )+}++func (s *DatabaseService) CreateReadOnlyUser(+ user *users_models.User,+ database *Database,+) (string, string, error) {+ var usingDatabase *Database++ if database.ID != uuid.Nil {+ existingDatabase, err := s.dbRepository.FindByID(database.ID)+ if err != nil {+ return "", "", err+ }++ if existingDatabase.WorkspaceID == nil {+ return "", "", errors.New("cannot create user for database without workspace")+ }++ canManage, err := s.workspaceService.CanUserManageDBs(*existingDatabase.WorkspaceID, user)+ if err != nil {+ return "", "", err+ }+ if !canManage {+ return "", "", errors.New("insufficient permissions to manage this database")+ }++ if database.WorkspaceID != nil && *existingDatabase.WorkspaceID != *database.WorkspaceID {+ return "", "", errors.New("database does not belong to this workspace")+ }++ existingDatabase.Update(database)++ if err := existingDatabase.Validate(); err != nil {+ return "", "", err+ }++ usingDatabase = existingDatabase+ } else {+ if database.WorkspaceID != nil {+ canManage, err := s.workspaceService.CanUserManageDBs(*database.WorkspaceID, user)+ if err != nil {+ return "", "", err+ }+ if !canManage {+ return "", "", errors.New("insufficient permissions to manage this workspace")+ }+ }++ usingDatabase = database+ }++ if usingDatabase.Type != DatabaseTypePostgres {+ return "", "", errors.New("read-only user creation only supported for PostgreSQL")+ }++ ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)+ defer cancel()++ username, password, err := usingDatabase.Postgresql.CreateReadOnlyUser(+ ctx, s.logger, s.fieldEncryptor, usingDatabase.ID,+ )+ if err != nil {+ return "", "", err+ }++ if usingDatabase.WorkspaceID != nil {+ s.auditLogService.WriteAuditLog(+ fmt.Sprintf(+ "Read-only user created for database: %s (username: %s)",+ usingDatabase.Name,+ username,+ ),+ &user.ID,+ usingDatabase.WorkspaceID,+ )+ }++ return username, password, nil+}diff --git a/backend/internal/features/restores/usecases/postgresql/restore_backup_uc.go b/backend/internal/features/restores/usecases/postgresql/restore_backup_uc.goindex 8a7b5933..c18190a2 100644--- a/backend/internal/features/restores/usecases/postgresql/restore_backup_uc.go+++ b/backend/internal/features/restores/usecases/postgresql/restore_backup_uc.go@@ -78,7 +78,8 @@ func (uc *RestorePostgresqlBackupUsecase) Execute("--verbose", // Add verbose output to help with debugging"--clean", // Clean (drop) database objects before recreating them"--if-exists", // Use IF EXISTS when dropping objects- "--no-owner",+ "--no-owner", // Skip restoring ownership+ "--no-acl", // Skip restoring access privileges (GRANT/REVOKE commands)}return uc.restoreFromStorage(diff --git a/frontend/src/entity/databases/api/databaseApi.ts b/frontend/src/entity/databases/api/databaseApi.tsindex ea074282..30bc7d83 100644--- a/frontend/src/entity/databases/api/databaseApi.ts+++ b/frontend/src/entity/databases/api/databaseApi.ts@@ -1,7 +1,9 @@import { getApplicationServer } from '../../../constants';import RequestOptions from '../../../shared/api/RequestOptions';import { apiHelper } from '../../../shared/api/apiHelper';+import type { CreateReadOnlyUserResponse } from '../model/CreateReadOnlyUserResponse';import type { Database } from '../model/Database';+import type { IsReadOnlyResponse } from '../model/IsReadOnlyResponse';export const databaseApi = {async createDatabase(database: Database) {@@ -85,4 +87,22 @@ export const databaseApi = {).then((res) => res.isUsing);},++ async isUserReadOnly(database: Database) {+ const requestOptions: RequestOptions = new RequestOptions();+ requestOptions.setBody(JSON.stringify(database));+ return apiHelper.fetchPostJson<IsReadOnlyResponse>(+ `${getApplicationServer()}/api/v1/databases/is-readonly`,+ requestOptions,+ );+ },++ async createReadOnlyUser(database: Database) {+ const requestOptions: RequestOptions = new RequestOptions();+ requestOptions.setBody(JSON.stringify(database));+ return apiHelper.fetchPostJson<CreateReadOnlyUserResponse>(+ `${getApplicationServer()}/api/v1/databases/create-readonly-user`,+ requestOptions,+ );+ },};diff --git a/frontend/src/entity/databases/index.ts b/frontend/src/entity/databases/index.tsindex 23f7edab..d9e6357b 100644--- a/frontend/src/entity/databases/index.ts+++ b/frontend/src/entity/databases/index.ts@@ -4,3 +4,5 @@ export { DatabaseType } from './model/DatabaseType';export { Period } from './model/Period';export { type PostgresqlDatabase } from './model/postgresql/PostgresqlDatabase';export { PostgresqlVersion } from './model/postgresql/PostgresqlVersion';+export { type IsReadOnlyResponse } from './model/IsReadOnlyResponse';+export { type CreateReadOnlyUserResponse } from './model/CreateReadOnlyUserResponse';diff --git a/frontend/src/entity/databases/model/CreateReadOnlyUserResponse.ts b/frontend/src/entity/databases/model/CreateReadOnlyUserResponse.tsnew file mode 100644index 00000000..0cce55be--- /dev/null+++ b/frontend/src/entity/databases/model/CreateReadOnlyUserResponse.ts@@ -0,0 +1,4 @@+export interface CreateReadOnlyUserResponse {+ username: string;+ password: string;+}diff --git a/frontend/src/entity/databases/model/IsReadOnlyResponse.ts b/frontend/src/entity/databases/model/IsReadOnlyResponse.tsnew file mode 100644index 00000000..7e9ae996--- /dev/null+++ b/frontend/src/entity/databases/model/IsReadOnlyResponse.ts@@ -0,0 +1,3 @@+export interface IsReadOnlyResponse {+ isReadOnly: boolean;+}diff --git a/frontend/src/features/databases/ui/CreateDatabaseComponent.tsx b/frontend/src/features/databases/ui/CreateDatabaseComponent.tsxindex 2c3c9d09..3360970b 100644--- a/frontend/src/features/databases/ui/CreateDatabaseComponent.tsx+++ b/frontend/src/features/databases/ui/CreateDatabaseComponent.tsx@@ -9,6 +9,7 @@ import {databaseApi,} from '../../../entity/databases';import { EditBackupConfigComponent } from '../../backups';+import { CreateReadOnlyComponent } from './edit/CreateReadOnlyComponent';import { EditDatabaseBaseInfoComponent } from './edit/EditDatabaseBaseInfoComponent';import { EditDatabaseNotifiersComponent } from './edit/EditDatabaseNotifiersComponent';import { EditDatabaseSpecificDataComponent } from './edit/EditDatabaseSpecificDataComponent';@@ -41,9 +42,9 @@ export const CreateDatabaseComponent = ({ workspaceId, onCreated, onClose }: ProsendNotificationsOn: [],} as Database);- const [step, setStep] = useState<'base-info' | 'db-settings' | 'backup-config' | 'notifiers'>(- 'base-info',- );+ const [step, setStep] = useState<+ 'base-info' | 'db-settings' | 'create-readonly-user' | 'backup-config' | 'notifiers'+ >('base-info');const createDatabase = async (database: Database, backupConfig: BackupConfig) => {setIsCreating(true);@@ -97,12 +98,25 @@ export const CreateDatabaseComponent = ({ workspaceId, onCreated, onClose }: ProisSaveToApi={false}onSaved={(database) => {setDatabase({ ...database });- setStep('backup-config');+ setStep('create-readonly-user');}}/>);}+ if (step === 'create-readonly-user') {+ return (+ <CreateReadOnlyComponent+ database={database}+ onReadOnlyUserUpdated={(database) => {+ setDatabase({ ...database });+ }}+ onGoBack={() => setStep('db-settings')}+ onContinue={() => setStep('backup-config')}+ />+ );+ }+if (step === 'backup-config') {return (<EditBackupConfigComponentdiff --git a/frontend/src/features/databases/ui/edit/CreateReadOnlyComponent.tsx b/frontend/src/features/databases/ui/edit/CreateReadOnlyComponent.tsxnew file mode 100644index 00000000..85556006--- /dev/null+++ b/frontend/src/features/databases/ui/edit/CreateReadOnlyComponent.tsx@@ -0,0 +1,165 @@+import { Button, Modal, Spin } from 'antd';+import { useEffect, useState } from 'react';++import { type Database, databaseApi } from '../../../../entity/databases';++interface Props {+ database: Database;+ onReadOnlyUserUpdated: (database: Database) => void;++ onGoBack: () => void;+ onContinue: () => void;+}++export const CreateReadOnlyComponent = ({+ database,+ onReadOnlyUserUpdated,+ onGoBack,+ onContinue,+}: Props) => {+ const [isCheckingReadOnlyUser, setIsCheckingReadOnlyUser] = useState(false);+ const [isCreatingReadOnlyUser, setIsCreatingReadOnlyUser] = useState(false);+ const [isShowSkipConfirmation, setShowSkipConfirmation] = useState(false);++ const checkReadOnlyUser = async (): Promise<boolean> => {+ try {+ const response = await databaseApi.isUserReadOnly(database);+ return response.isReadOnly;+ } catch (e) {+ alert((e as Error).message);+ return false;+ }+ };++ const createReadOnlyUser = async () => {+ setIsCreatingReadOnlyUser(true);++ try {+ const response = await databaseApi.createReadOnlyUser(database);+ database.postgresql!.username = response.username;+ database.postgresql!.password = response.password;+ onReadOnlyUserUpdated(database);+ onContinue();+ } catch (e) {+ alert((e as Error).message);+ }++ setIsCreatingReadOnlyUser(false);+ };++ const handleSkip = () => {+ setShowSkipConfirmation(true);+ };++ const handleSkipConfirmed = () => {+ setShowSkipConfirmation(false);+ onContinue();+ };++ useEffect(() => {+ const run = async () => {+ setIsCheckingReadOnlyUser(true);++ const isReadOnly = await checkReadOnlyUser();+ if (isReadOnly) {+ // already has a read-only user+ onContinue();+ }++ setIsCheckingReadOnlyUser(false);+ };+ run();+ }, []);++ if (isCheckingReadOnlyUser) {+ return (+ <div className="flex items-center">+ <Spin />+ <span className="ml-3">Checking read-only user...</span>+ </div>+ );+ }++ return (+ <div>+ <div className="mb-5">+ <p className="mb-3 text-lg font-bold">Create a read-only user for Postgresus?</p>++ <p className="mb-2">+ A read-only user is a PostgreSQL user with limited permissions that can only read data+ from your database, not modify it. This is recommended for backup operations because:+ </p>++ <ul className="mb-2 ml-5 list-disc">+ <li>it prevents accidental data modifications during backup</li>+ <li>it follows the principle of least privilege</li>+ <li>it's a security best practice</li>+ </ul>++ <p className="mb-2">+ Postgresus enforce enterprise-grade security (+ <a href="https://postgresus.com/security" target="_blank" rel="noreferrer">+ read in details here+ </a>+ ). However, it is not possible to be covered from all possible risks.+ </p>++ <p className="mt-3">+ <b>Read-only user allows to avoid storing credentials with write access at all</b>. Even+ in the worst case of hacking, nobody will be able to corrupt your data.+ </p>+ </div>++ <div className="mt-5 flex">+ <Button className="mr-auto" type="primary" ghost onClick={() => onGoBack()}>+ Back+ </Button>++ <Button className="mr-2 ml-auto" danger ghost onClick={handleSkip}>+ Skip+ </Button>++ <Button+ type="primary"+ onClick={createReadOnlyUser}+ loading={isCreatingReadOnlyUser}+ disabled={isCreatingReadOnlyUser}+ >+ Yes, create read-only user+ </Button>+ </div>++ <Modal+ title="Skip read-only user creation?"+ open={isShowSkipConfirmation}+ onCancel={() => setShowSkipConfirmation(false)}+ footer={null}+ width={450}+ >+ <div className="mb-5">+ <p className="mb-2">Are you sure you want to skip creating a read-only user?</p>++ <p className="mb-2">+ Using a user with full permissions for backups is not recommended and may pose security+ risks. Postgresus is highly recommending you to not skip this step.+ </p>++ <p>+ 100% protection is never possible. It's better to be safe in case of 0.01% risk of+ full hacking. So it is better to follow the secure way with read-only user.+ </p>+ </div>++ <div className="flex justify-end">+ <Button className="mr-2" danger onClick={handleSkipConfirmed}>+ Yes, I accept risks+ </Button>++ <Button type="primary" onClick={() => setShowSkipConfirmation(false)}>+ Let's continue with the secure way+ </Button>+ </div>+ </Modal>+ </div>+ );+};diff --git a/frontend/src/features/databases/ui/edit/EditDatabaseHealthcheckConfigComponent.tsx b/frontend/src/features/databases/ui/edit/EditDatabaseHealthcheckConfigComponent.tsxdeleted file mode 100644index e69de29b..00000000diff --git a/frontend/src/features/restores/ui/RestoresComponent.tsx b/frontend/src/features/restores/ui/RestoresComponent.tsxindex 7cc75c79..1f182ab1 100644--- a/frontend/src/features/restores/ui/RestoresComponent.tsx+++ b/frontend/src/features/restores/ui/RestoresComponent.tsx@@ -1,6 +1,6 @@-import { ExclamationCircleOutlined, SyncOutlined } from '@ant-design/icons';+import { CopyOutlined, ExclamationCircleOutlined, SyncOutlined } from '@ant-design/icons';import { CheckCircleOutlined } from '@ant-design/icons';-import { Button, Modal, Spin, Tooltip } from 'antd';+import { App, Button, Modal, Spin, Tooltip } from 'antd';import dayjs from 'dayjs';import { useEffect, useRef, useState } from 'react';@@ -16,11 +16,14 @@ interface Props {}export const RestoresComponent = ({ database, backup }: Props) => {+ const { message } = App.useApp();+const [editingDatabase, setEditingDatabase] = useState<Database>({...database,postgresql: database.postgresql? ({...database.postgresql,+ username: undefined,host: undefined,port: undefined,password: undefined,@@ -231,9 +234,21 @@ export const RestoresComponent = ({ database, backup }: Props) => {title="Restore error details"open={!!showingRestoreError}onCancel={() => setShowingRestoreError(undefined)}- footer={null}+ footer={+ <Button+ icon={<CopyOutlined />}+ onClick={() => {+ navigator.clipboard.writeText(showingRestoreError.failMessage || '');+ message.success('Error message copied to clipboard');+ }}+ >+ Copy+ </Button>+ }>- <div className="text-sm">{showingRestoreError.failMessage}</div>+ <div className="overflow-y-auto text-sm whitespace-pre-wrap" style={{ height: '400px' }}>+ {showingRestoreError.failMessage}+ </div></Modal>)}</div>