jason/cpolis
1
0
Fork 1
Code Issues Pull Requests 1 Packages Projects Releases 56 Wiki Activity

feature/better-error-handling #1

Closed
jonathan wants to merge 2 commits from jonathan/cpolis:feature/better-error-handling into main
pull from: jonathan/cpolis:feature/better-error-handling
merge into: jason:main
Conversation 1 Commits 2 Files Changed 2 +121 -28
1 changed files with 121 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit ffc4f4580d - Show all commits

149
cmd/backend/users.go
View File

@ -37,15 +37,19 @@ type User struct {
func readKey(filename string) ([]byte, error) { func readKey(filename string) ([]byte, error) {
key, err := os.ReadFile(filename) key, err := os.ReadFile(filename)
if err != nil { if err != nil {
log.Printf("Fehler beim Lesen der AES-Schlüsseldatei '%s': %v", filename, err)
return nil, fmt.Errorf("error reading from aes key file: %v", err) return nil, fmt.Errorf("error reading from aes key file: %v", err)
} }
if len(key) != 44 { if len(key) != 44 {
return nil, errors.New("key is not 32 bytes long") errMsg := "key is not 32 bytes long"
log.Println(errMsg)
return nil, errors.New(errMsg)
} }
key, err = base64.StdEncoding.DecodeString(string(key)) key, err = base64.StdEncoding.DecodeString(string(key))
if err != nil { if err != nil {
log.Printf("Fehler beim Base64-Dekodieren des Schlüssels: %v", err)
return nil, fmt.Errorf("error base64 decoding key: %v", err) return nil, fmt.Errorf("error base64 decoding key: %v", err)
} }
@ -55,14 +59,17 @@ func readKey(filename string) ([]byte, error) {
func key(c *Config) ([]byte, error) { func key(c *Config) ([]byte, error) {
key, err := readKey(c.AESKeyFile) key, err := readKey(c.AESKeyFile)
if err != nil { if err != nil {
log.Printf("Fehler beim Lesen des Schlüssels: %v", err)
key = make([]byte, 32) key = make([]byte, 32)
if _, err := rand.Read(key); err != nil { if _, err := rand.Read(key); err != nil {
log.Printf("Fehler beim Generieren eines zufälligen Schlüssels: %v", err)
return nil, fmt.Errorf("error generating random key: %v", err) return nil, fmt.Errorf("error generating random key: %v", err)
} }
fileKey := make([]byte, 44) fileKey := make([]byte, 44)
base64.StdEncoding.Encode(fileKey, key) base64.StdEncoding.Encode(fileKey, key)
if err = os.WriteFile(c.AESKeyFile, fileKey, 0600); err != nil { if err = os.WriteFile(c.AESKeyFile, fileKey, 0600); err != nil {
log.Printf("Fehler beim Schreiben des Schlüssels in die Datei '%s': %v", c.AESKeyFile, err)
return nil, fmt.Errorf("error writing key to file: %v", err) return nil, fmt.Errorf("error writing key to file: %v", err)
} }
} }
@ -73,21 +80,25 @@ func key(c *Config) ([]byte, error) {
func aesEncrypt(c *Config, plaintext string) (string, error) { func aesEncrypt(c *Config, plaintext string) (string, error) {
key, err := key(c) key, err := key(c)
if err != nil { if err != nil {
log.Printf("Fehler beim Abrufen des Schlüssels: %v", err)
return "", fmt.Errorf("error retrieving key: %v", err) return "", fmt.Errorf("error retrieving key: %v", err)
} }
block, err := aes.NewCipher(key) block, err := aes.NewCipher(key)
if err != nil { if err != nil {
log.Printf("Fehler beim Erstellen des Cipher Blocks: %v", err)
return "", fmt.Errorf("error creating cipher block: %v", err) return "", fmt.Errorf("error creating cipher block: %v", err)
} }
gcm, err := cipher.NewGCM(block) gcm, err := cipher.NewGCM(block)
if err != nil { if err != nil {
log.Printf("Fehler beim Erstellen von GCM: %v", err)
return "", fmt.Errorf("error creating new gcm: %v", err) return "", fmt.Errorf("error creating new gcm: %v", err)
} }
nonce := make([]byte, gcm.NonceSize()) nonce := make([]byte, gcm.NonceSize())
if _, err := io.ReadFull(rand.Reader, nonce); err != nil { if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
log.Printf("Fehler beim Erstellen des Nonce: %v", err)
return "", fmt.Errorf("error creating nonce: %v", err) return "", fmt.Errorf("error creating nonce: %v", err)
} }
@ -98,29 +109,39 @@ func aesEncrypt(c *Config, plaintext string) (string, error) {
func aesDecrypt(c *Config, ciphertext string) (string, error) { func aesDecrypt(c *Config, ciphertext string) (string, error) {
key, err := key(c) key, err := key(c)
if err != nil { if err != nil {
log.Printf("Fehler beim Abrufen des Schlüssels: %v", err)
return "", fmt.Errorf("error retrieving key: %v", err) return "", fmt.Errorf("error retrieving key: %v", err)
} }
block, err := aes.NewCipher(key) block, err := aes.NewCipher(key)
if err != nil { if err != nil {
log.Printf("Fehler beim Erstellen des Cipher Blocks: %v", err)
return "", fmt.Errorf("error creating cipher block: %v", err) return "", fmt.Errorf("error creating cipher block: %v", err)
} }
gcm, err := cipher.NewGCM(block) gcm, err := cipher.NewGCM(block)
if err != nil { if err != nil {
log.Printf("Fehler beim Erstellen von GCM: %v", err)
return "", fmt.Errorf("error creating new gcm: %v", err) return "", fmt.Errorf("error creating new gcm: %v", err)
} }
data, err := base64.StdEncoding.DecodeString(ciphertext) data, err := base64.StdEncoding.DecodeString(ciphertext)
if err != nil { if err != nil {
log.Printf("Fehler beim Base64-Dekodieren des Ciphertexts: %v", err)
return "", fmt.Errorf("error base64 decoding ciphertext: %v", err) return "", fmt.Errorf("error base64 decoding ciphertext: %v", err)
} }
nonceSize := gcm.NonceSize() nonceSize := gcm.NonceSize()
if len(data) < nonceSize {
errMsg := "ciphertext too short"
log.Println(errMsg)
return "", fmt.Errorf(errMsg)
}
nonce, cipherText := data[:nonceSize], data[nonceSize:] nonce, cipherText := data[:nonceSize], data[nonceSize:]
plaintext, err := gcm.Open(nil, nonce, cipherText, nil) plaintext, err := gcm.Open(nil, nonce, cipherText, nil)
if err != nil { if err != nil {
log.Printf("Fehler beim AES-Dekodieren des Ciphertexts: %v", err)
return "", fmt.Errorf("error aes decoding ciphertext: %v", err) return "", fmt.Errorf("error aes decoding ciphertext: %v", err)
} }
@ -130,21 +151,25 @@ func aesDecrypt(c *Config, ciphertext string) (string, error) {
func (db *DB) AddUser(c *Config, u *User, pass string) (int64, error) { func (db *DB) AddUser(c *Config, u *User, pass string) (int64, error) {
hashedPass, err := bcrypt.GenerateFromPassword([]byte(pass), bcrypt.DefaultCost) hashedPass, err := bcrypt.GenerateFromPassword([]byte(pass), bcrypt.DefaultCost)
if err != nil { if err != nil {
log.Printf("Fehler beim Erstellen des Passwort-Hashes: %v", err)
return 0, fmt.Errorf("error creating password hash: %v", err) return 0, fmt.Errorf("error creating password hash: %v", err)
} }
aesFirstName, err := aesEncrypt(c, u.FirstName) aesFirstName, err := aesEncrypt(c, u.FirstName)
if err != nil { if err != nil {
log.Printf("Fehler beim Verschlüsseln des Vornamens: %v", err)
return 0, fmt.Errorf("error encrypting first name: %v", err) return 0, fmt.Errorf("error encrypting first name: %v", err)
} }
aesLastName, err := aesEncrypt(c, u.LastName) aesLastName, err := aesEncrypt(c, u.LastName)
if err != nil { if err != nil {
log.Printf("Fehler beim Verschlüsseln des Nachnamens: %v", err)
return 0, fmt.Errorf("error encrypting last name: %v", err) return 0, fmt.Errorf("error encrypting last name: %v", err)
} }
aesEmail, err := aesEncrypt(c, u.Email) aesEmail, err := aesEncrypt(c, u.Email)
if err != nil { if err != nil {
log.Printf("Fehler beim Verschlüsseln der E-Mail: %v", err)
return 0, fmt.Errorf("error encrypting email: %v", err) return 0, fmt.Errorf("error encrypting email: %v", err)
} }
@ -155,10 +180,12 @@ func (db *DB) AddUser(c *Config, u *User, pass string) (int64, error) {
result, err := db.Exec(query, u.UserName, string(hashedPass), aesFirstName, aesLastName, aesEmail, u.ProfilePicLink, u.Role) result, err := db.Exec(query, u.UserName, string(hashedPass), aesFirstName, aesLastName, aesEmail, u.ProfilePicLink, u.Role)
if err != nil { if err != nil {
log.Printf("Fehler beim Einfügen des neuen Benutzers '%v' in die DB: %v", u.UserName, err)
return 0, fmt.Errorf("error inserting new user %v into DB: %v", u.UserName, err) return 0, fmt.Errorf("error inserting new user %v into DB: %v", u.UserName, err)
} }
id, err := result.LastInsertId() id, err := result.LastInsertId()
if err != nil { if err != nil {
log.Printf("Fehler beim Abrufen der letzten Insert-ID: %v", err)
return 0, fmt.Errorf("error inserting user into DB: %v", err) return 0, fmt.Errorf("error inserting user into DB: %v", err)
} }
@ -175,6 +202,7 @@ func (db *DB) GetID(userName string) int64 {
` `
row := db.QueryRow(query, userName) row := db.QueryRow(query, userName)
if err := row.Scan(&id); err != nil { // seems like the only possible error is ErrNoRows if err := row.Scan(&id); err != nil { // seems like the only possible error is ErrNoRows
log.Printf("Fehler beim Abrufen der ID für Benutzer '%v': %v", userName, err)
return 0 return 0
} }
@ -191,10 +219,12 @@ func (db *DB) CheckPassword(id int64, pass string) error {
` `
row := db.QueryRow(query, id) row := db.QueryRow(query, id)
if err := row.Scan(&queriedPass); err != nil { if err := row.Scan(&queriedPass); err != nil {
log.Printf("Fehler beim Lesen des Passworts aus der DB für ID '%v': %v", id, err)
return fmt.Errorf("error reading password from DB: %v", err) return fmt.Errorf("error reading password from DB: %v", err)
} }
if err := bcrypt.CompareHashAndPassword([]byte(queriedPass), []byte(pass)); err != nil { if err := bcrypt.CompareHashAndPassword([]byte(queriedPass), []byte(pass)); err != nil {
log.Printf("Falsches Passwort für ID '%v': %v", id, err)
return fmt.Errorf("incorrect password: %v", err) return fmt.Errorf("incorrect password: %v", err)
} }
@ -210,23 +240,26 @@ func (tx *Tx) ChangePassword(id int64, oldPass, newPass string) error {
` `
row := tx.QueryRow(getQuery, id) row := tx.QueryRow(getQuery, id)
if err := row.Scan(&queriedPass); err != nil { if err := row.Scan(&queriedPass); err != nil {
log.Printf("Fehler beim Lesen des Passworts aus der DB während der Passwortänderung für ID '%v': %v", id, err)
if rollbackErr := tx.Rollback(); rollbackErr != nil { if rollbackErr := tx.Rollback(); rollbackErr != nil {
log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr) log.Fatalf("Transaktionsfehler: %v, Rollback-Fehler: %v", err, rollbackErr)
} }
return fmt.Errorf("error reading password from DB: %v", err) return fmt.Errorf("error reading password from DB: %v", err)
} }
if err := bcrypt.CompareHashAndPassword([]byte(queriedPass), []byte(oldPass)); err != nil { if err := bcrypt.CompareHashAndPassword([]byte(queriedPass), []byte(oldPass)); err != nil {
log.Printf("Falsches altes Passwort für ID '%v': %v", id, err)
if rollbackErr := tx.Rollback(); rollbackErr != nil { if rollbackErr := tx.Rollback(); rollbackErr != nil {
log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr) log.Fatalf("Transaktionsfehler: %v, Rollback-Fehler: %v", err, rollbackErr)
} }
return fmt.Errorf("incorrect password: %v", err) return fmt.Errorf("incorrect password: %v", err)
} }
newHashedPass, err := bcrypt.GenerateFromPassword([]byte(newPass), bcrypt.DefaultCost) newHashedPass, err := bcrypt.GenerateFromPassword([]byte(newPass), bcrypt.DefaultCost)
if err != nil { if err != nil {
log.Printf("Fehler beim Erstellen des neuen Passwort-Hashes für ID '%v': %v", id, err)
if rollbackErr := tx.Rollback(); rollbackErr != nil { if rollbackErr := tx.Rollback(); rollbackErr != nil {
log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr) log.Fatalf("Transaktionsfehler: %v, Rollback-Fehler: %v", err, rollbackErr)
} }
return fmt.Errorf("error creating password hash: %v", err) return fmt.Errorf("error creating password hash: %v", err)
} }
@ -237,8 +270,9 @@ func (tx *Tx) ChangePassword(id int64, oldPass, newPass string) error {
WHERE id = ? WHERE id = ?
` `
if _, err = tx.Exec(setQuery, string(newHashedPass), id); err != nil { if _, err = tx.Exec(setQuery, string(newHashedPass), id); err != nil {
log.Printf("Fehler beim Aktualisieren des Passworts in der DB für ID '%v': %v", id, err)
if rollbackErr := tx.Rollback(); rollbackErr != nil { if rollbackErr := tx.Rollback(); rollbackErr != nil {
log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr) log.Fatalf("Transaktionsfehler: %v, Rollback-Fehler: %v", err, rollbackErr)
} }
return fmt.Errorf("error updating password in DB: %v", err) return fmt.Errorf("error updating password in DB: %v", err)
} }
@ -260,21 +294,25 @@ func (db *DB) GetUser(c *Config, id int64) (*User, error) {
row := db.QueryRow(query, id) row := db.QueryRow(query, id)
if err := row.Scan(&user.ID, &user.UserName, &aesFirstName, &aesLastName, &aesEmail, &user.ProfilePicLink, &user.Role); err != nil { if err := row.Scan(&user.ID, &user.UserName, &aesFirstName, &aesLastName, &aesEmail, &user.ProfilePicLink, &user.Role); err != nil {
log.Printf("Fehler beim Lesen der Benutzerinformationen aus der DB für ID '%v': %v", id, err)
return nil, fmt.Errorf("error reading user information: %v", err) return nil, fmt.Errorf("error reading user information: %v", err)
} }
user.FirstName, err = aesDecrypt(c, aesFirstName) user.FirstName, err = aesDecrypt(c, aesFirstName)
if err != nil { if err != nil {
log.Printf("Fehler beim Entschlüsseln des Vornamens für ID '%v': %v", id, err)
return nil, fmt.Errorf("error decrypting first name: %v", err) return nil, fmt.Errorf("error decrypting first name: %v", err)
} }
user.LastName, err = aesDecrypt(c, aesLastName) user.LastName, err = aesDecrypt(c, aesLastName)
if err != nil { if err != nil {
log.Printf("Fehler beim Entschlüsseln des Nachnamens für ID '%v': %v", id, err)
return nil, fmt.Errorf("error decrypting last name: %v", err) return nil, fmt.Errorf("error decrypting last name: %v", err)
} }
user.Email, err = aesDecrypt(c, aesEmail) user.Email, err = aesDecrypt(c, aesEmail)
if err != nil { if err != nil {
log.Printf("Fehler beim Entschlüsseln der E-Mail für ID '%v': %v", id, err)
return nil, fmt.Errorf("error decrypting email: %v", err) return nil, fmt.Errorf("error decrypting email: %v", err)
} }
@ -290,13 +328,15 @@ func (db *DB) UpdateOwnUserAttributes(c *Config, id int64, userName, firstName,
err := func() error { err := func() error {
tx.Tx, err = db.Begin() tx.Tx, err = db.Begin()
if err != nil { if err != nil {
log.Printf("Fehler beim Starten der Transaktion: %v", err)
return fmt.Errorf("error starting transaction: %v", err) return fmt.Errorf("error starting transaction: %v", err)
} }
if !passwordEmpty { if !passwordEmpty {
if err = tx.ChangePassword(id, oldPass, newPass); err != nil { if err = tx.ChangePassword(id, oldPass, newPass); err != nil {
log.Printf("Fehler beim Ändern des Passworts für ID '%v': %v", id, err)
if rollbackErr := tx.Rollback(); rollbackErr != nil { if rollbackErr := tx.Rollback(); rollbackErr != nil {
log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr) log.Fatalf("Transaktionsfehler: %v, Rollback-Fehler: %v", err, rollbackErr)
} }
return fmt.Errorf("error changing password: %v", err) return fmt.Errorf("error changing password: %v", err)
} }
@ -304,24 +344,27 @@ func (db *DB) UpdateOwnUserAttributes(c *Config, id int64, userName, firstName,
aesFirstName, err := aesEncrypt(c, firstName) aesFirstName, err := aesEncrypt(c, firstName)
if err != nil { if err != nil {
log.Printf("Fehler beim Verschlüsseln des Vornamens für ID '%v': %v", id, err)
if rollbackErr := tx.Rollback(); rollbackErr != nil { if rollbackErr := tx.Rollback(); rollbackErr != nil {
log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr) log.Fatalf("Transaktionsfehler: %v, Rollback-Fehler: %v", err, rollbackErr)
} }
return fmt.Errorf("error encrypting first name: %v", err) return fmt.Errorf("error encrypting first name: %v", err)
} }
aesLastName, err := aesEncrypt(c, lastName) aesLastName, err := aesEncrypt(c, lastName)
if err != nil { if err != nil {
log.Printf("Fehler beim Verschlüsseln des Nachnamens für ID '%v': %v", id, err)
if rollbackErr := tx.Rollback(); rollbackErr != nil { if rollbackErr := tx.Rollback(); rollbackErr != nil {
log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr) log.Fatalf("Transaktionsfehler: %v, Rollback-Fehler: %v", err, rollbackErr)
} }
return fmt.Errorf("error encrypting last name: %v", err) return fmt.Errorf("error encrypting last name: %v", err)
} }
aesEmail, err := aesEncrypt(c, email) aesEmail, err := aesEncrypt(c, email)
if err != nil { if err != nil {
log.Printf("Fehler beim Verschlüsseln der E-Mail für ID '%v': %v", id, err)
if rollbackErr := tx.Rollback(); rollbackErr != nil { if rollbackErr := tx.Rollback(); rollbackErr != nil {
log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr) log.Fatalf("Transaktionsfehler: %v, Rollback-Fehler: %v", err, rollbackErr)
} }
return fmt.Errorf("error encrypting email: %v", err) return fmt.Errorf("error encrypting email: %v", err)
} }
@ -333,13 +376,15 @@ func (db *DB) UpdateOwnUserAttributes(c *Config, id int64, userName, firstName,
&Attribute{Table: "users", ID: id, AttName: "email", Value: aesEmail}, &Attribute{Table: "users", ID: id, AttName: "email", Value: aesEmail},
&Attribute{Table: "users", ID: id, AttName: "profile_pic_link", Value: profilePicLink}, &Attribute{Table: "users", ID: id, AttName: "profile_pic_link", Value: profilePicLink},
); err != nil { ); err != nil {
log.Printf("Fehler beim Aktualisieren der Attribute in der DB für ID '%v': %v", id, err)
if rollbackErr := tx.Rollback(); rollbackErr != nil { if rollbackErr := tx.Rollback(); rollbackErr != nil {
log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr) log.Fatalf("Transaktionsfehler: %v, Rollback-Fehler: %v", err, rollbackErr)
} }
return fmt.Errorf("error updating attributes in DB: %v", err) return fmt.Errorf("error updating attributes in DB: %v", err)
} }
if err = tx.Commit(); err != nil { if err = tx.Commit(); err != nil {
log.Printf("Fehler beim Commit der Transaktion für ID '%v': %v", id, err)
return fmt.Errorf("error committing transaction: %v", err) return fmt.Errorf("error committing transaction: %v", err)
} }
@ -353,7 +398,9 @@ func (db *DB) UpdateOwnUserAttributes(c *Config, id int64, userName, firstName,
wait(i) wait(i)
} }
return fmt.Errorf("error: %v unsuccessful retries for DB operation, aborting", TxMaxRetries) errMsg := fmt.Sprintf("error: %v unsuccessful retries for DB operation, aborting", TxMaxRetries)
log.Println(errMsg)
return fmt.Errorf(errMsg)
} }
func (db *DB) AddFirstUser(c *Config, u *User, pass string) (int64, error) { func (db *DB) AddFirstUser(c *Config, u *User, pass string) (int64, error) {
@ -369,17 +416,20 @@ func (db *DB) AddFirstUser(c *Config, u *User, pass string) (int64, error) {
id, err := func() (int64, error) { id, err := func() (int64, error) {
tx, err := db.BeginTx(context.Background(), txOptions) tx, err := db.BeginTx(context.Background(), txOptions)
if err != nil { if err != nil {
log.Printf("Fehler beim Starten der Transaktion: %v", err)
return 0, fmt.Errorf("error starting transaction: %v", err) return 0, fmt.Errorf("error starting transaction: %v", err)
} }
if err := tx.QueryRow(selectQuery).Scan(&numUsers); err != nil { if err := tx.QueryRow(selectQuery).Scan(&numUsers); err != nil {
log.Printf("Fehler beim Abrufen der Anzahl der Benutzer: %v", err)
if rollbackErr := tx.Rollback(); rollbackErr != nil { if rollbackErr := tx.Rollback(); rollbackErr != nil {
log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr) log.Fatalf("Transaktionsfehler: %v, Rollback-Fehler: %v", err, rollbackErr)
} }
return 0, fmt.Errorf("error getting ID of %v: %v", u.UserName, err) return 0, fmt.Errorf("error getting ID of %v: %v", u.UserName, err)
} }
if numUsers != 0 { if numUsers != 0 {
if err = tx.Commit(); err != nil { if err = tx.Commit(); err != nil {
log.Printf("Fehler beim Commit der Transaktion: %v", err)
return 0, fmt.Errorf("error committing transaction: %v", err) return 0, fmt.Errorf("error committing transaction: %v", err)
} }
return -1, nil return -1, nil
@ -387,53 +437,60 @@ func (db *DB) AddFirstUser(c *Config, u *User, pass string) (int64, error) {
hashedPass, err := bcrypt.GenerateFromPassword([]byte(pass), bcrypt.DefaultCost) hashedPass, err := bcrypt.GenerateFromPassword([]byte(pass), bcrypt.DefaultCost)
if err != nil { if err != nil {
log.Printf("Fehler beim Erstellen des Passwort-Hashes: %v", err)
if rollbackErr := tx.Rollback(); rollbackErr != nil { if rollbackErr := tx.Rollback(); rollbackErr != nil {
log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr) log.Fatalf("Transaktionsfehler: %v, Rollback-Fehler: %v", err, rollbackErr)
} }
return 0, fmt.Errorf("error creating password hash: %v", err) return 0, fmt.Errorf("error creating password hash: %v", err)
} }
aesFirstName, err := aesEncrypt(c, u.FirstName) aesFirstName, err := aesEncrypt(c, u.FirstName)
if err != nil { if err != nil {
log.Printf("Fehler beim Verschlüsseln des Vornamens: %v", err)
if rollbackErr := tx.Rollback(); rollbackErr != nil { if rollbackErr := tx.Rollback(); rollbackErr != nil {
log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr) log.Fatalf("Transaktionsfehler: %v, Rollback-Fehler: %v", err, rollbackErr)
} }
return 0, fmt.Errorf("error encrypting first name: %v", err) return 0, fmt.Errorf("error encrypting first name: %v", err)
} }
aesLastName, err := aesEncrypt(c, u.LastName) aesLastName, err := aesEncrypt(c, u.LastName)
if err != nil { if err != nil {
log.Printf("Fehler beim Verschlüsseln des Nachnamens: %v", err)
if rollbackErr := tx.Rollback(); rollbackErr != nil { if rollbackErr := tx.Rollback(); rollbackErr != nil {
log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr) log.Fatalf("Transaktionsfehler: %v, Rollback-Fehler: %v", err, rollbackErr)
} }
return 0, fmt.Errorf("error encrypting last name: %v", err) return 0, fmt.Errorf("error encrypting last name: %v", err)
} }
aesEmail, err := aesEncrypt(c, u.Email) aesEmail, err := aesEncrypt(c, u.Email)
if err != nil { if err != nil {
log.Printf("Fehler beim Verschlüsseln der E-Mail: %v", err)
if rollbackErr := tx.Rollback(); rollbackErr != nil { if rollbackErr := tx.Rollback(); rollbackErr != nil {
log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr) log.Fatalf("Transaktionsfehler: %v, Rollback-Fehler: %v", err, rollbackErr)
} }
return 0, fmt.Errorf("error encrypting email: %v", err) return 0, fmt.Errorf("error encrypting email: %v", err)
} }
result, err := tx.Exec(insertQuery, u.UserName, string(hashedPass), aesFirstName, aesLastName, aesEmail, u.ProfilePicLink, u.Role) result, err := tx.Exec(insertQuery, u.UserName, string(hashedPass), aesFirstName, aesLastName, aesEmail, u.ProfilePicLink, u.Role)
if err != nil { if err != nil {
log.Printf("Fehler beim Einfügen des neuen Benutzers '%v' in die DB: %v", u.UserName, err)
if rollbackErr := tx.Rollback(); rollbackErr != nil { if rollbackErr := tx.Rollback(); rollbackErr != nil {
log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr) log.Fatalf("Transaktionsfehler: %v, Rollback-Fehler: %v", err, rollbackErr)
} }
return 0, fmt.Errorf("error inserting new user %v into DB: %v", u.UserName, err) return 0, fmt.Errorf("error inserting new user %v into DB: %v", u.UserName, err)
} }
id, err := result.LastInsertId() id, err := result.LastInsertId()
if err != nil { if err != nil {
log.Printf("Fehler beim Abrufen der letzten Insert-ID: %v", err)
if rollbackErr := tx.Rollback(); rollbackErr != nil { if rollbackErr := tx.Rollback(); rollbackErr != nil {
log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr) log.Fatalf("Transaktionsfehler: %v, Rollback-Fehler: %v", err, rollbackErr)
} }
return 0, fmt.Errorf("error inserting user into DB: %v", err) return 0, fmt.Errorf("error inserting user into DB: %v", err)
} }
if err = tx.Commit(); err != nil { if err = tx.Commit(); err != nil {
log.Printf("Fehler beim Commit der Transaktion: %v", err)
return 0, fmt.Errorf("error committing transaction: %v", err) return 0, fmt.Errorf("error committing transaction: %v", err)
} }
return id, nil return id, nil
@ -445,7 +502,9 @@ func (db *DB) AddFirstUser(c *Config, u *User, pass string) (int64, error) {
log.Println(err) log.Println(err)
wait(i) wait(i)
} }
return 0, fmt.Errorf("error: %v unsuccessful retries for DB operation, aborting", TxMaxRetries) errMsg := fmt.Sprintf("error: %v unsuccessful retries for DB operation, aborting", TxMaxRetries)
log.Println(errMsg)
return 0, fmt.Errorf(errMsg)
} }
func (db *DB) GetAllUsers(c *Config) ([]*User, error) { func (db *DB) GetAllUsers(c *Config) ([]*User, error) {
@ -456,34 +515,45 @@ func (db *DB) GetAllUsers(c *Config) ([]*User, error) {
rows, err := db.Query(query) rows, err := db.Query(query)
if err != nil { if err != nil {
log.Printf("Fehler beim Abrufen aller Benutzer aus der DB: %v", err)
return nil, fmt.Errorf("error getting all users from DB: %v", err) return nil, fmt.Errorf("error getting all users from DB: %v", err)
} }
defer rows.Close()
users := make([]*User, 0) users := make([]*User, 0)
for rows.Next() { for rows.Next() {
user := new(User) user := new(User)
if err = rows.Scan(&user.ID, &user.UserName, &aesFirstName, &aesLastName, &aesEmail, &user.ProfilePicLink, &user.Role); err != nil { if err = rows.Scan(&user.ID, &user.UserName, &aesFirstName, &aesLastName, &aesEmail, &user.ProfilePicLink, &user.Role); err != nil {
log.Printf("Fehler beim Scannen der Benutzerinformationen: %v", err)
return nil, fmt.Errorf("error getting user info: %v", err) return nil, fmt.Errorf("error getting user info: %v", err)
} }
user.FirstName, err = aesDecrypt(c, aesFirstName) user.FirstName, err = aesDecrypt(c, aesFirstName)
if err != nil { if err != nil {
log.Printf("Fehler beim Entschlüsseln des Vornamens für Benutzer ID '%v': %v", user.ID, err)
return nil, fmt.Errorf("error decrypting first name: %v", err) return nil, fmt.Errorf("error decrypting first name: %v", err)
} }
user.LastName, err = aesDecrypt(c, aesLastName) user.LastName, err = aesDecrypt(c, aesLastName)
if err != nil { if err != nil {
log.Printf("Fehler beim Entschlüsseln des Nachnamens für Benutzer ID '%v': %v", user.ID, err)
return nil, fmt.Errorf("error decrypting last name: %v", err) return nil, fmt.Errorf("error decrypting last name: %v", err)
} }
user.Email, err = aesDecrypt(c, aesEmail) user.Email, err = aesDecrypt(c, aesEmail)
if err != nil { if err != nil {
log.Printf("Fehler beim Entschlüsseln der E-Mail für Benutzer ID '%v': %v", user.ID, err)
return nil, fmt.Errorf("error decrypting email: %v", err) return nil, fmt.Errorf("error decrypting email: %v", err)
} }
users = append(users, user) users = append(users, user)
} }
if err = rows.Err(); err != nil {
log.Printf("Fehler bei der Iteration über die Zeilen: %v", err)
return nil, fmt.Errorf("error iterating over rows: %v", err)
}
return users, nil return users, nil
} }
@ -495,50 +565,63 @@ func (db *DB) GetAllUsersMap(c *Config) (map[int64]*User, error) {
rows, err := db.Query(query) rows, err := db.Query(query)
if err != nil { if err != nil {
log.Printf("Fehler beim Abrufen aller Benutzer aus der DB: %v", err)
return nil, fmt.Errorf("error getting all users from DB: %v", err) return nil, fmt.Errorf("error getting all users from DB: %v", err)
} }
defer rows.Close()
users := make(map[int64]*User, 0) users := make(map[int64]*User)
for rows.Next() { for rows.Next() {
user := new(User) user := new(User)
if err = rows.Scan(&user.ID, &user.UserName, &aesFirstName, &aesLastName, &aesEmail, &user.ProfilePicLink, &user.Role); err != nil { if err = rows.Scan(&user.ID, &user.UserName, &aesFirstName, &aesLastName, &aesEmail, &user.ProfilePicLink, &user.Role); err != nil {
log.Printf("Fehler beim Scannen der Benutzerinformationen: %v", err)
return nil, fmt.Errorf("error getting user info: %v", err) return nil, fmt.Errorf("error getting user info: %v", err)
} }
user.FirstName, err = aesDecrypt(c, aesFirstName) user.FirstName, err = aesDecrypt(c, aesFirstName)
if err != nil { if err != nil {
log.Printf("Fehler beim Entschlüsseln des Vornamens für Benutzer ID '%v': %v", user.ID, err)
return nil, fmt.Errorf("error decrypting first name: %v", err) return nil, fmt.Errorf("error decrypting first name: %v", err)
} }
user.LastName, err = aesDecrypt(c, aesLastName) user.LastName, err = aesDecrypt(c, aesLastName)
if err != nil { if err != nil {
log.Printf("Fehler beim Entschlüsseln des Nachnamens für Benutzer ID '%v': %v", user.ID, err)
return nil, fmt.Errorf("error decrypting last name: %v", err) return nil, fmt.Errorf("error decrypting last name: %v", err)
} }
user.Email, err = aesDecrypt(c, aesEmail) user.Email, err = aesDecrypt(c, aesEmail)
if err != nil { if err != nil {
log.Printf("Fehler beim Entschlüsseln der E-Mail für Benutzer ID '%v': %v", user.ID, err)
return nil, fmt.Errorf("error decrypting email: %v", err) return nil, fmt.Errorf("error decrypting email: %v", err)
} }
users[user.ID] = user users[user.ID] = user
} }
if err = rows.Err(); err != nil {
log.Printf("Fehler bei der Iteration über die Zeilen: %v", err)
return nil, fmt.Errorf("error iterating over rows: %v", err)
}
return users, nil return users, nil
} }
func (tx *Tx) SetPassword(id int64, newPass string) error { func (tx *Tx) SetPassword(id int64, newPass string) error {
hashedPass, err := bcrypt.GenerateFromPassword([]byte(newPass), bcrypt.DefaultCost) hashedPass, err := bcrypt.GenerateFromPassword([]byte(newPass), bcrypt.DefaultCost)
if err != nil { if err != nil {
log.Printf("Fehler beim Erstellen des Passwort-Hashes für ID '%v': %v", id, err)
if rollbackErr := tx.Rollback(); rollbackErr != nil { if rollbackErr := tx.Rollback(); rollbackErr != nil {
log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr) log.Fatalf("Transaktionsfehler: %v, Rollback-Fehler: %v", err, rollbackErr)
} }
return fmt.Errorf("error creating password hash: %v", err) return fmt.Errorf("error creating password hash: %v", err)
} }
setQuery := "UPDATE users SET password = ? WHERE id = ?" setQuery := "UPDATE users SET password = ? WHERE id = ?"
if _, err = tx.Exec(setQuery, string(hashedPass), id); err != nil { if _, err = tx.Exec(setQuery, string(hashedPass), id); err != nil {
log.Printf("Fehler beim Aktualisieren des Passworts in der DB für ID '%v': %v", id, err)
if rollbackErr := tx.Rollback(); rollbackErr != nil { if rollbackErr := tx.Rollback(); rollbackErr != nil {
log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr) log.Fatalf("Transaktionsfehler: %v, Rollback-Fehler: %v", err, rollbackErr)
} }
return fmt.Errorf("error updating password in DB: %v", err) return fmt.Errorf("error updating password in DB: %v", err)
} }
@ -555,13 +638,15 @@ func (db *DB) UpdateUserAttributes(c *Config, id int64, userName, firstName, las
err := func() error { err := func() error {
tx.Tx, err = db.Begin() tx.Tx, err = db.Begin()
if err != nil { if err != nil {
log.Printf("Fehler beim Starten der Transaktion: %v", err)
return fmt.Errorf("error starting transaction: %v", err) return fmt.Errorf("error starting transaction: %v", err)
} }
if !passwordEmpty { if !passwordEmpty {
if err = tx.SetPassword(id, newPass); err != nil { if err = tx.SetPassword(id, newPass); err != nil {
log.Printf("Fehler beim Setzen des neuen Passworts für ID '%v': %v", id, err)
if rollbackErr := tx.Rollback(); rollbackErr != nil { if rollbackErr := tx.Rollback(); rollbackErr != nil {
log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr) log.Fatalf("Transaktionsfehler: %v, Rollback-Fehler: %v", err, rollbackErr)
} }
return fmt.Errorf("error changing password: %v", err) return fmt.Errorf("error changing password: %v", err)
} }
@ -569,24 +654,27 @@ func (db *DB) UpdateUserAttributes(c *Config, id int64, userName, firstName, las
aesFirstName, err := aesEncrypt(c, firstName) aesFirstName, err := aesEncrypt(c, firstName)
if err != nil { if err != nil {
log.Printf("Fehler beim Verschlüsseln des Vornamens für ID '%v': %v", id, err)
if rollbackErr := tx.Rollback(); rollbackErr != nil { if rollbackErr := tx.Rollback(); rollbackErr != nil {
log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr) log.Fatalf("Transaktionsfehler: %v, Rollback-Fehler: %v", err, rollbackErr)
} }
return fmt.Errorf("error encrypting first name: %v", err) return fmt.Errorf("error encrypting first name: %v", err)
} }
aesLastName, err := aesEncrypt(c, lastName) aesLastName, err := aesEncrypt(c, lastName)
if err != nil { if err != nil {
log.Printf("Fehler beim Verschlüsseln des Nachnamens für ID '%v': %v", id, err)
if rollbackErr := tx.Rollback(); rollbackErr != nil { if rollbackErr := tx.Rollback(); rollbackErr != nil {
log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr) log.Fatalf("Transaktionsfehler: %v, Rollback-Fehler: %v", err, rollbackErr)
} }
return fmt.Errorf("error encrypting last name: %v", err) return fmt.Errorf("error encrypting last name: %v", err)
} }
aesEmail, err := aesEncrypt(c, email) aesEmail, err := aesEncrypt(c, email)
if err != nil { if err != nil {
log.Printf("Fehler beim Verschlüsseln der E-Mail für ID '%v': %v", id, err)
if rollbackErr := tx.Rollback(); rollbackErr != nil { if rollbackErr := tx.Rollback(); rollbackErr != nil {
log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr) log.Fatalf("Transaktionsfehler: %v, Rollback-Fehler: %v", err, rollbackErr)
} }
return fmt.Errorf("error encrypting email: %v", err) return fmt.Errorf("error encrypting email: %v", err)
} }
@ -599,13 +687,15 @@ func (db *DB) UpdateUserAttributes(c *Config, id int64, userName, firstName, las
&Attribute{Table: "users", ID: id, AttName: "profile_pic_link", Value: profilePicLink}, &Attribute{Table: "users", ID: id, AttName: "profile_pic_link", Value: profilePicLink},
&Attribute{Table: "users", ID: id, AttName: "role", Value: role}, &Attribute{Table: "users", ID: id, AttName: "role", Value: role},
); err != nil { ); err != nil {
log.Printf("Fehler beim Aktualisieren der Attribute in der DB für ID '%v': %v", id, err)
if rollbackErr := tx.Rollback(); rollbackErr != nil { if rollbackErr := tx.Rollback(); rollbackErr != nil {
log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr) log.Fatalf("Transaktionsfehler: %v, Rollback-Fehler: %v", err, rollbackErr)
} }
return fmt.Errorf("error updating attributes in DB: %v", err) return fmt.Errorf("error updating attributes in DB: %v", err)
} }
if err = tx.Commit(); err != nil { if err = tx.Commit(); err != nil {
log.Printf("Fehler beim Commit der Transaktion für ID '%v': %v", id, err)
return fmt.Errorf("error committing transaction: %v", err) return fmt.Errorf("error committing transaction: %v", err)
} }
@ -619,7 +709,9 @@ func (db *DB) UpdateUserAttributes(c *Config, id int64, userName, firstName, las
wait(i) wait(i)
} }
return fmt.Errorf("error: %v unsuccessful retries for DB operation, aborting", TxMaxRetries) errMsg := fmt.Sprintf("error: %v unsuccessful retries for DB operation, aborting", TxMaxRetries)
log.Println(errMsg)
return fmt.Errorf(errMsg)
} }
func (db *DB) DeleteUser(id int64) error { func (db *DB) DeleteUser(id int64) error {
@ -627,6 +719,7 @@ func (db *DB) DeleteUser(id int64) error {
_, err := db.Exec(query, id) _, err := db.Exec(query, id)
if err != nil { if err != nil {
log.Printf("Fehler beim Löschen des Benutzers mit ID '%v' aus der DB: %v", id, err)
return fmt.Errorf("error deleting user %v from DB: %v", id, err) return fmt.Errorf("error deleting user %v from DB: %v", id, err)
} }