README.md

@@ -111,13 +111,16 @@ W efekcie, jeśli warunek jest spełniony, w katalogu wynikowym działania skryp
 
 ## Obsługa plików szyfrowanych
 
-Od wersji 0.2.1 plik z hasłami (pgpass) musi być zaszyforwany. Szyfrowanie można wykonać następującym poleceniem:
+Od wersji 0.2.0 plik z hasłami (pgpass) musi być zaszyforwany. Szyfrowanie można wykonać następującym poleceniem
 
 ```sh
-multisql encrypt pgpass.sec pgpass
+multisql -P encrypt pgpass.sec pgpass
 ```
 
-Program zapyta o nowe hasło a następnie zaszyfruje treść pliku pgpass i zapisze go do pliku pgpass.sec.
+Jeśli nie jest ustawiona zmienna środowiskowa MULTISQLPASS, to opcja -P powoduje, że program zapyta o hasło
+a następnie zaszyfruje treść pliku pgpass i zapisze go do pliku pgpass.sec.
+
+> Uwaga: plik pgpass.sec zostanie napisany bez pytania.
 
 W konfiguracji należy ustawić plik wartość `"Passfile"` na `pgpass.sec`.
 
@@ -129,10 +132,7 @@ multisql -P decrypt pgpass.sec  # po udanym odszyfrowaniu wyświetli treść pli
 multisql -P decryp pgpass.sec newpgpass # w tym wariancie odszyfrowana treść zostanie zapisana do newpgpass
 ```
 
-Opcja `-P` powoduje, że program pyta o hasło. Jeśli nie podano tej opcji, program
+Żeby nie podawać hasła z klawiatury, należy ustawić je w zmiennej środowiskowej:
-próbuje użyć hasła ustawionego w zmiennej środowiskowej `MULTISQLPASS`.
-
-Zmienną można ustawić w następujący sposób:
 
 Linux:
 
@@ -152,9 +152,6 @@ Windows, powershell:
 $env:MULTISQLPASS = "abc"
 ```
 
