PostgreSQL backup tool with Point-In-Time-Recovery and restore verification
TypeScript backupbackupsdatabasedatabase-backupdevopsdockergolangkubernetesmariadbmongodbmysqlpgpostgrespostgresqls3self-hostedsystem-administrationtoolsweb-ui
FEATURE (encryption): Add backups encryption
Rostislav Duginb4b514c2d5a1
diff --git a/README.md b/README.mdindex d078c4d7..475ff1b1 100644--- a/README.md+++ b/README.md@@ -40,13 +40,13 @@- **Precise timing**: run backups at specific times (e.g., 4 AM during low traffic)- **Smart compression**: 4-8x space savings with balanced compression (~20% overhead)-### ποΈ **Multiple Storage Destinations** <a href="https://postgresus.com/storages">(docs)</a>+### ποΈ **Multiple Storage Destinations** <a href="https://postgresus.com/storages">(view supported)</a>- **Local storage**: Keep backups on your VPS/server- **Cloud storage**: S3, Cloudflare R2, Google Drive, NAS, Dropbox and more- **Secure**: All data stays under your control-### π± **Smart Notifications** <a href="https://postgresus.com/notifiers">(docs)</a>+### π± **Smart Notifications** <a href="https://postgresus.com/notifiers">(view supported)</a>- **Multiple channels**: Email, Telegram, Slack, Discord, webhooks- **Real-time updates**: Success and failure notifications@@ -58,6 +58,13 @@- **SSL support**: Secure connections available- **Easy restoration**: One-click restore from any backup+### π **Backup Encryption** <a href="https://postgresus.com/encryption">(docs)</a>++- **AES-256-GCM encryption**: Enterprise-grade protection for backup files+- **Zero-trust storage**: Encrypted backups are useless so you can keep in shared storages like S3, Azure Blob Storage, etc.+- **Optionality**: Encrypted backups are optional and can be enabled or disabled if you wish+- **Download unencrypted**: You can still download unencrypted backups via the 'Download' button to use them in `pg_restore` or other tools.+### π₯ **Suitable for Teams** <a href="https://postgresus.com/access-management">(docs)</a>- **Workspaces**: Group databases, notifiers and storages for different projects or teamsdiff --git a/backend/internal/features/backups/backups/controller_test.go b/backend/internal/features/backups/backups/controller_test.goindex db49b297..a4771e17 100644--- a/backend/internal/features/backups/backups/controller_test.go+++ b/backend/internal/features/backups/backups/controller_test.go@@ -524,7 +524,7 @@ func Test_CancelBackup_InProgressBackup_SuccessfullyCancelled(t *testing.T) {assert.NoError(t, err)// Register a cancellable context for the backup- GetBackupService().backupContextMgr.RegisterBackup(backup.ID, func() {})+ GetBackupService().backupContextManager.RegisterBackup(backup.ID, func() {})resp := test_utils.MakePostRequest(t,diff --git a/backend/internal/features/backups/backups/di.go b/backend/internal/features/backups/backups/di.goindex f3a0c80f..388b957f 100644--- a/backend/internal/features/backups/backups/di.go+++ b/backend/internal/features/backups/backups/di.go@@ -7,6 +7,7 @@ import ("postgresus-backend/internal/features/databases""postgresus-backend/internal/features/notifiers""postgresus-backend/internal/features/storages"+ users_repositories "postgresus-backend/internal/features/users/repositories"workspaces_services "postgresus-backend/internal/features/workspaces/services""postgresus-backend/internal/util/logger""time"@@ -23,6 +24,7 @@ var backupService = &BackupService{notifiers.GetNotifierService(),notifiers.GetNotifierService(),backups_config.GetBackupConfigService(),+ users_repositories.GetSecretKeyRepository(),usecases.GetCreateBackupUsecase(),logger.GetLogger(),[]BackupRemoveListener{},diff --git a/backend/internal/features/backups/backups/dto.go b/backend/internal/features/backups/backups/dto.goindex 92d5c029..073942c5 100644--- a/backend/internal/features/backups/backups/dto.go+++ b/backend/internal/features/backups/backups/dto.go@@ -1,5 +1,10 @@package backups+import (+ "io"+ "postgresus-backend/internal/features/backups/backups/encryption"+)+type GetBackupsRequest struct {DatabaseID string `form:"database_id" binding:"required"`Limit int `form:"limit"`@@ -12,3 +17,12 @@ type GetBackupsResponse struct {Limit int `json:"limit"`Offset int `json:"offset"`}++type decryptionReaderCloser struct {+ *encryption.DecryptionReader+ baseReader io.ReadCloser+}++func (r *decryptionReaderCloser) Close() error {+ return r.baseReader.Close()+}diff --git a/backend/internal/features/backups/backups/encryption/decrypting_reader.go b/backend/internal/features/backups/backups/encryption/decrypting_reader.gonew file mode 100644index 00000000..1b9b7666--- /dev/null+++ b/backend/internal/features/backups/backups/encryption/decrypting_reader.go@@ -0,0 +1,156 @@+package encryption++import (+ "crypto/aes"+ "crypto/cipher"+ "encoding/binary"+ "fmt"+ "io"++ "github.com/google/uuid"+)++type DecryptionReader struct {+ baseReader io.Reader+ cipher cipher.AEAD+ buffer []byte+ nonce []byte+ chunkIndex uint64+ headerRead bool+ eof bool+}++func NewDecryptionReader(+ baseReader io.Reader,+ masterKey string,+ backupID uuid.UUID,+ salt []byte,+ nonce []byte,+) (*DecryptionReader, error) {+ if len(salt) != SaltLen {+ return nil, fmt.Errorf("salt must be %d bytes, got %d", SaltLen, len(salt))+ }+ if len(nonce) != NonceLen {+ return nil, fmt.Errorf("nonce must be %d bytes, got %d", NonceLen, len(nonce))+ }++ derivedKey, err := DeriveBackupKey(masterKey, backupID, salt)+ if err != nil {+ return nil, fmt.Errorf("failed to derive backup key: %w", err)+ }++ block, err := aes.NewCipher(derivedKey)+ if err != nil {+ return nil, fmt.Errorf("failed to create cipher: %w", err)+ }++ aesgcm, err := cipher.NewGCM(block)+ if err != nil {+ return nil, fmt.Errorf("failed to create GCM: %w", err)+ }++ reader := &DecryptionReader{+ baseReader,+ aesgcm,+ make([]byte, 0),+ nonce,+ 0,+ false,+ false,+ }++ if err := reader.readAndValidateHeader(salt, nonce); err != nil {+ return nil, err+ }++ return reader, nil+}++func (r *DecryptionReader) Read(p []byte) (n int, err error) {+ for len(r.buffer) < len(p) && !r.eof {+ if err := r.readAndDecryptChunk(); err != nil {+ if err == io.EOF {+ r.eof = true+ break+ }+ return 0, err+ }+ }++ if len(r.buffer) == 0 {+ return 0, io.EOF+ }++ n = copy(p, r.buffer)+ r.buffer = r.buffer[n:]++ return n, nil+}++func (r *DecryptionReader) readAndValidateHeader(expectedSalt, expectedNonce []byte) error {+ header := make([]byte, HeaderLen)++ if _, err := io.ReadFull(r.baseReader, header); err != nil {+ return fmt.Errorf("failed to read header: %w", err)+ }++ magic := string(header[0:MagicBytesLen])+ if magic != MagicBytes {+ return fmt.Errorf("invalid magic bytes: expected %s, got %s", MagicBytes, magic)+ }++ salt := header[MagicBytesLen : MagicBytesLen+SaltLen]+ nonce := header[MagicBytesLen+SaltLen : MagicBytesLen+SaltLen+NonceLen]++ if string(salt) != string(expectedSalt) {+ return fmt.Errorf("salt mismatch in file header")+ }++ if string(nonce) != string(expectedNonce) {+ return fmt.Errorf("nonce mismatch in file header")+ }++ r.headerRead = true+ return nil+}++func (r *DecryptionReader) readAndDecryptChunk() error {+ lengthBuf := make([]byte, 4)+ if _, err := io.ReadFull(r.baseReader, lengthBuf); err != nil {+ return err+ }++ chunkLen := binary.BigEndian.Uint32(lengthBuf)+ if chunkLen == 0 || chunkLen > ChunkSize+16 {+ return fmt.Errorf("invalid chunk length: %d", chunkLen)+ }++ encrypted := make([]byte, chunkLen)+ if _, err := io.ReadFull(r.baseReader, encrypted); err != nil {+ return fmt.Errorf("failed to read encrypted chunk: %w", err)+ }++ chunkNonce := r.generateChunkNonce()++ decrypted, err := r.cipher.Open(nil, chunkNonce, encrypted, nil)+ if err != nil {+ return fmt.Errorf(+ "failed to decrypt chunk (authentication failed - file may be corrupted or tampered): %w",+ err,+ )+ }++ r.buffer = append(r.buffer, decrypted...)+ r.chunkIndex++++ return nil+}++func (r *DecryptionReader) generateChunkNonce() []byte {+ chunkNonce := make([]byte, NonceLen)+ copy(chunkNonce, r.nonce)++ binary.BigEndian.PutUint64(chunkNonce[4:], r.chunkIndex)++ return chunkNonce+}diff --git a/backend/internal/features/backups/backups/encryption/encrypting_writer.go b/backend/internal/features/backups/backups/encryption/encrypting_writer.gonew file mode 100644index 00000000..37df19a3--- /dev/null+++ b/backend/internal/features/backups/backups/encryption/encrypting_writer.go@@ -0,0 +1,147 @@+package encryption++import (+ "crypto/aes"+ "crypto/cipher"+ "encoding/binary"+ "fmt"+ "io"++ "github.com/google/uuid"+)++type EncryptionWriter struct {+ baseWriter io.Writer+ cipher cipher.AEAD+ buffer []byte+ nonce []byte+ salt []byte+ chunkIndex uint64+ headerWritten bool+}++func NewEncryptionWriter(+ baseWriter io.Writer,+ masterKey string,+ backupID uuid.UUID,+ salt []byte,+ nonce []byte,+) (*EncryptionWriter, error) {+ if len(salt) != SaltLen {+ return nil, fmt.Errorf("salt must be %d bytes, got %d", SaltLen, len(salt))+ }+ if len(nonce) != NonceLen {+ return nil, fmt.Errorf("nonce must be %d bytes, got %d", NonceLen, len(nonce))+ }++ derivedKey, err := DeriveBackupKey(masterKey, backupID, salt)+ if err != nil {+ return nil, fmt.Errorf("failed to derive backup key: %w", err)+ }++ block, err := aes.NewCipher(derivedKey)+ if err != nil {+ return nil, fmt.Errorf("failed to create cipher: %w", err)+ }++ aesgcm, err := cipher.NewGCM(block)+ if err != nil {+ return nil, fmt.Errorf("failed to create GCM: %w", err)+ }++ writer := &EncryptionWriter{+ baseWriter: baseWriter,+ cipher: aesgcm,+ buffer: make([]byte, 0, ChunkSize),+ nonce: nonce,+ chunkIndex: 0,+ headerWritten: false,+ salt: salt, // Store salt for lazy header writing+ }++ return writer, nil+}++func (w *EncryptionWriter) Write(p []byte) (n int, err error) {+ // Write header on first write (lazy initialization)+ if !w.headerWritten {+ if err := w.writeHeader(w.salt, w.nonce); err != nil {+ return 0, fmt.Errorf("failed to write header: %w", err)+ }+ }++ n = len(p)+ w.buffer = append(w.buffer, p...)++ for len(w.buffer) >= ChunkSize {+ chunk := w.buffer[:ChunkSize]+ if err := w.encryptAndWriteChunk(chunk); err != nil {+ return 0, err+ }+ w.buffer = w.buffer[ChunkSize:]+ }++ return n, nil+}++func (w *EncryptionWriter) Close() error {+ // Write header if it hasn't been written yet (in case Close is called without any writes)+ if !w.headerWritten {+ if err := w.writeHeader(w.salt, w.nonce); err != nil {+ return fmt.Errorf("failed to write header: %w", err)+ }+ }++ if len(w.buffer) > 0 {+ if err := w.encryptAndWriteChunk(w.buffer); err != nil {+ return err+ }+ w.buffer = nil+ }+ return nil+}++func (w *EncryptionWriter) writeHeader(salt, nonce []byte) error {+ header := make([]byte, HeaderLen)++ copy(header[0:MagicBytesLen], []byte(MagicBytes))+ copy(header[MagicBytesLen:MagicBytesLen+SaltLen], salt)+ copy(header[MagicBytesLen+SaltLen:MagicBytesLen+SaltLen+NonceLen], nonce)++ _, err := w.baseWriter.Write(header)+ if err != nil {+ return fmt.Errorf("failed to write header: %w", err)+ }++ w.headerWritten = true+ return nil+}++func (w *EncryptionWriter) encryptAndWriteChunk(chunk []byte) error {+ chunkNonce := w.generateChunkNonce()++ encrypted := w.cipher.Seal(nil, chunkNonce, chunk, nil)++ lengthBuf := make([]byte, 4)+ binary.BigEndian.PutUint32(lengthBuf, uint32(len(encrypted)))++ if _, err := w.baseWriter.Write(lengthBuf); err != nil {+ return fmt.Errorf("failed to write chunk length: %w", err)+ }++ if _, err := w.baseWriter.Write(encrypted); err != nil {+ return fmt.Errorf("failed to write encrypted chunk: %w", err)+ }++ w.chunkIndex+++ return nil+}++func (w *EncryptionWriter) generateChunkNonce() []byte {+ chunkNonce := make([]byte, NonceLen)+ copy(chunkNonce, w.nonce)++ binary.BigEndian.PutUint64(chunkNonce[4:], w.chunkIndex)++ return chunkNonce+}diff --git a/backend/internal/features/backups/backups/encryption/encryption_test.go b/backend/internal/features/backups/backups/encryption/encryption_test.gonew file mode 100644index 00000000..72be948c--- /dev/null+++ b/backend/internal/features/backups/backups/encryption/encryption_test.go@@ -0,0 +1,387 @@+package encryption++import (+ "bytes"+ "crypto/rand"+ "io"+ "testing"++ "github.com/google/uuid"+ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"+)++func Test_EncryptDecryptRoundTrip_ReturnsOriginalData(t *testing.T) {+ masterKey := uuid.New().String() + uuid.New().String()+ backupID := uuid.New()+ salt, err := GenerateSalt()+ require.NoError(t, err)+ nonce, err := GenerateNonce()+ require.NoError(t, err)++ originalData := []byte(+ "This is a test backup data that should be encrypted and then decrypted successfully.",+ )++ var encrypted bytes.Buffer+ writer, err := NewEncryptionWriter(&encrypted, masterKey, backupID, salt, nonce)+ require.NoError(t, err)++ n, err := writer.Write(originalData)+ require.NoError(t, err)+ assert.Equal(t, len(originalData), n)++ err = writer.Close()+ require.NoError(t, err)++ reader, err := NewDecryptionReader(&encrypted, masterKey, backupID, salt, nonce)+ require.NoError(t, err)++ decrypted := make([]byte, len(originalData))+ n, err = io.ReadFull(reader, decrypted)+ require.NoError(t, err)+ assert.Equal(t, len(originalData), n)+ assert.Equal(t, originalData, decrypted)+}++func Test_EncryptDecryptRoundTrip_LargeData_WorksCorrectly(t *testing.T) {+ masterKey := uuid.New().String() + uuid.New().String()+ backupID := uuid.New()+ salt, err := GenerateSalt()+ require.NoError(t, err)+ nonce, err := GenerateNonce()+ require.NoError(t, err)++ originalData := make([]byte, 100*1024)+ _, err = rand.Read(originalData)+ require.NoError(t, err)++ var encrypted bytes.Buffer+ writer, err := NewEncryptionWriter(&encrypted, masterKey, backupID, salt, nonce)+ require.NoError(t, err)++ n, err := writer.Write(originalData)+ require.NoError(t, err)+ assert.Equal(t, len(originalData), n)++ err = writer.Close()+ require.NoError(t, err)++ reader, err := NewDecryptionReader(&encrypted, masterKey, backupID, salt, nonce)+ require.NoError(t, err)++ decrypted, err := io.ReadAll(reader)+ require.NoError(t, err)+ assert.Equal(t, originalData, decrypted)+}++func Test_EncryptionWriter_MultipleWrites_CombinesCorrectly(t *testing.T) {+ masterKey := uuid.New().String() + uuid.New().String()+ backupID := uuid.New()+ salt, err := GenerateSalt()+ require.NoError(t, err)+ nonce, err := GenerateNonce()+ require.NoError(t, err)++ part1 := []byte("First part of data. ")+ part2 := []byte("Second part of data. ")+ part3 := []byte("Third part of data.")+ expectedData := append(append(part1, part2...), part3...)++ var encrypted bytes.Buffer+ writer, err := NewEncryptionWriter(&encrypted, masterKey, backupID, salt, nonce)+ require.NoError(t, err)++ _, err = writer.Write(part1)+ require.NoError(t, err)+ _, err = writer.Write(part2)+ require.NoError(t, err)+ _, err = writer.Write(part3)+ require.NoError(t, err)++ err = writer.Close()+ require.NoError(t, err)++ reader, err := NewDecryptionReader(&encrypted, masterKey, backupID, salt, nonce)+ require.NoError(t, err)++ decrypted, err := io.ReadAll(reader)+ require.NoError(t, err)+ assert.Equal(t, expectedData, decrypted)+}++func Test_DecryptionReader_InvalidHeader_ReturnsError(t *testing.T) {+ masterKey := uuid.New().String() + uuid.New().String()+ backupID := uuid.New()+ salt, err := GenerateSalt()+ require.NoError(t, err)+ nonce, err := GenerateNonce()+ require.NoError(t, err)++ invalidHeader := make([]byte, HeaderLen)+ copy(invalidHeader, []byte("INVALID!"))++ invalidData := bytes.NewBuffer(invalidHeader)++ _, err = NewDecryptionReader(invalidData, masterKey, backupID, salt, nonce)+ assert.Error(t, err)+ assert.Contains(t, err.Error(), "invalid magic bytes")+}++func Test_DecryptionReader_TamperedData_ReturnsError(t *testing.T) {+ masterKey := uuid.New().String() + uuid.New().String()+ backupID := uuid.New()+ salt, err := GenerateSalt()+ require.NoError(t, err)+ nonce, err := GenerateNonce()+ require.NoError(t, err)++ originalData := []byte("This data will be tampered with.")++ var encrypted bytes.Buffer+ writer, err := NewEncryptionWriter(&encrypted, masterKey, backupID, salt, nonce)+ require.NoError(t, err)++ _, err = writer.Write(originalData)+ require.NoError(t, err)++ err = writer.Close()+ require.NoError(t, err)++ encryptedBytes := encrypted.Bytes()+ if len(encryptedBytes) > HeaderLen+10 {+ encryptedBytes[HeaderLen+10] ^= 0xFF+ }++ tamperedBuffer := bytes.NewBuffer(encryptedBytes)++ reader, err := NewDecryptionReader(tamperedBuffer, masterKey, backupID, salt, nonce)+ require.NoError(t, err)++ _, err = io.ReadAll(reader)+ assert.Error(t, err)+ assert.Contains(t, err.Error(), "authentication failed")+}++func Test_DeriveBackupKey_SameInputs_ReturnsSameKey(t *testing.T) {+ masterKey := uuid.New().String() + uuid.New().String()+ backupID := uuid.New()+ salt, err := GenerateSalt()+ require.NoError(t, err)++ key1, err := DeriveBackupKey(masterKey, backupID, salt)+ require.NoError(t, err)++ key2, err := DeriveBackupKey(masterKey, backupID, salt)+ require.NoError(t, err)++ assert.Equal(t, key1, key2)+}++func Test_DeriveBackupKey_DifferentInputs_ReturnsDifferentKeys(t *testing.T) {+ masterKey1 := uuid.New().String() + uuid.New().String()+ masterKey2 := uuid.New().String() + uuid.New().String()+ backupID1 := uuid.New()+ backupID2 := uuid.New()+ salt1, err := GenerateSalt()+ require.NoError(t, err)+ salt2, err := GenerateSalt()+ require.NoError(t, err)++ key1, err := DeriveBackupKey(masterKey1, backupID1, salt1)+ require.NoError(t, err)++ key2, err := DeriveBackupKey(masterKey2, backupID1, salt1)+ require.NoError(t, err)+ assert.NotEqual(t, key1, key2)++ key3, err := DeriveBackupKey(masterKey1, backupID2, salt1)+ require.NoError(t, err)+ assert.NotEqual(t, key1, key3)++ key4, err := DeriveBackupKey(masterKey1, backupID1, salt2)+ require.NoError(t, err)+ assert.NotEqual(t, key1, key4)+}++func Test_EncryptionWriter_PartialChunk_HandledCorrectly(t *testing.T) {+ masterKey := uuid.New().String() + uuid.New().String()+ backupID := uuid.New()+ salt, err := GenerateSalt()+ require.NoError(t, err)+ nonce, err := GenerateNonce()+ require.NoError(t, err)++ smallData := []byte("Small data less than chunk size")++ var encrypted bytes.Buffer+ writer, err := NewEncryptionWriter(&encrypted, masterKey, backupID, salt, nonce)+ require.NoError(t, err)++ _, err = writer.Write(smallData)+ require.NoError(t, err)++ err = writer.Close()+ require.NoError(t, err)++ reader, err := NewDecryptionReader(&encrypted, masterKey, backupID, salt, nonce)+ require.NoError(t, err)++ decrypted, err := io.ReadAll(reader)+ require.NoError(t, err)+ assert.Equal(t, smallData, decrypted)+}++func Test_GenerateSalt_ReturnsCorrectLength(t *testing.T) {+ salt, err := GenerateSalt()+ require.NoError(t, err)+ assert.Equal(t, SaltLen, len(salt))+}++func Test_GenerateSalt_GeneratesUniqueSalts(t *testing.T) {+ salt1, err := GenerateSalt()+ require.NoError(t, err)++ salt2, err := GenerateSalt()+ require.NoError(t, err)++ assert.NotEqual(t, salt1, salt2)+}++func Test_GenerateNonce_ReturnsCorrectLength(t *testing.T) {+ nonce, err := GenerateNonce()+ require.NoError(t, err)+ assert.Equal(t, NonceLen, len(nonce))+}++func Test_GenerateNonce_GeneratesUniqueNonces(t *testing.T) {+ nonce1, err := GenerateNonce()+ require.NoError(t, err)++ nonce2, err := GenerateNonce()+ require.NoError(t, err)++ assert.NotEqual(t, nonce1, nonce2)+}++func Test_DecryptionReader_WrongMasterKey_ReturnsError(t *testing.T) {+ masterKey1 := uuid.New().String() + uuid.New().String()+ masterKey2 := uuid.New().String() + uuid.New().String()+ backupID := uuid.New()+ salt, err := GenerateSalt()+ require.NoError(t, err)+ nonce, err := GenerateNonce()+ require.NoError(t, err)++ originalData := []byte("Secret data")++ var encrypted bytes.Buffer+ writer, err := NewEncryptionWriter(&encrypted, masterKey1, backupID, salt, nonce)+ require.NoError(t, err)++ _, err = writer.Write(originalData)+ require.NoError(t, err)++ err = writer.Close()+ require.NoError(t, err)++ reader, err := NewDecryptionReader(&encrypted, masterKey2, backupID, salt, nonce)+ require.NoError(t, err)++ _, err = io.ReadAll(reader)+ assert.Error(t, err)+ assert.Contains(t, err.Error(), "authentication failed")+}++func Test_EncryptionWriter_EmptyData_WorksCorrectly(t *testing.T) {+ masterKey := uuid.New().String() + uuid.New().String()+ backupID := uuid.New()+ salt, err := GenerateSalt()+ require.NoError(t, err)+ nonce, err := GenerateNonce()+ require.NoError(t, err)++ var encrypted bytes.Buffer+ writer, err := NewEncryptionWriter(&encrypted, masterKey, backupID, salt, nonce)+ require.NoError(t, err)++ err = writer.Close()+ require.NoError(t, err)++ reader, err := NewDecryptionReader(&encrypted, masterKey, backupID, salt, nonce)+ require.NoError(t, err)++ decrypted, err := io.ReadAll(reader)+ require.NoError(t, err)+ assert.Equal(t, 0, len(decrypted))+}++func Test_EncryptionWriter_MultipleChunks_WorksCorrectly(t *testing.T) {+ masterKey := uuid.New().String() + uuid.New().String()+ backupID := uuid.New()+ salt, err := GenerateSalt()+ require.NoError(t, err)+ nonce, err := GenerateNonce()+ require.NoError(t, err)++ dataSize := ChunkSize*3 + 1000+ originalData := make([]byte, dataSize)+ _, err = rand.Read(originalData)+ require.NoError(t, err)++ var encrypted bytes.Buffer+ writer, err := NewEncryptionWriter(&encrypted, masterKey, backupID, salt, nonce)+ require.NoError(t, err)++ _, err = writer.Write(originalData)+ require.NoError(t, err)++ err = writer.Close()+ require.NoError(t, err)++ reader, err := NewDecryptionReader(&encrypted, masterKey, backupID, salt, nonce)+ require.NoError(t, err)++ decrypted, err := io.ReadAll(reader)+ require.NoError(t, err)+ assert.Equal(t, originalData, decrypted)+}++func Test_DecryptionReader_SmallReads_WorksCorrectly(t *testing.T) {+ masterKey := uuid.New().String() + uuid.New().String()+ backupID := uuid.New()+ salt, err := GenerateSalt()+ require.NoError(t, err)+ nonce, err := GenerateNonce()+ require.NoError(t, err)++ originalData := []byte("This is test data that will be read in small chunks.")++ var encrypted bytes.Buffer+ writer, err := NewEncryptionWriter(&encrypted, masterKey, backupID, salt, nonce)+ require.NoError(t, err)++ _, err = writer.Write(originalData)+ require.NoError(t, err)++ err = writer.Close()+ require.NoError(t, err)++ reader, err := NewDecryptionReader(&encrypted, masterKey, backupID, salt, nonce)+ require.NoError(t, err)++ var decrypted []byte+ buf := make([]byte, 5)+ for {+ n, err := reader.Read(buf)+ if n > 0 {+ decrypted = append(decrypted, buf[:n]...)+ }+ if err == io.EOF {+ break+ }+ require.NoError(t, err)+ }++ assert.Equal(t, originalData, decrypted)+}diff --git a/backend/internal/features/backups/backups/encryption/utils.go b/backend/internal/features/backups/backups/encryption/utils.gonew file mode 100644index 00000000..64df3cad--- /dev/null+++ b/backend/internal/features/backups/backups/encryption/utils.go@@ -0,0 +1,52 @@+package encryption++import (+ "crypto/rand"+ "crypto/sha256"+ "fmt"++ "github.com/google/uuid"+ "golang.org/x/crypto/pbkdf2"+)++const (+ MagicBytes = "PGRSUS01"+ MagicBytesLen = 8+ SaltLen = 32+ NonceLen = 12+ ReservedLen = 12+ HeaderLen = MagicBytesLen + SaltLen + NonceLen + ReservedLen+ ChunkSize = 32 * 1024+ PBKDF2Iterations = 100000+)++func DeriveBackupKey(masterKey string, backupID uuid.UUID, salt []byte) ([]byte, error) {+ if masterKey == "" {+ return nil, fmt.Errorf("master key cannot be empty")+ }+ if len(salt) != SaltLen {+ return nil, fmt.Errorf("salt must be %d bytes", SaltLen)+ }++ keyMaterial := []byte(masterKey + backupID.String())++ derivedKey := pbkdf2.Key(keyMaterial, salt, PBKDF2Iterations, 32, sha256.New)++ return derivedKey, nil+}++func GenerateSalt() ([]byte, error) {+ salt := make([]byte, SaltLen)+ if _, err := rand.Read(salt); err != nil {+ return nil, fmt.Errorf("failed to generate salt: %w", err)+ }+ return salt, nil+}++func GenerateNonce() ([]byte, error) {+ nonce := make([]byte, NonceLen)+ if _, err := rand.Read(nonce); err != nil {+ return nil, fmt.Errorf("failed to generate nonce: %w", err)+ }+ return nonce, nil+}diff --git a/backend/internal/features/backups/backups/interfaces.go b/backend/internal/features/backups/backups/interfaces.goindex 072177b5..93b92c57 100644--- a/backend/internal/features/backups/backups/interfaces.go+++ b/backend/internal/features/backups/backups/interfaces.go@@ -3,6 +3,7 @@ package backupsimport ("context"+ usecases_postgresql "postgresus-backend/internal/features/backups/backups/usecases/postgresql"backups_config "postgresus-backend/internal/features/backups/config""postgresus-backend/internal/features/databases""postgresus-backend/internal/features/notifiers"@@ -29,7 +30,7 @@ type CreateBackupUsecase interface {backupProgressListener func(completedMBs float64,),- ) error+ ) (*usecases_postgresql.BackupMetadata, error)}type BackupRemoveListener interface {diff --git a/backend/internal/features/backups/backups/model.go b/backend/internal/features/backups/backups/model.goindex b7e68e28..1289b3e1 100644--- a/backend/internal/features/backups/backups/model.go+++ b/backend/internal/features/backups/backups/model.go@@ -1,6 +1,7 @@package backupsimport (+ backups_config "postgresus-backend/internal/features/backups/config""time""github.com/google/uuid"@@ -19,5 +20,9 @@ type Backup struct {BackupDurationMs int64 `json:"backupDurationMs" gorm:"column:backup_duration_ms;default:0"`+ EncryptionSalt *string `json:"-" gorm:"column:encryption_salt"`+ EncryptionIV *string `json:"-" gorm:"column:encryption_iv"`+ Encryption backups_config.BackupEncryption `json:"encryption" gorm:"column:encryption;type:text;not null;default:'NONE'"`+CreatedAt time.Time `json:"createdAt" gorm:"column:created_at"`}diff --git a/backend/internal/features/backups/backups/service.go b/backend/internal/features/backups/backups/service.goindex 29d7318b..20aec093 100644--- a/backend/internal/features/backups/backups/service.go+++ b/backend/internal/features/backups/backups/service.go@@ -2,16 +2,19 @@ package backupsimport ("context"+ "encoding/base64""errors""fmt""io""log/slog"audit_logs "postgresus-backend/internal/features/audit_logs"+ "postgresus-backend/internal/features/backups/backups/encryption"backups_config "postgresus-backend/internal/features/backups/config""postgresus-backend/internal/features/databases""postgresus-backend/internal/features/notifiers""postgresus-backend/internal/features/storages"users_models "postgresus-backend/internal/features/users/models"+ users_repositories "postgresus-backend/internal/features/users/repositories"workspaces_services "postgresus-backend/internal/features/workspaces/services""slices""strings"@@ -27,6 +30,7 @@ type BackupService struct {notifierService *notifiers.NotifierServicenotificationSender NotificationSenderbackupConfigService *backups_config.BackupConfigService+ secretKeyRepo *users_repositories.SecretKeyRepositorycreateBackupUseCase CreateBackupUsecase@@ -34,9 +38,9 @@ type BackupService struct {backupRemoveListeners []BackupRemoveListener- workspaceService *workspaces_services.WorkspaceService- auditLogService *audit_logs.AuditLogService- backupContextMgr *BackupContextManager+ workspaceService *workspaces_services.WorkspaceService+ auditLogService *audit_logs.AuditLogService+ backupContextManager *BackupContextManager}func (s *BackupService) AddBackupRemoveListener(listener BackupRemoveListener) {@@ -253,10 +257,10 @@ func (s *BackupService) MakeBackup(databaseID uuid.UUID, isLastTry bool) {}ctx, cancel := context.WithCancel(context.Background())- s.backupContextMgr.RegisterBackup(backup.ID, cancel)- defer s.backupContextMgr.UnregisterBackup(backup.ID)+ s.backupContextManager.RegisterBackup(backup.ID, cancel)+ defer s.backupContextManager.UnregisterBackup(backup.ID)- err = s.createBackupUseCase.Execute(+ backupMetadata, err := s.createBackupUseCase.Execute(ctx,backup.ID,backupConfig,@@ -326,6 +330,13 @@ func (s *BackupService) MakeBackup(databaseID uuid.UUID, isLastTry bool) {backup.Status = BackupStatusCompletedbackup.BackupDurationMs = time.Since(start).Milliseconds()+ // Update backup with encryption metadata if provided+ if backupMetadata != nil {+ backup.EncryptionSalt = backupMetadata.EncryptionSalt+ backup.EncryptionIV = backupMetadata.EncryptionIV+ backup.Encryption = backupMetadata.Encryption+ }+if err := s.backupRepository.Save(backup); err != nil {s.logger.Error("Failed to save backup", "error", err)return@@ -463,7 +474,7 @@ func (s *BackupService) CancelBackup(return errors.New("backup is not in progress")}- if err := s.backupContextMgr.CancelBackup(backupID); err != nil {+ if err := s.backupContextManager.CancelBackup(backupID); err != nil {return err}@@ -509,11 +520,6 @@ func (s *BackupService) GetBackupFile(return nil, errors.New("insufficient permissions to download backup for this database")}- storage, err := s.storageService.GetStorageByID(backup.StorageID)- if err != nil {- return nil, err- }-s.auditLogService.WriteAuditLog(fmt.Sprintf("Backup file downloaded for database: %s (ID: %s)",@@ -524,7 +530,7 @@ func (s *BackupService) GetBackupFile(database.WorkspaceID,)- return storage.GetFile(backup.ID)+ return s.getBackupReader(backupID)}func (s *BackupService) deleteBackup(backup *Backup) error {@@ -579,3 +585,91 @@ func (s *BackupService) deleteDbBackups(databaseID uuid.UUID) error {return nil}++// GetBackupReader returns a reader for the backup file+// If encrypted, wraps with DecryptionReader+func (s *BackupService) getBackupReader(backupID uuid.UUID) (io.ReadCloser, error) {+ backup, err := s.backupRepository.FindByID(backupID)+ if err != nil {+ return nil, fmt.Errorf("failed to find backup: %w", err)+ }++ storage, err := s.storageService.GetStorageByID(backup.StorageID)+ if err != nil {+ return nil, fmt.Errorf("failed to get storage: %w", err)+ }++ fileReader, err := storage.GetFile(backup.ID)+ if err != nil {+ return nil, fmt.Errorf("failed to get backup file: %w", err)+ }++ // If not encrypted, return raw reader+ if backup.Encryption == backups_config.BackupEncryptionNone {+ s.logger.Info("Returning non-encrypted backup", "backupId", backupID)+ return fileReader, nil+ }++ // Decrypt on-the-fly for encrypted backups+ if backup.Encryption != backups_config.BackupEncryptionEncrypted {+ if err := fileReader.Close(); err != nil {+ s.logger.Error("Failed to close file reader", "error", err)+ }+ return nil, fmt.Errorf("unsupported encryption type: %s", backup.Encryption)+ }++ if backup.EncryptionSalt == nil || backup.EncryptionIV == nil {+ if err := fileReader.Close(); err != nil {+ s.logger.Error("Failed to close file reader", "error", err)+ }+ return nil, fmt.Errorf("backup marked as encrypted but missing encryption metadata")+ }++ // Get master key+ masterKey, err := s.secretKeyRepo.GetSecretKey()+ if err != nil {+ if closeErr := fileReader.Close(); closeErr != nil {+ s.logger.Error("Failed to close file reader", "error", closeErr)+ }+ return nil, fmt.Errorf("failed to get master key: %w", err)+ }++ // Decode salt and IV+ salt, err := base64.StdEncoding.DecodeString(*backup.EncryptionSalt)+ if err != nil {+ if closeErr := fileReader.Close(); closeErr != nil {+ s.logger.Error("Failed to close file reader", "error", closeErr)+ }+ return nil, fmt.Errorf("failed to decode salt: %w", err)+ }++ iv, err := base64.StdEncoding.DecodeString(*backup.EncryptionIV)+ if err != nil {+ if closeErr := fileReader.Close(); closeErr != nil {+ s.logger.Error("Failed to close file reader", "error", closeErr)+ }+ return nil, fmt.Errorf("failed to decode IV: %w", err)+ }++ // Wrap with decrypting reader+ decryptionReader, err := encryption.NewDecryptionReader(+ fileReader,+ masterKey,+ backup.ID,+ salt,+ iv,+ )+ if err != nil {+ if closeErr := fileReader.Close(); closeErr != nil {+ s.logger.Error("Failed to close file reader", "error", closeErr)+ }+ return nil, fmt.Errorf("failed to create decrypting reader: %w", err)+ }++ s.logger.Info("Returning encrypted backup with decryption", "backupId", backupID)++ return &decryptionReaderCloser{+ decryptionReader,+ fileReader,+ }, nil+}diff --git a/backend/internal/features/backups/backups/service_test.go b/backend/internal/features/backups/backups/service_test.goindex 12df548d..851ab7a4 100644--- a/backend/internal/features/backups/backups/service_test.go+++ b/backend/internal/features/backups/backups/service_test.go@@ -3,11 +3,13 @@ package backupsimport ("context""errors"+ usecases_postgresql "postgresus-backend/internal/features/backups/backups/usecases/postgresql"backups_config "postgresus-backend/internal/features/backups/config""postgresus-backend/internal/features/databases""postgresus-backend/internal/features/notifiers""postgresus-backend/internal/features/storages"users_enums "postgresus-backend/internal/features/users/enums"+ users_repositories "postgresus-backend/internal/features/users/repositories"users_testing "postgresus-backend/internal/features/users/testing"workspaces_services "postgresus-backend/internal/features/workspaces/services"workspaces_testing "postgresus-backend/internal/features/workspaces/testing"@@ -53,6 +55,7 @@ func Test_BackupExecuted_NotificationSent(t *testing.T) {notifiers.GetNotifierService(),mockNotificationSender,backups_config.GetBackupConfigService(),+ users_repositories.GetSecretKeyRepository(),&CreateFailedBackupUsecase{},logger.GetLogger(),[]BackupRemoveListener{},@@ -99,6 +102,7 @@ func Test_BackupExecuted_NotificationSent(t *testing.T) {notifiers.GetNotifierService(),mockNotificationSender,backups_config.GetBackupConfigService(),+ users_repositories.GetSecretKeyRepository(),&CreateSuccessBackupUsecase{},logger.GetLogger(),[]BackupRemoveListener{},@@ -122,6 +126,7 @@ func Test_BackupExecuted_NotificationSent(t *testing.T) {notifiers.GetNotifierService(),mockNotificationSender,backups_config.GetBackupConfigService(),+ users_repositories.GetSecretKeyRepository(),&CreateSuccessBackupUsecase{},logger.GetLogger(),[]BackupRemoveListener{},@@ -171,9 +176,9 @@ func (uc *CreateFailedBackupUsecase) Execute(backupProgressListener func(completedMBs float64,),-) error {+) (*usecases_postgresql.BackupMetadata, error) {backupProgressListener(10) // Assume we completed 10MB- return errors.New("backup failed")+ return nil, errors.New("backup failed")}type CreateSuccessBackupUsecase struct {@@ -188,7 +193,11 @@ func (uc *CreateSuccessBackupUsecase) Execute(backupProgressListener func(completedMBs float64,),-) error {+) (*usecases_postgresql.BackupMetadata, error) {backupProgressListener(10) // Assume we completed 10MB- return nil+ return &usecases_postgresql.BackupMetadata{+ EncryptionSalt: nil,+ EncryptionIV: nil,+ Encryption: backups_config.BackupEncryptionNone,+ }, nil}diff --git a/backend/internal/features/backups/backups/usecases/create_backup_uc.go b/backend/internal/features/backups/backups/usecases/create_backup_uc.goindex 61968f1f..00101652 100644--- a/backend/internal/features/backups/backups/usecases/create_backup_uc.go+++ b/backend/internal/features/backups/backups/usecases/create_backup_uc.go@@ -15,7 +15,7 @@ type CreateBackupUsecase struct {CreatePostgresqlBackupUsecase *usecases_postgresql.CreatePostgresqlBackupUsecase}-// Execute creates a backup of the database and returns the backup size in MB+// Execute creates a backup of the database and returns the backup metadatafunc (uc *CreateBackupUsecase) Execute(ctx context.Context,backupID uuid.UUID,@@ -25,7 +25,7 @@ func (uc *CreateBackupUsecase) Execute(backupProgressListener func(completedMBs float64,),-) error {+) (*usecases_postgresql.BackupMetadata, error) {if database.Type == databases.DatabaseTypePostgres {return uc.CreatePostgresqlBackupUsecase.Execute(ctx,@@ -37,5 +37,5 @@ func (uc *CreateBackupUsecase) Execute()}- return errors.New("database type not supported")+ return nil, errors.New("database type not supported")}diff --git a/backend/internal/features/backups/backups/usecases/postgresql/create_backup_uc.go b/backend/internal/features/backups/backups/usecases/postgresql/create_backup_uc.goindex cb1e1f71..42b84336 100644--- a/backend/internal/features/backups/backups/usecases/postgresql/create_backup_uc.go+++ b/backend/internal/features/backups/backups/usecases/postgresql/create_backup_uc.go@@ -2,6 +2,7 @@ package usecases_postgresqlimport ("context"+ "encoding/base64""errors""fmt""io"@@ -14,17 +15,33 @@ import ("time""postgresus-backend/internal/config"+ "postgresus-backend/internal/features/backups/backups/encryption"backups_config "postgresus-backend/internal/features/backups/config""postgresus-backend/internal/features/databases"pgtypes "postgresus-backend/internal/features/databases/databases/postgresql""postgresus-backend/internal/features/storages"+ users_repositories "postgresus-backend/internal/features/users/repositories""postgresus-backend/internal/util/tools""github.com/google/uuid")+const (+ backupTimeout = 23 * time.Hour+ shutdownCheckInterval = 1 * time.Second+ copyBufferSize = 32 * 1024+ progressReportIntervalMB = 1.0+ pgConnectTimeout = 30+ compressionLevel = 5+ defaultBackupLimit = 1000+ exitCodeAccessViolation = -1073741819+ exitCodeGenericError = 1+ exitCodeConnectionError = 2+)+type CreatePostgresqlBackupUsecase struct {- logger *slog.Logger+ logger *slog.Logger+ secretKeyRepo *users_repositories.SecretKeyRepository}// Execute creates a backup of the database@@ -37,7 +54,7 @@ func (uc *CreatePostgresqlBackupUsecase) Execute(backupProgressListener func(completedMBs float64,),-) error {+) (*BackupMetadata, error) {uc.logger.Info("Creating PostgreSQL backup via pg_dump custom format","databaseId",@@ -47,39 +64,20 @@ func (uc *CreatePostgresqlBackupUsecase) Execute()if !backupConfig.IsBackupsEnabled {- return fmt.Errorf("backups are not enabled for this database: \"%s\"", db.Name)+ return nil, fmt.Errorf("backups are not enabled for this database: \"%s\"", db.Name)}pg := db.Postgresqlif pg == nil {- return fmt.Errorf("postgresql database configuration is required for pg_dump backups")+ return nil, fmt.Errorf("postgresql database configuration is required for pg_dump backups")}if pg.Database == nil || *pg.Database == "" {- return fmt.Errorf("database name is required for pg_dump backups")+ return nil, fmt.Errorf("database name is required for pg_dump backups")}- args := []string{- "-Fc", // custom format with built-in compression- "--no-password", // Use environment variable for password, prevent prompts- "-h", pg.Host,- "-p", strconv.Itoa(pg.Port),- "-U", pg.Username,- "-d", *pg.Database,- "--verbose", // Add verbose output to help with debugging- }-- // Use zstd compression level 5 for PostgreSQL 16+ (better compression and speed)- // Fall back to gzip compression level 5 for older versions (12-15)- if pg.Version == tools.PostgresqlVersion12 || pg.Version == tools.PostgresqlVersion13 ||- pg.Version == tools.PostgresqlVersion14 || pg.Version == tools.PostgresqlVersion15 {- args = append(args, "-Z", "5")- uc.logger.Info("Using gzip compression level 5 (zstd not available)", "version", pg.Version)- } else {- args = append(args, "--compress=zstd:5")- uc.logger.Info("Using zstd compression level 5", "version", pg.Version)- }+ args := uc.buildPgDumpArgs(pg)return uc.streamToStorage(ctx,@@ -110,36 +108,15 @@ func (uc *CreatePostgresqlBackupUsecase) streamToStorage(storage *storages.Storage,db *databases.Database,backupProgressListener func(completedMBs float64),-) error {+) (*BackupMetadata, error) {uc.logger.Info("Streaming PostgreSQL backup to storage", "pgBin", pgBin, "args", args)- // if backup not fit into 23 hours, Postgresus- // seems not to work for such database size- ctx, cancel := context.WithTimeout(parentCtx, 23*time.Hour)+ ctx, cancel := uc.createBackupContext(parentCtx)defer cancel()- // Monitor for shutdown and cancel context if needed- go func() {- ticker := time.NewTicker(1 * time.Second)- defer ticker.Stop()-- for {- select {- case <-ctx.Done():- return- case <-ticker.C:- if config.IsShouldShutdown() {- cancel()- return- }- }- }- }()-- // Create temporary .pgpass file as a more reliable alternative to PGPASSWORD- pgpassFile, err := uc.createTempPgpassFile(db.Postgresql, password)+ pgpassFile, err := uc.setupPgpassFile(db.Postgresql, password)if err != nil {- return fmt.Errorf("failed to create temporary .pgpass file: %w", err)+ return nil, err}defer func() {if pgpassFile != "" {@@ -147,87 +124,21 @@ func (uc *CreatePostgresqlBackupUsecase) streamToStorage(}}()- // Verify .pgpass file was created successfully- if pgpassFile == "" {- return fmt.Errorf("temporary .pgpass file was not created")- }-- // Verify .pgpass file was created correctly- if info, err := os.Stat(pgpassFile); err == nil {- uc.logger.Info("Temporary .pgpass file created successfully",- "pgpassFile", pgpassFile,- "size", info.Size(),- "mode", info.Mode(),- )- } else {- return fmt.Errorf("failed to verify .pgpass file: %w", err)- }-cmd := exec.CommandContext(ctx, pgBin, args...)uc.logger.Info("Executing PostgreSQL backup command", "command", cmd.String())- // Start with system environment variables to preserve Windows PATH, SystemRoot, etc.- cmd.Env = os.Environ()-- // Use the .pgpass file for authentication- cmd.Env = append(cmd.Env, "PGPASSFILE="+pgpassFile)- uc.logger.Info("Using temporary .pgpass file for authentication", "pgpassFile", pgpassFile)-- // Debug password setup (without exposing the actual password)- uc.logger.Info("Setting up PostgreSQL environment",- "passwordLength", len(password),- "passwordEmpty", password == "",- "pgBin", pgBin,- "usingPgpassFile", true,- "parallelJobs", backupConfig.CpuCount,- )-- // Add PostgreSQL-specific environment variables- cmd.Env = append(cmd.Env, "PGCLIENTENCODING=UTF8")- cmd.Env = append(cmd.Env, "PGCONNECT_TIMEOUT=30")-- // Add encoding-related environment variables to handle character encoding issues- cmd.Env = append(cmd.Env, "LC_ALL=C.UTF-8")- cmd.Env = append(cmd.Env, "LANG=C.UTF-8")-- // Add PostgreSQL-specific encoding settings- cmd.Env = append(cmd.Env, "PGOPTIONS=--client-encoding=UTF8")-- shouldRequireSSL := db.Postgresql.IsHttps-- // Require SSL when explicitly configured- if shouldRequireSSL {- cmd.Env = append(cmd.Env, "PGSSLMODE=require")- uc.logger.Info("Using required SSL mode", "configuredHttps", db.Postgresql.IsHttps)- } else {- // SSL not explicitly required, but prefer it if available- cmd.Env = append(cmd.Env, "PGSSLMODE=prefer")- uc.logger.Info("Using preferred SSL mode", "configuredHttps", db.Postgresql.IsHttps)- }-- // Set other SSL parameters to avoid certificate issues- cmd.Env = append(cmd.Env, "PGSSLCERT=") // No client certificate- cmd.Env = append(cmd.Env, "PGSSLKEY=") // No client key- cmd.Env = append(cmd.Env, "PGSSLROOTCERT=") // No root certificate verification- cmd.Env = append(cmd.Env, "PGSSLCRL=") // No certificate revocation list-- // Verify executable exists and is accessible- if _, err := exec.LookPath(pgBin); err != nil {- return fmt.Errorf(- "PostgreSQL executable not found or not accessible: %s - %w",- pgBin,- err,- )+ if err := uc.setupPgEnvironment(cmd, pgpassFile, db.Postgresql.IsHttps, password, backupConfig.CpuCount, pgBin); err != nil {+ return nil, err}pgStdout, err := cmd.StdoutPipe()if err != nil {- return fmt.Errorf("stdout pipe: %w", err)+ return nil, fmt.Errorf("stdout pipe: %w", err)}pgStderr, err := cmd.StderrPipe()if err != nil {- return fmt.Errorf("stderr pipe: %w", err)+ return nil, fmt.Errorf("stderr pipe: %w", err)}// Capture stderr in a separate goroutine to ensure we don't miss any error output@@ -237,23 +148,31 @@ func (uc *CreatePostgresqlBackupUsecase) streamToStorage(stderrCh <- stderrOutput}()- // A pipe connecting pg_dump output β storagestorageReader, storageWriter := io.Pipe()- // Create a counting writer to track bytes- countingWriter := &CountingWriter{writer: storageWriter}+ finalWriter, encryptionWriter, backupMetadata, err := uc.setupBackupEncryption(+ backupID,+ backupConfig,+ storageWriter,+ )+ if err != nil {+ return nil, err+ }++ countingWriter := &CountingWriter{writer: finalWriter}// The backup ID becomes the object key / filename in storage// Start streaming into storage in its own goroutinesaveErrCh := make(chan error, 1)go func() {- saveErrCh <- storage.SaveFile(uc.logger, backupID, storageReader)+ saveErr := storage.SaveFile(uc.logger, backupID, storageReader)+ saveErrCh <- saveErr}()// Start pg_dumpif err = cmd.Start(); err != nil {- return fmt.Errorf("start %s: %w", filepath.Base(pgBin), err)+ return nil, fmt.Errorf("start %s: %w", filepath.Base(pgBin), err)}// Copy pg output directly to storage with shutdown checks@@ -278,26 +197,14 @@ func (uc *CreatePostgresqlBackupUsecase) streamToStorage(// Check for shutdown or cancellation before finalizingselect {case <-ctx.Done():- if pipeWriter, ok := countingWriter.writer.(*io.PipeWriter); ok {- if err := pipeWriter.Close(); err != nil {- uc.logger.Error("Failed to close counting writer", "error", err)- }- }-- <-saveErrCh // Wait for storage to finish-- if config.IsShouldShutdown() {- return fmt.Errorf("backup cancelled due to shutdown")- }- return fmt.Errorf("backup cancelled")+ uc.cleanupOnCancellation(encryptionWriter, storageWriter, saveErrCh)+ return nil, uc.checkCancellationReason()default:}- // Close the pipe writer to signal end of data- if pipeWriter, ok := countingWriter.writer.(*io.PipeWriter); ok {- if err := pipeWriter.Close(); err != nil {- uc.logger.Error("Failed to close counting writer", "error", err)- }+ if err := uc.closeWriters(encryptionWriter, storageWriter); err != nil {+ <-saveErrCh+ return nil, err}// Wait until storage ends reading@@ -312,149 +219,34 @@ func (uc *CreatePostgresqlBackupUsecase) streamToStorage(switch {case waitErr != nil:- select {- case <-ctx.Done():- if config.IsShouldShutdown() {- return fmt.Errorf("backup cancelled due to shutdown")- }- return fmt.Errorf("backup cancelled")- default:+ if err := uc.checkCancellation(ctx); err != nil {+ return nil, err}-- // Enhanced error handling for PostgreSQL connection and SSL issues- stderrStr := string(stderrOutput)- errorMsg := fmt.Sprintf(- "%s failed: %v β stderr: %s",- filepath.Base(pgBin),- waitErr,- stderrStr,- )-- // Check for specific PostgreSQL error patterns- if exitErr, ok := waitErr.(*exec.ExitError); ok {- exitCode := exitErr.ExitCode()-- // Enhanced debugging for exit status 1 with empty stderr- if exitCode == 1 && strings.TrimSpace(stderrStr) == "" {- uc.logger.Error("pg_dump failed with exit status 1 but no stderr output",- "pgBin", pgBin,- "args", args,- "env_vars", []string{- "PGCLIENTENCODING=UTF8",- "PGCONNECT_TIMEOUT=30",- "LC_ALL=C.UTF-8",- "LANG=C.UTF-8",- "PGOPTIONS=--client-encoding=UTF8",- },- )-- errorMsg = fmt.Sprintf(- "%s failed with exit status 1 but provided no error details. "+- "This often indicates: "+- "1) Connection timeout or refused connection, "+- "2) Authentication failure with incorrect credentials, "+- "3) Database does not exist, "+- "4) Network connectivity issues, "+- "5) PostgreSQL server not running. "+- "Command executed: %s %s",- filepath.Base(pgBin),- pgBin,- strings.Join(args, " "),- )- } else if exitCode == -1073741819 { // 0xC0000005 in decimal- uc.logger.Error("PostgreSQL tool crashed with access violation",- "pgBin", pgBin,- "args", args,- "exitCode", fmt.Sprintf("0x%X", uint32(exitCode)),- )-- errorMsg = fmt.Sprintf(- "%s crashed with access violation (0xC0000005). This may indicate incompatible PostgreSQL version, corrupted installation, or connection issues. stderr: %s",- filepath.Base(pgBin),- stderrStr,- )- } else if exitCode == 1 || exitCode == 2 {- // Check for common connection and authentication issues- if containsIgnoreCase(stderrStr, "pg_hba.conf") {- errorMsg = fmt.Sprintf(- "PostgreSQL connection rejected by server configuration (pg_hba.conf). The server may not allow connections from your IP address or may require different authentication settings. stderr: %s",- stderrStr,- )- } else if containsIgnoreCase(stderrStr, "no password supplied") || containsIgnoreCase(stderrStr, "fe_sendauth") {- errorMsg = fmt.Sprintf(- "PostgreSQL authentication failed - no password supplied. "+- "PGPASSWORD environment variable may not be working correctly on this system. "+- "Password length: %d, Password empty: %v. "+- "Consider using a .pgpass file as an alternative. stderr: %s",- len(password),- password == "",- stderrStr,- )- } else if containsIgnoreCase(stderrStr, "ssl") && containsIgnoreCase(stderrStr, "connection") {- errorMsg = fmt.Sprintf(- "PostgreSQL SSL connection failed. The server may require SSL encryption or have SSL configuration issues. stderr: %s",- stderrStr,- )- } else if containsIgnoreCase(stderrStr, "connection") && containsIgnoreCase(stderrStr, "refused") {- errorMsg = fmt.Sprintf(- "PostgreSQL connection refused. Check if the server is running and accessible from your network. stderr: %s",- stderrStr,- )- } else if containsIgnoreCase(stderrStr, "authentication") || containsIgnoreCase(stderrStr, "password") {- errorMsg = fmt.Sprintf(- "PostgreSQL authentication failed. Check username and password. stderr: %s",- stderrStr,- )- } else if containsIgnoreCase(stderrStr, "timeout") {- errorMsg = fmt.Sprintf(- "PostgreSQL connection timeout. The server may be unreachable or overloaded. stderr: %s",- stderrStr,- )- }- }- }-- return errors.New(errorMsg)+ return nil, uc.buildPgDumpErrorMessage(waitErr, stderrOutput, pgBin, args, password)case copyErr != nil:- select {- case <-ctx.Done():- if config.IsShouldShutdown() {- return fmt.Errorf("backup cancelled due to shutdown")- }- return fmt.Errorf("backup cancelled")- default:+ if err := uc.checkCancellation(ctx); err != nil {+ return nil, err}-- return fmt.Errorf("copy to storage: %w", copyErr)+ return nil, fmt.Errorf("copy to storage: %w", copyErr)case saveErr != nil:- select {- case <-ctx.Done():- if config.IsShouldShutdown() {- return fmt.Errorf("backup cancelled due to shutdown")- }- return fmt.Errorf("backup cancelled")- default:+ if err := uc.checkCancellation(ctx); err != nil {+ return nil, err}-- return fmt.Errorf("save to storage: %w", saveErr)+ return nil, fmt.Errorf("save to storage: %w", saveErr)}- return nil+ return &backupMetadata, nil}-// copyWithShutdownCheck copies data from src to dst while checking for shutdownfunc (uc *CreatePostgresqlBackupUsecase) copyWithShutdownCheck(ctx context.Context,dst io.Writer,src io.Reader,backupProgressListener func(completedMBs float64),) (int64, error) {- buf := make([]byte, 32*1024) // 32KB buffer+ buf := make([]byte, copyBufferSize)var totalBytesWritten int64-- // Progress reporting interval - report every 1MB of datavar lastReportedMB float64- const reportIntervalMB = 1.0for {select {@@ -487,12 +279,9 @@ func (uc *CreatePostgresqlBackupUsecase) copyWithShutdownCheck(totalBytesWritten += int64(bytesWritten)- // Report progress based on total sizeif backupProgressListener != nil {currentSizeMB := float64(totalBytesWritten) / (1024 * 1024)-- // Only report if we've written at least 1MB more data than last report- if currentSizeMB >= lastReportedMB+reportIntervalMB {+ if currentSizeMB >= lastReportedMB+progressReportIntervalMB {backupProgressListener(currentSizeMB)lastReportedMB = currentSizeMB}@@ -503,7 +292,6 @@ func (uc *CreatePostgresqlBackupUsecase) copyWithShutdownCheck(if readErr != io.EOF {return totalBytesWritten, readErr}-break}}@@ -511,12 +299,412 @@ func (uc *CreatePostgresqlBackupUsecase) copyWithShutdownCheck(return totalBytesWritten, nil}-// containsIgnoreCase checks if a string contains a substring, ignoring case-func containsIgnoreCase(str, substr string) bool {- return strings.Contains(strings.ToLower(str), strings.ToLower(substr))+func (uc *CreatePostgresqlBackupUsecase) buildPgDumpArgs(pg *pgtypes.PostgresqlDatabase) []string {+ args := []string{+ "-Fc",+ "--no-password",+ "-h", pg.Host,+ "-p", strconv.Itoa(pg.Port),+ "-U", pg.Username,+ "-d", *pg.Database,+ "--verbose",+ }++ compressionArgs := uc.getCompressionArgs(pg.Version)+ return append(args, compressionArgs...)+}++func (uc *CreatePostgresqlBackupUsecase) getCompressionArgs(+ version tools.PostgresqlVersion,+) []string {+ if uc.isOlderPostgresVersion(version) {+ uc.logger.Info("Using gzip compression level 5 (zstd not available)", "version", version)+ return []string{"-Z", strconv.Itoa(compressionLevel)}+ }++ uc.logger.Info("Using zstd compression level 5", "version", version)+ return []string{fmt.Sprintf("--compress=zstd:%d", compressionLevel)}+}++func (uc *CreatePostgresqlBackupUsecase) isOlderPostgresVersion(+ version tools.PostgresqlVersion,+) bool {+ return version == tools.PostgresqlVersion12 ||+ version == tools.PostgresqlVersion13 ||+ version == tools.PostgresqlVersion14 ||+ version == tools.PostgresqlVersion15+}++func (uc *CreatePostgresqlBackupUsecase) createBackupContext(+ parentCtx context.Context,+) (context.Context, context.CancelFunc) {+ ctx, cancel := context.WithTimeout(parentCtx, backupTimeout)++ go func() {+ ticker := time.NewTicker(shutdownCheckInterval)+ defer ticker.Stop()++ for {+ select {+ case <-ctx.Done():+ return+ case <-ticker.C:+ if config.IsShouldShutdown() {+ cancel()+ return+ }+ }+ }+ }()++ return ctx, cancel+}++func (uc *CreatePostgresqlBackupUsecase) setupPgpassFile(+ pgConfig *pgtypes.PostgresqlDatabase,+ password string,+) (string, error) {+ pgpassFile, err := uc.createTempPgpassFile(pgConfig, password)+ if err != nil {+ return "", fmt.Errorf("failed to create temporary .pgpass file: %w", err)+ }++ if pgpassFile == "" {+ return "", fmt.Errorf("temporary .pgpass file was not created")+ }++ if info, err := os.Stat(pgpassFile); err == nil {+ uc.logger.Info("Temporary .pgpass file created successfully",+ "pgpassFile", pgpassFile,+ "size", info.Size(),+ "mode", info.Mode(),+ )+ } else {+ return "", fmt.Errorf("failed to verify .pgpass file: %w", err)+ }++ return pgpassFile, nil+}++func (uc *CreatePostgresqlBackupUsecase) setupPgEnvironment(+ cmd *exec.Cmd,+ pgpassFile string,+ shouldRequireSSL bool,+ password string,+ cpuCount int,+ pgBin string,+) error {+ cmd.Env = os.Environ()+ cmd.Env = append(cmd.Env, "PGPASSFILE="+pgpassFile)++ uc.logger.Info("Using temporary .pgpass file for authentication", "pgpassFile", pgpassFile)+ uc.logger.Info("Setting up PostgreSQL environment",+ "passwordLength", len(password),+ "passwordEmpty", password == "",+ "pgBin", pgBin,+ "usingPgpassFile", true,+ "parallelJobs", cpuCount,+ )++ cmd.Env = append(cmd.Env,+ "PGCLIENTENCODING=UTF8",+ "PGCONNECT_TIMEOUT="+strconv.Itoa(pgConnectTimeout),+ "LC_ALL=C.UTF-8",+ "LANG=C.UTF-8",+ "PGOPTIONS=--client-encoding=UTF8",+ )++ if shouldRequireSSL {+ cmd.Env = append(cmd.Env, "PGSSLMODE=require")+ uc.logger.Info("Using required SSL mode", "configuredHttps", shouldRequireSSL)+ } else {+ cmd.Env = append(cmd.Env, "PGSSLMODE=prefer")+ uc.logger.Info("Using preferred SSL mode", "configuredHttps", shouldRequireSSL)+ }++ cmd.Env = append(cmd.Env,+ "PGSSLCERT=",+ "PGSSLKEY=",+ "PGSSLROOTCERT=",+ "PGSSLCRL=",+ )++ if _, err := exec.LookPath(pgBin); err != nil {+ return fmt.Errorf("PostgreSQL executable not found or not accessible: %s - %w", pgBin, err)+ }++ return nil+}++func (uc *CreatePostgresqlBackupUsecase) setupBackupEncryption(+ backupID uuid.UUID,+ backupConfig *backups_config.BackupConfig,+ storageWriter io.WriteCloser,+) (io.Writer, *encryption.EncryptionWriter, BackupMetadata, error) {+ metadata := BackupMetadata{}++ if backupConfig.Encryption != backups_config.BackupEncryptionEncrypted {+ metadata.Encryption = backups_config.BackupEncryptionNone+ uc.logger.Info("Encryption disabled for backup", "backupId", backupID)+ return storageWriter, nil, metadata, nil+ }++ salt, err := encryption.GenerateSalt()+ if err != nil {+ return nil, nil, metadata, fmt.Errorf("failed to generate salt: %w", err)+ }++ nonce, err := encryption.GenerateNonce()+ if err != nil {+ return nil, nil, metadata, fmt.Errorf("failed to generate nonce: %w", err)+ }++ masterKey, err := uc.secretKeyRepo.GetSecretKey()+ if err != nil {+ return nil, nil, metadata, fmt.Errorf("failed to get master key: %w", err)+ }++ encWriter, err := encryption.NewEncryptionWriter(+ storageWriter,+ masterKey,+ backupID,+ salt,+ nonce,+ )+ if err != nil {+ return nil, nil, metadata, fmt.Errorf("failed to create encrypting writer: %w", err)+ }++ saltBase64 := base64.StdEncoding.EncodeToString(salt)+ nonceBase64 := base64.StdEncoding.EncodeToString(nonce)+ metadata.EncryptionSalt = &saltBase64+ metadata.EncryptionIV = &nonceBase64+ metadata.Encryption = backups_config.BackupEncryptionEncrypted++ uc.logger.Info("Encryption enabled for backup", "backupId", backupID)+ return encWriter, encWriter, metadata, nil+}++func (uc *CreatePostgresqlBackupUsecase) cleanupOnCancellation(+ encryptionWriter *encryption.EncryptionWriter,+ storageWriter io.WriteCloser,+ saveErrCh chan error,+) {+ if encryptionWriter != nil {+ go func() {+ if closeErr := encryptionWriter.Close(); closeErr != nil {+ uc.logger.Error(+ "Failed to close encrypting writer during cancellation",+ "error",+ closeErr,+ )+ }+ }()+ }++ if err := storageWriter.Close(); err != nil {+ uc.logger.Error("Failed to close pipe writer during cancellation", "error", err)+ }++ <-saveErrCh+}++func (uc *CreatePostgresqlBackupUsecase) closeWriters(+ encryptionWriter *encryption.EncryptionWriter,+ storageWriter io.WriteCloser,+) error {+ encryptionCloseErrCh := make(chan error, 1)+ if encryptionWriter != nil {+ go func() {+ closeErr := encryptionWriter.Close()+ if closeErr != nil {+ uc.logger.Error("Failed to close encrypting writer", "error", closeErr)+ }+ encryptionCloseErrCh <- closeErr+ }()+ } else {+ encryptionCloseErrCh <- nil+ }++ encryptionCloseErr := <-encryptionCloseErrCh+ if encryptionCloseErr != nil {+ if err := storageWriter.Close(); err != nil {+ uc.logger.Error("Failed to close pipe writer after encryption error", "error", err)+ }+ return fmt.Errorf("failed to close encryption writer: %w", encryptionCloseErr)+ }++ if err := storageWriter.Close(); err != nil {+ uc.logger.Error("Failed to close pipe writer", "error", err)+ return err+ }++ return nil+}++func (uc *CreatePostgresqlBackupUsecase) checkCancellation(ctx context.Context) error {+ select {+ case <-ctx.Done():+ if config.IsShouldShutdown() {+ return fmt.Errorf("backup cancelled due to shutdown")+ }+ return fmt.Errorf("backup cancelled")+ default:+ return nil+ }+}++func (uc *CreatePostgresqlBackupUsecase) checkCancellationReason() error {+ if config.IsShouldShutdown() {+ return fmt.Errorf("backup cancelled due to shutdown")+ }+ return fmt.Errorf("backup cancelled")+}++func (uc *CreatePostgresqlBackupUsecase) buildPgDumpErrorMessage(+ waitErr error,+ stderrOutput []byte,+ pgBin string,+ args []string,+ password string,+) error {+ stderrStr := string(stderrOutput)+ errorMsg := fmt.Sprintf("%s failed: %v β stderr: %s", filepath.Base(pgBin), waitErr, stderrStr)++ exitErr, ok := waitErr.(*exec.ExitError)+ if !ok {+ return errors.New(errorMsg)+ }++ exitCode := exitErr.ExitCode()++ if exitCode == exitCodeGenericError && strings.TrimSpace(stderrStr) == "" {+ return uc.handleExitCode1NoStderr(pgBin, args)+ }++ if exitCode == exitCodeAccessViolation {+ return uc.handleAccessViolation(pgBin, stderrStr)+ }++ if exitCode == exitCodeGenericError || exitCode == exitCodeConnectionError {+ return uc.handleConnectionErrors(stderrStr, password)+ }++ return errors.New(errorMsg)+}++func (uc *CreatePostgresqlBackupUsecase) handleExitCode1NoStderr(+ pgBin string,+ args []string,+) error {+ uc.logger.Error("pg_dump failed with exit status 1 but no stderr output",+ "pgBin", pgBin,+ "args", args,+ "env_vars", []string{+ "PGCLIENTENCODING=UTF8",+ "PGCONNECT_TIMEOUT=" + strconv.Itoa(pgConnectTimeout),+ "LC_ALL=C.UTF-8",+ "LANG=C.UTF-8",+ "PGOPTIONS=--client-encoding=UTF8",+ },+ )++ return fmt.Errorf(+ "%s failed with exit status 1 but provided no error details. "++ "This often indicates: "++ "1) Connection timeout or refused connection, "++ "2) Authentication failure with incorrect credentials, "++ "3) Database does not exist, "++ "4) Network connectivity issues, "++ "5) PostgreSQL server not running. "++ "Command executed: %s %s",+ filepath.Base(pgBin),+ pgBin,+ strings.Join(args, " "),+ )+}++func (uc *CreatePostgresqlBackupUsecase) handleAccessViolation(+ pgBin string,+ stderrStr string,+) error {+ uc.logger.Error("PostgreSQL tool crashed with access violation",+ "pgBin", pgBin,+ "exitCode", "0xC0000005",+ )++ return fmt.Errorf(+ "%s crashed with access violation (0xC0000005). "++ "This may indicate incompatible PostgreSQL version, corrupted installation, or connection issues. "++ "stderr: %s",+ filepath.Base(pgBin),+ stderrStr,+ )+}++func (uc *CreatePostgresqlBackupUsecase) handleConnectionErrors(+ stderrStr string,+ password string,+) error {+ if containsIgnoreCase(stderrStr, "pg_hba.conf") {+ return fmt.Errorf(+ "PostgreSQL connection rejected by server configuration (pg_hba.conf). "++ "The server may not allow connections from your IP address or may require different authentication settings. "++ "stderr: %s",+ stderrStr,+ )+ }++ if containsIgnoreCase(stderrStr, "no password supplied") ||+ containsIgnoreCase(stderrStr, "fe_sendauth") {+ return fmt.Errorf(+ "PostgreSQL authentication failed - no password supplied. "++ "PGPASSWORD environment variable may not be working correctly on this system. "++ "Password length: %d, Password empty: %v. "++ "Consider using a .pgpass file as an alternative. "++ "stderr: %s",+ len(password),+ password == "",+ stderrStr,+ )+ }++ if containsIgnoreCase(stderrStr, "ssl") && containsIgnoreCase(stderrStr, "connection") {+ return fmt.Errorf(+ "PostgreSQL SSL connection failed. "++ "The server may require SSL encryption or have SSL configuration issues. "++ "stderr: %s",+ stderrStr,+ )+ }++ if containsIgnoreCase(stderrStr, "connection") && containsIgnoreCase(stderrStr, "refused") {+ return fmt.Errorf(+ "PostgreSQL connection refused. "++ "Check if the server is running and accessible from your network. "++ "stderr: %s",+ stderrStr,+ )+ }++ if containsIgnoreCase(stderrStr, "authentication") ||+ containsIgnoreCase(stderrStr, "password") {+ return fmt.Errorf(+ "PostgreSQL authentication failed. Check username and password. stderr: %s",+ stderrStr,+ )+ }++ if containsIgnoreCase(stderrStr, "timeout") {+ return fmt.Errorf(+ "PostgreSQL connection timeout. The server may be unreachable or overloaded. stderr: %s",+ stderrStr,+ )+ }++ return fmt.Errorf("PostgreSQL connection or authentication error. stderr: %s", stderrStr)}-// createTempPgpassFile creates a temporary .pgpass file with the given passwordfunc (uc *CreatePostgresqlBackupUsecase) createTempPgpassFile(pgConfig *pgtypes.PostgresqlDatabase,password string,@@ -532,7 +720,6 @@ func (uc *CreatePostgresqlBackupUsecase) createTempPgpassFile(password,)- // it always create unique directory like /tmp/pgpass-1234567890tempDir, err := os.MkdirTemp("", "pgpass")if err != nil {return "", fmt.Errorf("failed to create temporary directory: %w", err)@@ -546,3 +733,7 @@ func (uc *CreatePostgresqlBackupUsecase) createTempPgpassFile(return pgpassFile, nil}++func containsIgnoreCase(str, substr string) bool {+ return strings.Contains(strings.ToLower(str), strings.ToLower(substr))+}diff --git a/backend/internal/features/backups/backups/usecases/postgresql/di.go b/backend/internal/features/backups/backups/usecases/postgresql/di.goindex e4a1f4e0..f9bf0918 100644--- a/backend/internal/features/backups/backups/usecases/postgresql/di.go+++ b/backend/internal/features/backups/backups/usecases/postgresql/di.go@@ -1,11 +1,13 @@package usecases_postgresqlimport (+ users_repositories "postgresus-backend/internal/features/users/repositories""postgresus-backend/internal/util/logger")var createPostgresqlBackupUsecase = &CreatePostgresqlBackupUsecase{logger.GetLogger(),+ users_repositories.GetSecretKeyRepository(),}func GetCreatePostgresqlBackupUsecase() *CreatePostgresqlBackupUsecase {diff --git a/backend/internal/features/backups/backups/usecases/postgresql/dto.go b/backend/internal/features/backups/backups/usecases/postgresql/dto.gonew file mode 100644index 00000000..594613c9--- /dev/null+++ b/backend/internal/features/backups/backups/usecases/postgresql/dto.go@@ -0,0 +1,15 @@+package usecases_postgresql++import backups_config "postgresus-backend/internal/features/backups/config"++type EncryptionMetadata struct {+ Salt string+ IV string+ Encryption backups_config.BackupEncryption+}++type BackupMetadata struct {+ EncryptionSalt *string+ EncryptionIV *string+ Encryption backups_config.BackupEncryption+}diff --git a/backend/internal/features/backups/config/controller.go b/backend/internal/features/backups/config/controller.goindex 91205454..08dccf92 100644--- a/backend/internal/features/backups/config/controller.go+++ b/backend/internal/features/backups/config/controller.go@@ -20,15 +20,15 @@ func (c *BackupConfigController) RegisterRoutes(router *gin.RouterGroup) {// SaveBackupConfig// @Summary Save backup configuration-// @Description Save or update backup configuration for a database+// @Description Save or update backup configuration for a database. Encryption can be set to NONE (no encryption) or ENCRYPTED (AES-256-GCM encryption).// @Tags backup-configs// @Accept json// @Produce json-// @Param request body BackupConfig true "Backup configuration data"-// @Success 200 {object} BackupConfig-// @Failure 400-// @Failure 401-// @Failure 500+// @Param request body BackupConfig true "Backup configuration data (encryption field: NONE or ENCRYPTED)"+// @Success 200 {object} BackupConfig "Returns the saved backup configuration including encryption settings"+// @Failure 400 {object} map[string]string "Invalid encryption value or other validation errors"+// @Failure 401 {object} map[string]string "User not authenticated"+// @Failure 500 {object} map[string]string "Internal server error"// @Router /backup-configs/save [post]func (c *BackupConfigController) SaveBackupConfig(ctx *gin.Context) {user, ok := users_middleware.GetUserFromContext(ctx)@@ -57,14 +57,14 @@ func (c *BackupConfigController) SaveBackupConfig(ctx *gin.Context) {// GetBackupConfigByDbID// @Summary Get backup configuration by database ID-// @Description Get backup configuration for a specific database+// @Description Get backup configuration for a specific database including encryption settings (NONE or ENCRYPTED)// @Tags backup-configs// @Produce json// @Param id path string true "Database ID"-// @Success 200 {object} BackupConfig-// @Failure 400-// @Failure 401-// @Failure 404+// @Success 200 {object} BackupConfig "Returns backup configuration with encryption field"+// @Failure 400 {object} map[string]string "Invalid database ID"+// @Failure 401 {object} map[string]string "User not authenticated"+// @Failure 404 {object} map[string]string "Backup configuration not found"// @Router /backup-configs/database/{id} [get]func (c *BackupConfigController) GetBackupConfigByDbID(ctx *gin.Context) {user, ok := users_middleware.GetUserFromContext(ctx)diff --git a/backend/internal/features/backups/config/controller_test.go b/backend/internal/features/backups/config/controller_test.goindex 24cd24ee..0b67630c 100644--- a/backend/internal/features/backups/config/controller_test.go+++ b/backend/internal/features/backups/config/controller_test.go@@ -368,6 +368,86 @@ func Test_IsStorageUsing_PermissionsEnforced(t *testing.T) {}}+func Test_SaveBackupConfig_WithEncryptionNone_ConfigSaved(t *testing.T) {+ router := createTestRouter()+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)+ workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)++ database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)++ timeOfDay := "04:00"+ request := BackupConfig{+ DatabaseID: database.ID,+ IsBackupsEnabled: true,+ StorePeriod: period.PeriodWeek,+ BackupInterval: &intervals.Interval{+ Interval: intervals.IntervalDaily,+ TimeOfDay: &timeOfDay,+ },+ SendNotificationsOn: []BackupNotificationType{+ NotificationBackupFailed,+ },+ CpuCount: 2,+ IsRetryIfFailed: true,+ MaxFailedTriesCount: 3,+ Encryption: BackupEncryptionNone,+ }++ var response BackupConfig+ test_utils.MakePostRequestAndUnmarshal(+ t,+ router,+ "/api/v1/backup-configs/save",+ "Bearer "+owner.Token,+ request,+ http.StatusOK,+ &response,+ )++ assert.Equal(t, database.ID, response.DatabaseID)+ assert.Equal(t, BackupEncryptionNone, response.Encryption)+}++func Test_SaveBackupConfig_WithEncryptionEncrypted_ConfigSaved(t *testing.T) {+ router := createTestRouter()+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)+ workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)++ database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)++ timeOfDay := "04:00"+ request := BackupConfig{+ DatabaseID: database.ID,+ IsBackupsEnabled: true,+ StorePeriod: period.PeriodWeek,+ BackupInterval: &intervals.Interval{+ Interval: intervals.IntervalDaily,+ TimeOfDay: &timeOfDay,+ },+ SendNotificationsOn: []BackupNotificationType{+ NotificationBackupFailed,+ },+ CpuCount: 2,+ IsRetryIfFailed: true,+ MaxFailedTriesCount: 3,+ Encryption: BackupEncryptionEncrypted,+ }++ var response BackupConfig+ test_utils.MakePostRequestAndUnmarshal(+ t,+ router,+ "/api/v1/backup-configs/save",+ "Bearer "+owner.Token,+ request,+ http.StatusOK,+ &response,+ )++ assert.Equal(t, database.ID, response.DatabaseID)+ assert.Equal(t, BackupEncryptionEncrypted, response.Encryption)+}+func createTestDatabaseViaAPI(name string,workspaceID uuid.UUID,diff --git a/backend/internal/features/backups/config/enums.go b/backend/internal/features/backups/config/enums.goindex b37455f9..3baedc3b 100644--- a/backend/internal/features/backups/config/enums.go+++ b/backend/internal/features/backups/config/enums.go@@ -6,3 +6,10 @@ const (NotificationBackupFailed BackupNotificationType = "BACKUP_FAILED"NotificationBackupSuccess BackupNotificationType = "BACKUP_SUCCESS")++type BackupEncryption string++const (+ BackupEncryptionNone BackupEncryption = "NONE"+ BackupEncryptionEncrypted BackupEncryption = "ENCRYPTED"+)diff --git a/backend/internal/features/backups/config/model.go b/backend/internal/features/backups/config/model.goindex bf8c8e08..2a49f2c2 100644--- a/backend/internal/features/backups/config/model.go+++ b/backend/internal/features/backups/config/model.go@@ -31,6 +31,8 @@ type BackupConfig struct {MaxFailedTriesCount int `json:"maxFailedTriesCount" gorm:"column:max_failed_tries_count;type:int;not null"`CpuCount int `json:"cpuCount" gorm:"type:int;not null"`++ Encryption BackupEncryption `json:"encryption" gorm:"column:encryption;type:text;not null;default:'NONE'"`}func (h *BackupConfig) TableName() string {@@ -88,6 +90,11 @@ func (b *BackupConfig) Validate() error {return errors.New("max failed tries count must be greater than 0")}+ if b.Encryption != "" && b.Encryption != BackupEncryptionNone &&+ b.Encryption != BackupEncryptionEncrypted {+ return errors.New("encryption must be NONE or ENCRYPTED")+ }+return nil}@@ -103,5 +110,6 @@ func (b *BackupConfig) Copy(newDatabaseID uuid.UUID) *BackupConfig {IsRetryIfFailed: b.IsRetryIfFailed,MaxFailedTriesCount: b.MaxFailedTriesCount,CpuCount: b.CpuCount,+ Encryption: b.Encryption,}}diff --git a/backend/internal/features/backups/config/service.go b/backend/internal/features/backups/config/service.goindex 510702c9..6c7b8f18 100644--- a/backend/internal/features/backups/config/service.go+++ b/backend/internal/features/backups/config/service.go@@ -171,6 +171,7 @@ func (s *BackupConfigService) initializeDefaultConfig(CpuCount: 1,IsRetryIfFailed: true,MaxFailedTriesCount: 3,+ Encryption: BackupEncryptionNone,})return errdiff --git a/backend/internal/features/restores/usecases/postgresql/di.go b/backend/internal/features/restores/usecases/postgresql/di.goindex 5c3828f7..b099f40d 100644--- a/backend/internal/features/restores/usecases/postgresql/di.go+++ b/backend/internal/features/restores/usecases/postgresql/di.go@@ -1,11 +1,13 @@package usecases_postgresqlimport (+ users_repositories "postgresus-backend/internal/features/users/repositories""postgresus-backend/internal/util/logger")var restorePostgresqlBackupUsecase = &RestorePostgresqlBackupUsecase{logger.GetLogger(),+ users_repositories.GetSecretKeyRepository(),}func GetRestorePostgresqlBackupUsecase() *RestorePostgresqlBackupUsecase {diff --git a/backend/internal/features/restores/usecases/postgresql/restore_backup_uc.go b/backend/internal/features/restores/usecases/postgresql/restore_backup_uc.goindex 8a5fdeb8..6c0f9ea1 100644--- a/backend/internal/features/restores/usecases/postgresql/restore_backup_uc.go+++ b/backend/internal/features/restores/usecases/postgresql/restore_backup_uc.go@@ -2,6 +2,7 @@ package usecases_postgresqlimport ("context"+ "encoding/base64""errors""fmt""io"@@ -15,11 +16,13 @@ import ("postgresus-backend/internal/config""postgresus-backend/internal/features/backups/backups"+ "postgresus-backend/internal/features/backups/backups/encryption"backups_config "postgresus-backend/internal/features/backups/config""postgresus-backend/internal/features/databases"pgtypes "postgresus-backend/internal/features/databases/databases/postgresql""postgresus-backend/internal/features/restores/models""postgresus-backend/internal/features/storages"+ users_repositories "postgresus-backend/internal/features/users/repositories"files_utils "postgresus-backend/internal/util/files""postgresus-backend/internal/util/tools"@@ -27,7 +30,8 @@ import ()type RestorePostgresqlBackupUsecase struct {- logger *slog.Logger+ logger *slog.Logger+ secretKeyRepo *users_repositories.SecretKeyRepository}func (uc *RestorePostgresqlBackupUsecase) Execute(@@ -202,18 +206,66 @@ func (uc *RestorePostgresqlBackupUsecase) downloadBackupToTempFile(backup.ID,"tempFile",tempBackupFile,+ "encrypted",+ backup.Encryption == backups_config.BackupEncryptionEncrypted,)- backupReader, err := storage.GetFile(backup.ID)+ rawReader, err := storage.GetFile(backup.ID)if err != nil {cleanupFunc()return "", nil, fmt.Errorf("failed to get backup file from storage: %w", err)}defer func() {- if err := backupReader.Close(); err != nil {+ if err := rawReader.Close(); err != nil {uc.logger.Error("Failed to close backup reader", "error", err)}}()+ // Create a reader that handles decryption if needed+ var backupReader io.Reader = rawReader+ if backup.Encryption == backups_config.BackupEncryptionEncrypted {+ // Validate encryption metadata+ if backup.EncryptionSalt == nil || backup.EncryptionIV == nil {+ cleanupFunc()+ return "", nil, fmt.Errorf("backup is encrypted but missing encryption metadata")+ }++ // Get master key+ masterKey, err := uc.secretKeyRepo.GetSecretKey()+ if err != nil {+ cleanupFunc()+ return "", nil, fmt.Errorf("failed to get master key for decryption: %w", err)+ }++ // Decode salt and IV from base64+ salt, err := base64.StdEncoding.DecodeString(*backup.EncryptionSalt)+ if err != nil {+ cleanupFunc()+ return "", nil, fmt.Errorf("failed to decode encryption salt: %w", err)+ }++ iv, err := base64.StdEncoding.DecodeString(*backup.EncryptionIV)+ if err != nil {+ cleanupFunc()+ return "", nil, fmt.Errorf("failed to decode encryption IV: %w", err)+ }++ // Create decryption reader+ decryptReader, err := encryption.NewDecryptionReader(+ rawReader,+ masterKey,+ backup.ID,+ salt,+ iv,+ )+ if err != nil {+ cleanupFunc()+ return "", nil, fmt.Errorf("failed to create decryption reader: %w", err)+ }++ backupReader = decryptReader+ uc.logger.Info("Using decryption for encrypted backup", "backupId", backup.ID)+ }+// Create temporary backup filetempFile, err := os.Create(tempBackupFile)if err != nil {diff --git a/backend/internal/features/tests/postgresql_backup_restore_test.go b/backend/internal/features/tests/postgresql_backup_restore_test.goindex cf624b95..e39bbbe8 100644--- a/backend/internal/features/tests/postgresql_backup_restore_test.go+++ b/backend/internal/features/tests/postgresql_backup_restore_test.go@@ -79,14 +79,171 @@ func Test_BackupAndRestorePostgresql_RestoreIsSuccesful(t *testing.T) {}for _, tc := range cases {- tc := tc // capture loop variablet.Run(tc.name, func(t *testing.T) {- t.Parallel() // Enable parallel execution+ t.Parallel()testBackupRestoreForVersion(t, tc.version, tc.port)})}}+func Test_BackupAndRestorePostgresqlWithEncryption_RestoreIsSuccessful(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},+ {"PostgreSQL 18", "18", env.TestPostgres18Port},+ }++ for _, tc := range cases {+ t.Run(tc.name, func(t *testing.T) {+ t.Parallel()+ testBackupRestoreWithEncryptionForVersion(t, tc.version, tc.port)+ })+ }+}++func testBackupRestoreWithEncryptionForVersion(t *testing.T, pgVersion string, port string) {+ // Connect to pre-configured PostgreSQL container+ container, err := connectToPostgresContainer(pgVersion, port)+ assert.NoError(t, err)+ defer func() {+ if container.DB != nil {+ container.DB.Close()+ }+ }()++ _, err = container.DB.Exec(createAndFillTableQuery)+ assert.NoError(t, err)++ // Prepare data for backup+ backupID := uuid.New()+ pgVersionEnum := tools.GetPostgresqlVersionEnum(pgVersion)++ backupDb := &databases.Database{+ ID: uuid.New(),+ Type: databases.DatabaseTypePostgres,+ Name: "Test Database",+ Postgresql: &pgtypes.PostgresqlDatabase{+ Version: pgVersionEnum,+ Host: container.Host,+ Port: container.Port,+ Username: container.Username,+ Password: container.Password,+ Database: &container.Database,+ IsHttps: false,+ },+ }++ storageID := uuid.New()+ backupConfig := &backups_config.BackupConfig{+ DatabaseID: backupDb.ID,+ IsBackupsEnabled: true,+ StorePeriod: period.PeriodDay,+ BackupInterval: &intervals.Interval{Interval: intervals.IntervalDaily},+ StorageID: &storageID,+ CpuCount: 1,+ Encryption: backups_config.BackupEncryptionEncrypted,+ }++ storage := &storages.Storage{+ WorkspaceID: uuid.New(),+ Type: storages.StorageTypeLocal,+ Name: "Test Storage",+ LocalStorage: &local_storage.LocalStorage{},+ }++ // Make backup+ progressTracker := func(completedMBs float64) {}+ metadata, err := usecases_postgresql_backup.GetCreatePostgresqlBackupUsecase().Execute(+ context.Background(),+ backupID,+ backupConfig,+ backupDb,+ storage,+ progressTracker,+ )+ assert.NoError(t, err)+ assert.NotNil(t, metadata)++ // Verify encryption metadata is set+ assert.Equal(t, backups_config.BackupEncryptionEncrypted, metadata.Encryption)+ assert.NotNil(t, metadata.EncryptionSalt)+ assert.NotNil(t, metadata.EncryptionIV)++ // Create new database+ newDBName := "restoreddb_encrypted"+ _, err = container.DB.Exec(fmt.Sprintf("DROP DATABASE IF EXISTS %s;", newDBName))+ assert.NoError(t, err)++ _, err = container.DB.Exec(fmt.Sprintf("CREATE DATABASE %s;", newDBName))+ assert.NoError(t, err)++ // Connect to the new database+ newDSN := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable",+ container.Host, container.Port, container.Username, container.Password, newDBName)+ newDB, err := sqlx.Connect("postgres", newDSN)+ assert.NoError(t, err)+ defer newDB.Close()++ // Setup data for restore with encryption metadata+ completedBackup := &backups.Backup{+ ID: backupID,+ DatabaseID: backupDb.ID,+ StorageID: storage.ID,+ Status: backups.BackupStatusCompleted,+ CreatedAt: time.Now().UTC(),+ EncryptionSalt: metadata.EncryptionSalt,+ EncryptionIV: metadata.EncryptionIV,+ Encryption: metadata.Encryption,+ }++ restoreID := uuid.New()+ restore := models.Restore{+ ID: restoreID,+ Backup: completedBackup,+ Postgresql: &pgtypes.PostgresqlDatabase{+ Version: pgVersionEnum,+ Host: container.Host,+ Port: container.Port,+ Username: container.Username,+ Password: container.Password,+ Database: &newDBName,+ IsHttps: false,+ },+ }++ // Restore the encrypted backup+ restoreBackupUC := usecases_postgresql_restore.GetRestorePostgresqlBackupUsecase()+ err = restoreBackupUC.Execute(backupDb, backupConfig, restore, completedBackup, storage)+ assert.NoError(t, err)++ // Verify restored table exists+ var tableExists bool+ err = newDB.Get(+ &tableExists,+ "SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = 'test_data')",+ )+ assert.NoError(t, err)+ assert.True(t, tableExists, "Table 'test_data' should exist in restored database")++ // Verify data integrity+ verifyDataIntegrity(t, container.DB, newDB)++ // Clean up the backup file after the test+ err = os.Remove(filepath.Join(config.GetEnv().DataFolder, backupID.String()))+ if err != nil {+ t.Logf("Warning: Failed to delete backup file: %v", err)+ }+}+// Run a test for a specific PostgreSQL versionfunc testBackupRestoreForVersion(t *testing.T, pgVersion string, port string) {// Connect to pre-configured PostgreSQL container@@ -139,7 +296,7 @@ func testBackupRestoreForVersion(t *testing.T, pgVersion string, port string) {// Make backupprogressTracker := func(completedMBs float64) {}- err = usecases_postgresql_backup.GetCreatePostgresqlBackupUsecase().Execute(+ _, err = usecases_postgresql_backup.GetCreatePostgresqlBackupUsecase().Execute(context.Background(),backupID,backupConfig,diff --git a/backend/internal/features/users/repositories/di.go b/backend/internal/features/users/repositories/di.gonew file mode 100644index 00000000..3e5f324a--- /dev/null+++ b/backend/internal/features/users/repositories/di.go@@ -0,0 +1,17 @@+package users_repositories++var secretKeyRepository = &SecretKeyRepository{}+var userRepository = &UserRepository{}+var usersSettingsRepository = &UsersSettingsRepository{}++func GetSecretKeyRepository() *SecretKeyRepository {+ return secretKeyRepository+}++func GetUserRepository() *UserRepository {+ return userRepository+}++func GetUsersSettingsRepository() *UsersSettingsRepository {+ return usersSettingsRepository+}diff --git a/backend/internal/features/users/repositories/secret_key_repository.go b/backend/internal/features/users/repositories/secret_key_repository.goindex 865a2718..23fe726d 100644--- a/backend/internal/features/users/repositories/secret_key_repository.go+++ b/backend/internal/features/users/repositories/secret_key_repository.go@@ -14,9 +14,7 @@ type SecretKeyRepository struct{}func (r *SecretKeyRepository) GetSecretKey() (string, error) {var secretKey user_models.SecretKey- if err := storage.- GetDb().- First(&secretKey).Error; err != nil {+ if err := storage.GetDb().First(&secretKey).Error; err != nil {// create a new secret key if not foundif errors.Is(err, gorm.ErrRecordNotFound) {newSecretKey := user_models.SecretKey{diff --git a/backend/internal/features/users/services/di.go b/backend/internal/features/users/services/di.goindex fe2a4785..858e3a54 100644--- a/backend/internal/features/users/services/di.go+++ b/backend/internal/features/users/services/di.go@@ -1,25 +1,19 @@package users_services-import (- user_repositories "postgresus-backend/internal/features/users/repositories"-)--var secretKeyRepository = &user_repositories.SecretKeyRepository{}-var userRepository = &user_repositories.UserRepository{}-var usersSettingsRepository = &user_repositories.UsersSettingsRepository{}+import users_repositories "postgresus-backend/internal/features/users/repositories"var userService = &UserService{- userRepository,- secretKeyRepository,+ users_repositories.GetUserRepository(),+ users_repositories.GetSecretKeyRepository(),settingsService,nil,}var settingsService = &SettingsService{- usersSettingsRepository,+ users_repositories.GetUsersSettingsRepository(),nil,}var managementService = &UserManagementService{- userRepository,+ users_repositories.GetUserRepository(),nil,}diff --git a/backend/migrations/20251117064849_add_backup_encryption_fields.sql b/backend/migrations/20251117064849_add_backup_encryption_fields.sqlnew file mode 100644index 00000000..3a679d88--- /dev/null+++ b/backend/migrations/20251117064849_add_backup_encryption_fields.sql@@ -0,0 +1,25 @@+-- +goose Up+-- +goose StatementBegin++ALTER TABLE backup_configs+ ADD COLUMN encryption TEXT NOT NULL DEFAULT 'NONE';++ALTER TABLE backups+ ADD COLUMN encryption_salt TEXT,+ ADD COLUMN encryption_iv TEXT,+ ADD COLUMN encryption TEXT NOT NULL DEFAULT 'NONE';++-- +goose StatementEnd++-- +goose Down+-- +goose StatementBegin++ALTER TABLE backups+ DROP COLUMN IF EXISTS encryption,+ DROP COLUMN IF EXISTS encryption_iv,+ DROP COLUMN IF EXISTS encryption_salt;++ALTER TABLE backup_configs+ DROP COLUMN IF EXISTS encryption;++-- +goose StatementEnddiff --git a/frontend/src/entity/backups/index.ts b/frontend/src/entity/backups/index.tsindex ccf3c2a6..732c3193 100644--- a/frontend/src/entity/backups/index.ts+++ b/frontend/src/entity/backups/index.ts@@ -4,3 +4,4 @@ export { BackupStatus } from './model/BackupStatus';export type { Backup } from './model/Backup';export type { BackupConfig } from './model/BackupConfig';export { BackupNotificationType } from './model/BackupNotificationType';+export { BackupEncryption } from './model/BackupEncryption';diff --git a/frontend/src/entity/backups/model/Backup.ts b/frontend/src/entity/backups/model/Backup.tsindex 758ceb42..7cc98be4 100644--- a/frontend/src/entity/backups/model/Backup.ts+++ b/frontend/src/entity/backups/model/Backup.ts@@ -1,5 +1,6 @@import type { Database } from '../../databases/model/Database';import type { Storage } from '../../storages';+import { BackupEncryption } from './BackupEncryption';import { BackupStatus } from './BackupStatus';export interface Backup {@@ -15,5 +16,7 @@ export interface Backup {backupDurationMs: number;+ encryption: BackupEncryption;+createdAt: Date;}diff --git a/frontend/src/entity/backups/model/BackupConfig.ts b/frontend/src/entity/backups/model/BackupConfig.tsindex 76165aad..d6ff84be 100644--- a/frontend/src/entity/backups/model/BackupConfig.ts+++ b/frontend/src/entity/backups/model/BackupConfig.ts@@ -1,6 +1,7 @@import type { Period } from '../../databases/model/Period';import type { Interval } from '../../intervals';import type { Storage } from '../../storages';+import { BackupEncryption } from './BackupEncryption';import type { BackupNotificationType } from './BackupNotificationType';export interface BackupConfig {@@ -14,4 +15,5 @@ export interface BackupConfig {cpuCount: number;isRetryIfFailed: boolean;maxFailedTriesCount: number;+ encryption: BackupEncryption;}diff --git a/frontend/src/entity/backups/model/BackupEncryption.ts b/frontend/src/entity/backups/model/BackupEncryption.tsnew file mode 100644index 00000000..b9bb639d--- /dev/null+++ b/frontend/src/entity/backups/model/BackupEncryption.ts@@ -0,0 +1,4 @@+export enum BackupEncryption {+ NONE = 'NONE',+ ENCRYPTED = 'ENCRYPTED',+}diff --git a/frontend/src/features/backups/ui/BackupsComponent.tsx b/frontend/src/features/backups/ui/BackupsComponent.tsxindex 3b9dddd5..7074e442 100644--- a/frontend/src/features/backups/ui/BackupsComponent.tsx+++ b/frontend/src/features/backups/ui/BackupsComponent.tsx@@ -6,6 +6,7 @@ import {DownloadOutlined,ExclamationCircleOutlined,InfoCircleOutlined,+ LockOutlined,SyncOutlined,} from '@ant-design/icons';import { Button, Modal, Spin, Table, Tooltip } from 'antd';@@ -16,6 +17,7 @@ import { useEffect, useRef, useState } from 'react';import {type Backup,type BackupConfig,+ BackupEncryption,BackupStatus,backupConfigApi,backupsApi,@@ -318,6 +320,12 @@ export const BackupsComponent = ({ database, isCanManageDBs, scrollContainerRef<div className="flex items-center text-green-600"><CheckCircleOutlined className="mr-2" style={{ fontSize: 16 }} /><div>Successful</div>++ {record.encryption === BackupEncryption.ENCRYPTED && (+ <Tooltip title="Encrypted">+ <LockOutlined className="ml-1" style={{ fontSize: 14 }} />+ </Tooltip>+ )}</div>);}diff --git a/frontend/src/features/backups/ui/EditBackupConfigComponent.tsx b/frontend/src/features/backups/ui/EditBackupConfigComponent.tsxindex 40d54bb4..77ba61aa 100644--- a/frontend/src/features/backups/ui/EditBackupConfigComponent.tsx+++ b/frontend/src/features/backups/ui/EditBackupConfigComponent.tsx@@ -13,7 +13,7 @@ import {import dayjs, { Dayjs } from 'dayjs';import { useEffect, useMemo, useState } from 'react';-import { type BackupConfig, backupConfigApi } from '../../../entity/backups';+import { type BackupConfig, BackupEncryption, backupConfigApi } from '../../../entity/backups';import { BackupNotificationType } from '../../../entity/backups/model/BackupNotificationType';import type { Database } from '../../../entity/databases';import { Period } from '../../../entity/databases/model/Period';@@ -153,6 +153,7 @@ export const EditBackupConfigComponent = ({sendNotificationsOn: [],isRetryIfFailed: true,maxFailedTriesCount: 3,+ encryption: BackupEncryption.ENCRYPTED,});}loadStorages();@@ -195,6 +196,7 @@ export const EditBackupConfigComponent = ({(Boolean(backupConfig.storePeriod) &&Boolean(backupConfig.storage?.id) &&Boolean(backupConfig.cpuCount) &&+ Boolean(backupConfig.encryption) &&Boolean(backupInterval?.interval) &&(!backupInterval ||((backupInterval.interval !== IntervalType.WEEKLY || displayedWeekday) &&@@ -418,6 +420,27 @@ export const EditBackupConfigComponent = ({)}</div>+ <div className="mb-1 flex w-full items-center">+ <div className="min-w-[150px]">Encryption</div>+ <Select+ value={backupConfig.encryption}+ onChange={(v) => updateBackupConfig({ encryption: v })}+ size="small"+ className="max-w-[200px] grow"+ options={[+ { label: 'None', value: BackupEncryption.NONE },+ { label: 'Encrypt backup files', value: BackupEncryption.ENCRYPTED },+ ]}+ />++ <Tooltip+ className="cursor-pointer"+ title="If backup is encrypted, backup files in your storage (S3, local, etc.) cannot be used directly. You can restore backups through Postgresus or download them unencrypted via the 'Download' button."+ >+ <InfoCircleOutlined className="ml-2" style={{ color: 'gray' }} />+ </Tooltip>+ </div>+{backupConfig.isBackupsEnabled && (<><div className="mt-4 mb-1 flex w-full items-start">diff --git a/frontend/src/features/backups/ui/ShowBackupConfigComponent.tsx b/frontend/src/features/backups/ui/ShowBackupConfigComponent.tsxindex e6db465d..cae59e33 100644--- a/frontend/src/features/backups/ui/ShowBackupConfigComponent.tsx+++ b/frontend/src/features/backups/ui/ShowBackupConfigComponent.tsx@@ -1,8 +1,10 @@+import { InfoCircleOutlined } from '@ant-design/icons';+import { Tooltip } from 'antd';import dayjs from 'dayjs';import { useMemo } from 'react';import { useEffect, useState } from 'react';-import { type BackupConfig, backupConfigApi } from '../../../entity/backups';+import { type BackupConfig, BackupEncryption, backupConfigApi } from '../../../entity/backups';import { BackupNotificationType } from '../../../entity/backups/model/BackupNotificationType';import type { Database } from '../../../entity/databases';import { Period } from '../../../entity/databases/model/Period';@@ -167,6 +169,18 @@ export const ShowBackupConfigComponent = ({ database }: Props) => {</div></div>+ <div className="mb-1 flex w-full items-center">+ <div className="min-w-[150px]">Encryption</div>+ <div>{backupConfig.encryption === BackupEncryption.ENCRYPTED ? 'Enabled' : 'None'}</div>++ <Tooltip+ className="cursor-pointer"+ title="If backup is encrypted, backup files in your storage (S3, local, etc.) cannot be used directly. You can restore backups through Postgresus or download them unencrypted via the 'Download' button."+ >+ <InfoCircleOutlined className="ml-2" style={{ color: 'gray' }} />+ </Tooltip>+ </div>+<div className="mb-1 flex w-full items-center"><div className="min-w-[150px]">Notifications</div><div>