-Użycie opcji `-P` powoduje, że zmienna środowiskowa jest ignorowana i hasło pobierane jest z klawiatury.
+Program nigdy nie pyta o hasła, jeśli wczytał je ze zmiennej środowiskowej.
-
+Jeśli nie podano hasła w zmiennej i nie podano
-> Uwaga: Od wersji 0.2.3 wykorzystywany jest format szyfrowania
+opcji `-P`, to program przerwie działanie.
-> [age-encryption](https://age-encryption.org/).
-> Plik haseł można więc szyfrować i deszyftować również narzędziem
-> `age` (https://github.com/FiloSottile/age/releases/tag/v1.0.0)

cfg/params.go

@@ -66,7 +66,7 @@ Użycie:
 		multisql -outdir /tmp -sqldir /data/skrypty -passfile ./hasla
 
 Użycie w trybie szyfrowania:
-		multisql encrypt plik.wynikowy.zaszyfrowany plik.zródłowy
+		multisql [-P] encrypt plik.wynikowy.zaszyfrowany plik.zródłowy
 	lub
 		multisql [-P] decrypt plik.źródłowy.zaszyfrowany [plik.wynikowy.jawny]
 
@@ -129,8 +129,7 @@ plik zaszyfrować:
 
     multsql encrypt pgpass.encrypted  pgpass
 
-Przy użyciu (odszyfrowaniu) pliku, hasło jest pobierane ze zmiennej
+Hasło jest pobierane ze zmiennej środowiskowej %s lub z klawiatury, jeśli użyto opcji -P.
-środowiskowej %s lub z klawiatury, jeśli użyto opcji -P.
 
 `, MULTISQLPASS)
 

cmd/multisql/multisql.go

@@ -72,6 +72,8 @@ func main() {
 }
 
 func encryption(args []string, params cfg.Parameters) {
+	password := pass.GetMasterPass(params.AskPass)
+
 	switch strings.ToLower(args[0]) {
 	case "encrypt":
 		if len(args) < 3 {
@@ -82,12 +84,8 @@ func encryption(args []string, params cfg.Parameters) {
 		if err != nil {
 			log.Fatalf("Błąd odczytu pliku: %v", err)
 		}
-
-		password := pass.EnterMasterPass()
-
 		err = pass.EncryptFile(password, args[1], plain)
 		if err != nil {
-			_ = os.Remove(args[1]) // jeśli błąd to usuń plik
 			log.Fatalf("Błąd szyfrowania pliku: %v", err)
 		}
 	case "decrypt":
@@ -95,8 +93,6 @@ func encryption(args []string, params cfg.Parameters) {
 			log.Fatal("decryp wymaga podania pliku zaszyfrowanego")
 			return
 		}
-		password := pass.GetMasterPass(params.AskPass)
-
 		data, err := pass.DecryptFile(password, args[1])
 		if err !=nil {
 			log.Fatalf("Błąd deszyfrowania pliku: %v", err)

go.mod

@@ -2,12 +2,4 @@ module baal.ar76.eu/x/pub/multisql
 
 go 1.19
 
-require (
+require golang.org/x/crypto v0.3.0 // indirect
-	filippo.io/age v1.0.0
-	golang.org/x/term v0.2.0
-)
-
-require (
-	golang.org/x/crypto v0.3.0 // indirect
-	golang.org/x/sys v0.2.0 // indirect
-)

go.sum

@@ -1,8 +1,2 @@
-filippo.io/age v1.0.0 h1:V6q14n0mqYU3qKFkZ6oOaF9oXneOviS3ubXsSVBRSzc=
-filippo.io/age v1.0.0/go.mod h1:PaX+Si/Sd5G8LgfCwldsSba3H1DDQZhIhFGkhbHaBq8=
 golang.org/x/crypto v0.3.0 h1:a06MkbcxBrEFc0w0QIZWXrH/9cCX6KJyWbBOIwAn+7A=
 golang.org/x/crypto v0.3.0/go.mod h1:hebNnKkNXi2UzZN1eVRvBB7co0a+JxK6XbPiWVs/3J4=
-golang.org/x/sys v0.2.0 h1:ljd4t30dBnAvMZaQCevtY0xLLD0A+bRZXbgLMLU1F/A=
-golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.2.0 h1:z85xZCsEl7bi/KwbNADeBYoOP0++7W1ipu+aGnpwzRM=
-golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc=

pass/crypt.go

@@ -1,65 +1,124 @@
 package pass
 
 import (
-	"bytes"
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/rand"
 	"fmt"
-	"io"
+	"log"
 	"os"
 
-	"filippo.io/age"
+	"baal.ar76.eu/x/pub/multisql/cfg"
-	"filippo.io/age/armor"
+	"golang.org/x/crypto/scrypt"
 )
 
-func DecryptFile(password []byte, file string) ([]byte, error) {
+func DeriveKey(password, salt []byte) ([]byte, []byte, error) {
-	identity, err := age.NewScryptIdentity(string(password))
+	if salt == nil {
-	if err != nil {
+		salt = make([]byte, 32)
-		return nil, fmt.Errorf("błąd przetwarzania hasła: %w", err)
+		if _, err := rand.Read(salt); err != nil {
+			return nil, nil, err
 		}
-	fd, err := os.Open(file)
-	if err != nil {
-		return nil, fmt.Errorf("błąd otwarcia pliku: %w", err)
-	}
-	defer fd.Close()
-
-	in := armor.NewReader(fd)
-
-	r, err := age.Decrypt(in, identity)
-	if err != nil {
-		return nil, fmt.Errorf("błąd deszyfrowania #01: %w", err)
 	}
 
-	out := &bytes.Buffer{}
+	key, err := scrypt.Key(password, salt, 32768, 8, 1, 32)
-	if _, err := io.Copy(out, r); err != nil {
+	if err != nil {
-		return nil, fmt.Errorf("błąd deszyfrowania #02: %v", err)
+		return nil, nil, fmt.Errorf("błąd generowania klucza: %w", err)
 	}
-	return out.Bytes(), nil
+
+	return key, salt, nil
 }
 
-func EncryptFile(password []byte, file string, data []byte) error {
+func Encrypt(key, data []byte) ([]byte, error) {
-	recipient, err := age.NewScryptRecipient(string(password))
+	blockCipher, err := aes.NewCipher(key)
 	if err != nil {
-		return fmt.Errorf("błąd przetwarzania hasła: %w", err)
+		return nil, err
 	}
-	fd, err := os.OpenFile(file, os.O_WRONLY | os.O_CREATE | os.O_EXCL, 0o600)
-	if err != nil {
-		return fmt.Errorf("błąd tworzenia pliku: %w", err)
-	}
-	defer fd.Close()
 
-	out := armor.NewWriter(fd) // armor
+	gcm, err := cipher.NewGCM(blockCipher)
-	defer out.Close()
+	if err != nil {
+		return nil, err
+	}
 
-	w, err := age.Encrypt(out, recipient)
+	nonce := make([]byte, gcm.NonceSize())
-	if err != nil {
+	if _, err = rand.Read(nonce); err != nil {
-		return fmt.Errorf("błąd szyfrowania #01: %w", err)
+		return nil, err
 	}
-	_, err = w.Write(data)
+
-	if err != nil {
+	ciphertext := gcm.Seal(nonce, nonce, data, nil)
-		return fmt.Errorf("błąd szyfrowania #02: %w", err)
+
-	}
+	return ciphertext, nil
-	err = w.Close()
+}
-	if err != nil {
+
-		return fmt.Errorf("błąd szyfrowania #03: %w", err)
+func Decrypt(key, data []byte) ([]byte, error) {
-	}
+	blockCipher, err := aes.NewCipher(key)
-	return nil
+	if err != nil {
+		return nil, err
+	}
+
+	gcm, err := cipher.NewGCM(blockCipher)
+	if err != nil {
+		return nil, err
+	}
+
+	nonce, ciphertext := data[:gcm.NonceSize()], data[gcm.NonceSize():]
+
+	plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return plaintext, nil
+}
+
+func DecryptFile(password, file string) ([]byte, error) {
+	data, err := os.ReadFile(file)
+	if err != nil {
+		return nil, err
+	}
+	salt := data[:32] //
+	data = data[32:]
+	key, _, err := DeriveKey([]byte(password), salt)
+	if err != nil {
+		return nil, err
+	}
+	return Decrypt(key, data)
+}
+
+func EncryptFile(password, file string, data []byte) error {
+	key, salt, err := DeriveKey([]byte(password), nil)
+	if err != nil {
+		return err
+	}
+	encrypted, err := Encrypt(key, data)
+	if err != nil {
+		return err
+	}
+	fd, err := os.Create(file)
+	if err != nil {
+		return err
+	}
+	_, err = fd.Write(salt)
+	if err != nil {
+		return err
+	}
+	_, err = fd.Write(encrypted)
+	if err != nil {
+		return err
+	}
+	return fd.Close()
+}
+
+func GetMasterPass(askPass bool) string {
+	password := os.Getenv(cfg.MULTISQLPASS)
+	if password == "" {
+		if !askPass {
+			log.Fatalf("Nieustalone hasło. Użyj flagi -P lub ustaw hasło w zmiennej %s", cfg.MULTISQLPASS)
+		}
+		fmt.Fprintf(os.Stderr, "Podaj hasło: ")
+		n, e := fmt.Scanln(&password)
+		if n == 0 || e != nil {
+			log.Fatalln("Nie udało się wczytać hasła z konsoli")
+		}
+	}
+	return password
 }

pass/pass.go

@@ -18,7 +18,7 @@ type PassDb struct {
 	cache map[string]*pgpassrow
 }
 
-func Load(file string, master []byte) (*PassDb, error) {
+func Load(file string, master string) (*PassDb, error) {
 
 	data, err := DecryptFile(master, file)
 	if err != nil {

pass/term.go

@@ -1,55 +0,0 @@
-package pass
-
-import (
-	"bytes"
-	"fmt"
-	"log"
-	"os"
-
-	"baal.ar76.eu/x/pub/multisql/cfg"
-	"golang.org/x/term"
-)
-
-func GetMasterPass(askPass bool) []byte {
-	if askPass {
-		res, err := termGetPassword("Podaj hasło")
-		if err != nil {
-			log.Fatalln("Nie udało się wczytać hasła z konsoli")
-		}
-		return res
-	}
-	password := os.Getenv(cfg.MULTISQLPASS)
-
-	if password != "" {
-		return []byte(password)
-	}
-
-	log.Fatalf("Nieustalone hasło. Użyj flagi -P lub ustaw hasło w zmiennej %s", cfg.MULTISQLPASS)
-	return nil
-}
-
-func EnterMasterPass() []byte {
-	p1, err := termGetPassword("Podaj nowe hasło (min 8 znaków)")
-	if err != nil {
-		log.Fatalf("Błąd wczytywania hasła: %v", err)
-	}
-	if len(p1) < 8 {
-		log.Fatalf("podano zbyt krótkie hasło")
-	}
-	p2, err := termGetPassword("Powtórz nowe hasło")
-	if err != nil {
-		log.Fatalf("Błąd wczytywania hasła: %v", err)
-	}
-	if !bytes.Equal(p1, p2) {
-		log.Fatalf("podane hasła są różne")
-	}
-
-	return p1
-}
-
-func termGetPassword(prompt string) ([]byte, error) {
-	fmt.Fprintf(os.Stderr, "%s: ", prompt)
-	passwd, err := term.ReadPassword(int(os.Stdin.Fd()))
-	fmt.Fprintln(os.Stderr)
-	return passwd, err
-}