From 5cc67501d3583f085867d4ff4befff8d985162d1 Mon Sep 17 00:00:00 2001 From: Nathan Coad Date: Mon, 3 Apr 2023 12:00:01 +1000 Subject: [PATCH] change to use logging instead of print to stdout --- controllers/auth.go | 12 +++---- controllers/retrieve_secrets.go | 6 ++-- controllers/store_secrets.go | 8 ++--- main.go | 5 +-- middlewares/middlewares.go | 4 +-- models/role.go | 8 ++--- models/secret.go | 58 ++++++++++++++++----------------- models/setup.go | 38 ++++++++++----------- models/user.go | 24 +++++++------- utils/token/token.go | 3 +- utils/utils.go | 9 +++-- 11 files changed, 88 insertions(+), 87 deletions(-) diff --git a/controllers/auth.go b/controllers/auth.go index b7a6901..76b7e8a 100644 --- a/controllers/auth.go +++ b/controllers/auth.go @@ -1,8 +1,8 @@ package controllers import ( - "fmt" "html" + "log" "net/http" "strings" @@ -39,7 +39,7 @@ func Register(c *gin.Context) { // Default to regular user role if not specified if input.RoleId == 0 { - fmt.Printf("Register no role specified, defaulting to RoleId of 2.\n") + log.Printf("Register no role specified, defaulting to RoleId of 2.\n") u.RoleId = 2 } else { u.RoleId = input.RoleId @@ -50,9 +50,9 @@ func Register(c *gin.Context) { // Check if user already exists testUser, _ := models.GetUserByName(u.UserName) - fmt.Printf("Register checking if user already exists : '%v'\n", testUser) + log.Printf("Register checking if user already exists : '%v'\n", testUser) if (models.User{} == testUser) { - fmt.Printf("Register confirmed no existing username\n") + log.Printf("Register confirmed no existing username\n") } else { c.JSON(http.StatusBadRequest, gin.H{"error": "Attempt to register conflicting username"}) return @@ -64,7 +64,7 @@ func Register(c *gin.Context) { c.JSON(http.StatusBadRequest, gin.H{"Error hashing password": err.Error()}) return } else { - fmt.Printf("Register generated hashed password value '%s' from '%s'\n", string(hashedPassword), input.Password) + log.Printf("Register generated hashed password value '%s' from '%s'\n", string(hashedPassword), input.Password) } u.Password = string(hashedPassword) @@ -92,7 +92,7 @@ func Login(c *gin.Context) { u.UserName = input.Username u.Password = input.Password - fmt.Printf("Login checking username '%s' and password '%s'\n", u.UserName, u.Password) + log.Printf("Login checking username '%s' and password '%s'\n", u.UserName, u.Password) token, err := models.LoginCheck(u.UserName, u.Password) diff --git a/controllers/retrieve_secrets.go b/controllers/retrieve_secrets.go index f079256..b169590 100644 --- a/controllers/retrieve_secrets.go +++ b/controllers/retrieve_secrets.go @@ -3,7 +3,7 @@ package controllers import ( "ccsecrets/models" "ccsecrets/utils/token" - "fmt" + "log" "net/http" "github.com/gin-gonic/gin" @@ -22,7 +22,7 @@ func RetrieveSecret(c *gin.Context) { c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()}) return } - fmt.Printf("RetrieveSecret received JSON input '%v'\n", input) + log.Printf("RetrieveSecret received JSON input '%v'\n", input) // Get the user and role id of the requestor user_id, err := token.ExtractTokenID(c) @@ -72,7 +72,7 @@ func RetrieveMultpleSecrets(c *gin.Context) { c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()}) return } - fmt.Printf("StoreSecret received JSON input '%v'\n", input) + log.Printf("StoreSecret received JSON input '%v'\n", input) // Get the user and role id of the requestor user_id, err := token.ExtractTokenID(c) diff --git a/controllers/store_secrets.go b/controllers/store_secrets.go index 2c3adc4..9ae6567 100644 --- a/controllers/store_secrets.go +++ b/controllers/store_secrets.go @@ -3,7 +3,7 @@ package controllers import ( "ccsecrets/models" "errors" - "fmt" + "log" "net/http" "github.com/gin-gonic/gin" @@ -27,7 +27,7 @@ func StoreSecret(c *gin.Context) { return } - fmt.Printf("StoreSecret received JSON input '%v'\n", input) + log.Printf("StoreSecret received JSON input '%v'\n", input) // Populate fields s := models.Secret{} @@ -55,7 +55,7 @@ func StoreSecret(c *gin.Context) { } if len(checkExists) > 0 { - fmt.Printf("StoreSecret not storing secret with '%d' already matching secrets.\n", len(checkExists)) + log.Printf("StoreSecret not storing secret with '%d' already matching secrets.\n", len(checkExists)) c.JSON(http.StatusBadRequest, gin.H{"error": "StoreSecret attempting to store secret already defined. API calls for update/delete don't yet exist"}) return } @@ -86,7 +86,7 @@ func UpdateSecret(c *gin.Context) { return } - fmt.Printf("UpdateSecret received JSON input '%v'\n", input) + log.Printf("UpdateSecret received JSON input '%v'\n", input) // Get the user and role id of the requestor u, err := models.GetUserRoleFromToken(c) diff --git a/main.go b/main.go index 00e2dd8..44460c5 100644 --- a/main.go +++ b/main.go @@ -35,6 +35,7 @@ func main() { fmt.Println("Unable to write logfile", err) os.Exit(1) } + log.SetOutput(logfileWriter) // Initiate connection to sqlite and make sure our schema is up to date models.ConnectDatabase() @@ -88,7 +89,7 @@ func main() { bindIP = "8443" } bindAddress := fmt.Sprint(bindIP, ":", bindPort) - fmt.Printf("Will listen on address 'https://%s'\n", bindAddress) + log.Printf("Will listen on address 'https://%s'\n", bindAddress) // Get file names for TLS cert/key tlsCertFilename := os.Getenv("TLS_CERT_FILE") @@ -107,7 +108,7 @@ func main() { // Generate certificate if required if !(utils.FileExists(tlsCertFilename) && utils.FileExists(tlsKeyFilename)) { - fmt.Printf("Specified TLS certificate (%s) or private key (%s) do not exist.\n", tlsCertFilename, tlsKeyFilename) + log.Printf("Specified TLS certificate (%s) or private key (%s) do not exist.\n", tlsCertFilename, tlsKeyFilename) utils.GenerateCerts(tlsCertFilename, tlsKeyFilename) } diff --git a/middlewares/middlewares.go b/middlewares/middlewares.go index 1f9b126..7537c4a 100644 --- a/middlewares/middlewares.go +++ b/middlewares/middlewares.go @@ -1,7 +1,7 @@ package middlewares import ( - "fmt" + "log" "net/http" "ccsecrets/models" @@ -50,7 +50,7 @@ func JwtAuthAdminMiddleware() gin.HandlerFunc { c.Abort() return } - fmt.Printf("JwtAuthAdminMiddleware retrieved UserRole object '%v'\n", ur) + log.Printf("JwtAuthAdminMiddleware retrieved UserRole object '%v'\n", ur) if !ur.Admin { c.String(http.StatusUnauthorized, "User role is Non-Admin") diff --git a/models/role.go b/models/role.go index 167fea7..6c4826a 100644 --- a/models/role.go +++ b/models/role.go @@ -1,6 +1,6 @@ package models -import "fmt" +import "log" type Role struct { RoleId int `db:"RoleId"` @@ -16,7 +16,7 @@ func QueryRoles() ([]Role, error) { rows, err := db.Queryx("SELECT * FROM roles") if err != nil { - fmt.Printf("QueryRoles error executing sql record : '%s'\n", err) + log.Printf("QueryRoles error executing sql record : '%s'\n", err) return results, err } else { // parse all the results into a slice @@ -24,13 +24,13 @@ func QueryRoles() ([]Role, error) { var r Role err = rows.StructScan(&r) if err != nil { - fmt.Printf("QueryRoles error parsing sql record : '%s'\n", err) + log.Printf("QueryRoles error parsing sql record : '%s'\n", err) return results, err } results = append(results, r) } - fmt.Printf("QueryRoles retrieved '%d' results\n", len(results)) + log.Printf("QueryRoles retrieved '%d' results\n", len(results)) } return results, nil diff --git a/models/secret.go b/models/secret.go index c268915..e19e1fe 100644 --- a/models/secret.go +++ b/models/secret.go @@ -6,8 +6,8 @@ import ( "crypto/rand" "encoding/hex" "errors" - "fmt" "io" + "log" "os" "github.com/jmoiron/sqlx" @@ -29,16 +29,16 @@ func (s *Secret) SaveSecret() (*Secret, error) { var err error - fmt.Printf("SaveSecret storing values '%v'\n", s) + log.Printf("SaveSecret storing values '%v'\n", s) result, err := db.NamedExec((`INSERT INTO secrets (RoleId, DeviceName, DeviceCategory, UserName, Secret) VALUES (:RoleId, :DeviceName, :DeviceCategory, :UserName, :Secret)`), s) if err != nil { - fmt.Printf("StoreSecret error executing sql record : '%s'\n", err) + log.Printf("StoreSecret error executing sql record : '%s'\n", err) return s, err } else { affected, _ := result.RowsAffected() id, _ := result.LastInsertId() - fmt.Printf("StoreSecret insert returned result id '%d' affecting %d row(s).\n", id, affected) + log.Printf("StoreSecret insert returned result id '%d' affecting %d row(s).\n", id, affected) } return s, nil @@ -50,7 +50,7 @@ func GetSecrets(s *Secret) ([]Secret, error) { var rows *sqlx.Rows var secretResults []Secret - fmt.Printf("GetSecret querying values '%v'\n", s) + log.Printf("GetSecret querying values '%v'\n", s) // Determine whether to query for a specific device or a category of devices // Prefer querying device name than category @@ -61,13 +61,13 @@ func GetSecrets(s *Secret) ([]Secret, error) { } else if s.DeviceCategory != "" { rows, err = db.Queryx("SELECT * FROM secrets WHERE DeviceCategory LIKE ? AND RoleId = ?", s.DeviceCategory, s.RoleId) } else { - fmt.Printf("GetSecret no valid search options specified\n") + log.Printf("GetSecret no valid search options specified\n") err = errors.New("no valid search options specified") return secretResults, err } if err != nil { - fmt.Printf("GetSecret error executing sql record : '%s'\n", err) + log.Printf("GetSecret error executing sql record : '%s'\n", err) return secretResults, err } else { // parse all the results into a slice @@ -75,20 +75,20 @@ func GetSecrets(s *Secret) ([]Secret, error) { var r Secret err = rows.StructScan(&r) if err != nil { - fmt.Printf("GetSecret error parsing sql record : '%s'\n", err) + log.Printf("GetSecret error parsing sql record : '%s'\n", err) return secretResults, err } // Decrypt the secret _, err = r.DecryptSecret() if err != nil { - fmt.Printf("GetSecret unable to decrypt stored secret '%v', skipping result.\n", r.Secret) + log.Printf("GetSecret unable to decrypt stored secret '%v', skipping result.\n", r.Secret) } else { secretResults = append(secretResults, r) } } - fmt.Printf("GetSecret retrieved '%d' results\n", len(secretResults)) + log.Printf("GetSecret retrieved '%d' results\n", len(secretResults)) } return secretResults, nil @@ -98,22 +98,22 @@ func (s *Secret) UpdateSecret() (*Secret, error) { var err error - fmt.Printf("UpdateSecret storing values '%v'\n", s) + log.Printf("UpdateSecret storing values '%v'\n", s) if s.SecretId == 0 { err = errors.New("UpdateSecret unable to locate secret with empty secretId field") - fmt.Printf("UpdateSecret error in pre-check : '%s'\n", err) + log.Printf("UpdateSecret error in pre-check : '%s'\n", err) return s, err } result, err := db.NamedExec((`UPDATE secrets SET DeviceName = :DeviceName, DeviceCategory = :DeviceCategory, UserName = :UserName, Secret = :Secret WHERE SecretId = :SecretId`), s) if err != nil { - fmt.Printf("UpdateSecret error executing sql record : '%s'\n", err) + log.Printf("UpdateSecret error executing sql record : '%s'\n", err) return &Secret{}, err } else { affected, _ := result.RowsAffected() id, _ := result.LastInsertId() - fmt.Printf("UpdateSecret insert returned result id '%d' affecting %d row(s).\n", id, affected) + log.Printf("UpdateSecret insert returned result id '%d' affecting %d row(s).\n", id, affected) } return s, nil @@ -128,35 +128,35 @@ func (s *Secret) EncryptSecret() (*Secret, error) { //key := []byte("ECB518652A170880555136EA1F9752D6") plaintext := []byte(s.Secret) - fmt.Printf("EncryptSecret applying key '%v' of length '%d' to plaintext secret '%s'\n", key, len(key), s.Secret) + log.Printf("EncryptSecret applying key '%v' of length '%d' to plaintext secret '%s'\n", key, len(key), s.Secret) block, err := aes.NewCipher(key) if err != nil { - fmt.Printf("EncryptSecret NewCipher error '%s'\n", err) + log.Printf("EncryptSecret NewCipher error '%s'\n", err) return s, err } // Never use more than 2^32 random nonces with a given key because of the risk of a repeat. nonce := make([]byte, nonceSize) if _, err := io.ReadFull(rand.Reader, nonce); err != nil { - fmt.Printf("EncryptSecret nonce generation error '%s'\n", err) + log.Printf("EncryptSecret nonce generation error '%s'\n", err) return s, err } - fmt.Printf("EncryptSecret random nonce value is '%x'\n", nonce) + log.Printf("EncryptSecret random nonce value is '%x'\n", nonce) aesgcm, err := cipher.NewGCM(block) if err != nil { - fmt.Printf("EncryptSecret NewGCM error '%s'\n", err) + log.Printf("EncryptSecret NewGCM error '%s'\n", err) return s, err } ciphertext := aesgcm.Seal(nil, nonce, plaintext, nil) - fmt.Printf("EncryptSecret generated ciphertext '%x''\n", ciphertext) + log.Printf("EncryptSecret generated ciphertext '%x''\n", ciphertext) // Create a new slice to store nonce at the start and then the resulting ciphertext // Nonce is always 12 bytes combinedText := append(nonce, ciphertext...) - fmt.Printf("EncryptSecret combined secret value is now '%x'\n", combinedText) + log.Printf("EncryptSecret combined secret value is now '%x'\n", combinedText) // Store the value back into the struct ready for database operations s.Secret = hex.EncodeToString(combinedText) @@ -175,44 +175,44 @@ func (s *Secret) DecryptSecret() (*Secret, error) { //key := []byte("ECB518652A170880555136EA1F9752D6") if len(s.Secret) < nonceSize { - fmt.Printf("DecryptSecret ciphertext is too short to decrypt\n") + log.Printf("DecryptSecret ciphertext is too short to decrypt\n") return s, errors.New("ciphertext is too short") } crypted, err := hex.DecodeString(s.Secret) if err != nil { - fmt.Printf("DecryptSecret unable to convert hex encoded string due to error '%s'\n", err) + log.Printf("DecryptSecret unable to convert hex encoded string due to error '%s'\n", err) return s, err } - fmt.Printf("DecryptSecret processing secret '%x'\n", crypted) + log.Printf("DecryptSecret processing secret '%x'\n", crypted) //nonce, _ := hex.DecodeString("64a9433eae7ccceee2fc0eda") // The nonce is the first 12 bytes from the ciphertext nonce := crypted[:nonceSize] ciphertext := crypted[nonceSize:] - fmt.Printf("DecryptSecret applying key '%v' and nonce '%x' to ciphertext '%x'\n", key, nonce, ciphertext) + log.Printf("DecryptSecret applying key '%v' and nonce '%x' to ciphertext '%x'\n", key, nonce, ciphertext) block, err := aes.NewCipher(key) if err != nil { - fmt.Printf("DecryptSecret NewCipher error '%s'\n", err) + log.Printf("DecryptSecret NewCipher error '%s'\n", err) return s, err } aesgcm, err := cipher.NewGCM(block) if err != nil { - fmt.Printf("DecryptSecret NewGCM error '%s'\n", err) + log.Printf("DecryptSecret NewGCM error '%s'\n", err) return s, err } plaintext, err := aesgcm.Open(nil, nonce, ciphertext, nil) if err != nil { - fmt.Printf("DecryptSecret Open error '%s'\n", err) + log.Printf("DecryptSecret Open error '%s'\n", err) return s, err } - fmt.Printf("DecryptSecret plaintext is '%s'\n", plaintext) + log.Printf("DecryptSecret plaintext is '%s'\n", plaintext) s.Secret = string(plaintext) return s, nil diff --git a/models/setup.go b/models/setup.go index 93ab313..65c4c54 100644 --- a/models/setup.go +++ b/models/setup.go @@ -74,10 +74,10 @@ func ConnectDatabase() { db, err = sqlx.Open("sqlite", sqlPath) if err != nil { - fmt.Printf("Error opening sqlite database connection to file '%s' : '%s'\n", sqlPath, err) + log.Printf("Error opening sqlite database connection to file '%s' : '%s'\n", sqlPath, err) os.Exit(1) } else { - fmt.Printf("Connected to sqlite database file '%s'\n", sqlPath) + log.Printf("Connected to sqlite database file '%s'\n", sqlPath) } //sqlx.NameMapper = func(s string) string { return s } @@ -89,7 +89,7 @@ func ConnectDatabase() { } func DisconnectDatabase() { - fmt.Printf("DisconnectDatabase called") + log.Printf("DisconnectDatabase called") defer db.Close() } @@ -99,28 +99,28 @@ func CreateTables() { // Create database tables if it doesn't exist // Roles table should go first since other tables refer to it if _, err = db.Exec(createRoles); err != nil { - fmt.Printf("Error checking roles table : '%s'", err) + log.Printf("Error checking roles table : '%s'", err) os.Exit(1) } rowCount, _ = CheckCount("roles") if rowCount == 0 { if _, err = db.Exec("INSERT INTO roles VALUES(1, 'Admin', false, true);"); err != nil { - fmt.Printf("Error adding initial admin role : '%s'", err) + log.Printf("Error adding initial admin role : '%s'", err) os.Exit(1) } if _, err = db.Exec("INSERT INTO roles VALUES(2, 'UserRole', false, false);"); err != nil { - fmt.Printf("Error adding initial user role : '%s'", err) + log.Printf("Error adding initial user role : '%s'", err) os.Exit(1) } if _, err = db.Exec("INSERT INTO roles VALUES(3, 'GuestRole', true, false);"); err != nil { - fmt.Printf("Error adding initial guest role : '%s'", err) + log.Printf("Error adding initial guest role : '%s'", err) os.Exit(1) } } // Users table if _, err = db.Exec(createUsers); err != nil { - fmt.Printf("Error checking users table : '%s'", err) + log.Printf("Error checking users table : '%s'", err) os.Exit(1) } rowCount, _ = CheckCount("users") @@ -130,30 +130,30 @@ func CreateTables() { if initialPassword == "" { initialPassword = "password" } else if initialPassword[:4] == "$2a$" { - fmt.Printf("CreateTables inital admin password is already a hash") + log.Printf("CreateTables inital admin password is already a hash") } else { cryptText, _ := bcrypt.GenerateFromPassword([]byte(initialPassword), bcrypt.DefaultCost) initialPassword = string(cryptText) } if _, err = db.Exec("INSERT INTO users VALUES(1, 1, 'Administrator', ?);", initialPassword); err != nil { - fmt.Printf("Error adding initial admin role : '%s'", err) + log.Printf("Error adding initial admin role : '%s'", err) os.Exit(1) } } // Secrets table if _, err = db.Exec(createSecrets); err != nil { - fmt.Printf("Error checking secrets table : '%s'", err) + log.Printf("Error checking secrets table : '%s'", err) os.Exit(1) } // Schema table should go last so we know if the database has a value in the schema table then everything was created properly if _, err = db.Exec(createSchema); err != nil { - fmt.Printf("Error checking schema table : '%s'", err) + log.Printf("Error checking schema table : '%s'", err) os.Exit(1) } schemaCheck, _ := CheckColumnExists("schema", "Version") if !schemaCheck { if _, err = db.Exec("INSERT INTO schema VALUES(1);"); err != nil { - fmt.Printf("Error adding initial scehama version : '%s'", err) + log.Printf("Error adding initial scehama version : '%s'", err) os.Exit(1) } } @@ -165,12 +165,12 @@ func CheckCount(tablename string) (int, error) { var count int stmt, err := db.Prepare("SELECT COUNT(*) as count FROM " + tablename) if err != nil { - fmt.Printf("CheckCount error preparing sqlite statement : '%s'\n", err) + log.Printf("CheckCount error preparing sqlite statement : '%s'\n", err) return 0, err } err = stmt.QueryRow().Scan(&count) if err != nil { - fmt.Printf("CheckCount error querying database record count : '%s'\n", err) + log.Printf("CheckCount error querying database record count : '%s'\n", err) return 0, err } stmt.Close() // or use defer rows.Close(), idc @@ -214,7 +214,7 @@ func GenerateInsertMethod(q interface{}) (string, error) { fieldValues = fmt.Sprintf("%s, %d", fieldValues, boolSet) } default: - fmt.Printf("Unsupported type '%s'\n", v.Field(i).Kind()) + log.Printf("Unsupported type '%s'\n", v.Field(i).Kind()) } } query = fmt.Sprintf("%s(%s) VALUES (%s)", query, fieldNames, fieldValues) @@ -227,14 +227,14 @@ func CheckColumnExists(table string, column string) (bool, error) { var count int64 rows, err := db.Queryx("SELECT COUNT(*) AS CNTREC FROM pragma_table_info('" + table + "') WHERE name='" + column + "';") if err != nil { - fmt.Printf("CheckColumnExists error querying database for existence of column '%s' : '%s'\n", column, err) + log.Printf("CheckColumnExists error querying database for existence of column '%s' : '%s'\n", column, err) return false, err } defer rows.Close() for rows.Next() { // cols is an []interface{} of all of the column results cols, _ := rows.SliceScan() - fmt.Printf("CheckColumnExists Value is '%v' for table '%s' and column '%s'\n", cols[0].(int64), table, column) + log.Printf("CheckColumnExists Value is '%v' for table '%s' and column '%s'\n", cols[0].(int64), table, column) count = cols[0].(int64) if count == 1 { @@ -246,7 +246,7 @@ func CheckColumnExists(table string, column string) (bool, error) { err = rows.Err() if err != nil { - fmt.Printf("CheckColumnExists error getting results : '%s'\n", err) + log.Printf("CheckColumnExists error getting results : '%s'\n", err) return false, err } diff --git a/models/user.go b/models/user.go index 499dee5..dd3a217 100644 --- a/models/user.go +++ b/models/user.go @@ -3,7 +3,7 @@ package models import ( "ccsecrets/utils/token" "errors" - "fmt" + "log" "net/http" "github.com/gin-gonic/gin" @@ -33,19 +33,19 @@ func (u *User) SaveUser() (*User, error) { result, err := db.NamedExec((`INSERT INTO users (RoleId, UserName, Password) VALUES (:RoleId, :UserName, :Password)`), u) if err != nil { - fmt.Printf("SaveUser error executing sql record : '%s'\n", err) + log.Printf("SaveUser error executing sql record : '%s'\n", err) return &User{}, err } else { affected, _ := result.RowsAffected() id, _ := result.LastInsertId() - fmt.Printf("SaveUser insert returned result id '%d' affecting %d row(s).\n", id, affected) + log.Printf("SaveUser insert returned result id '%d' affecting %d row(s).\n", id, affected) } return u, nil } func VerifyPassword(password, hashedPassword string) error { - fmt.Printf("VerifyPassword comparing password vs hashed:\n'%s'\n'%s'\n", password, hashedPassword) + log.Printf("VerifyPassword comparing password vs hashed:\n'%s'\n'%s'\n", password, hashedPassword) return bcrypt.CompareHashAndPassword([]byte(hashedPassword), []byte(password)) } @@ -58,7 +58,7 @@ func LoginCheck(username string, password string) (string, error) { // Query database for matching user object err = db.QueryRowx("SELECT * FROM Users WHERE Username=?", username).StructScan(&u) - fmt.Printf("LoginCheck retrieved user '%v' from database\n", u) + log.Printf("LoginCheck retrieved user '%v' from database\n", u) if err != nil { return "", err @@ -67,16 +67,16 @@ func LoginCheck(username string, password string) (string, error) { err = VerifyPassword(password, u.Password) if err != nil && err == bcrypt.ErrMismatchedHashAndPassword { - fmt.Printf("LoginCheck says password doesn't match stored hash.\n") + log.Printf("LoginCheck says password doesn't match stored hash.\n") return "", err } else { - fmt.Printf("LoginCheck verified password against stored hash.\n") + log.Printf("LoginCheck verified password against stored hash.\n") } token, err := token.GenerateToken(uint(u.UserId)) if err != nil { - fmt.Printf("LoginCheck error generating token : '%s'\n", err) + log.Printf("LoginCheck error generating token : '%s'\n", err) return "", err } @@ -122,10 +122,10 @@ func GetUserRoleByID(uid uint) (UserRole, error) { var ur UserRole // Query database for matching user object - fmt.Printf("GetUserRoleByID querying for userid '%d'\n", uid) + log.Printf("GetUserRoleByID querying for userid '%d'\n", uid) err := db.QueryRowx("SELECT users.UserId, users.RoleId, users.UserName, users.Password, roles.RoleName, roles.ReadOnly, roles.Admin FROM users INNER JOIN roles ON users.RoleId = roles.RoleId WHERE users.UserId=?", uid).StructScan(&ur) if err != nil { - fmt.Printf("GetUserRoleByID received error when querying database : '%s'\n", err) + log.Printf("GetUserRoleByID received error when querying database : '%s'\n", err) return ur, errors.New("GetUserRoleByID user not found") } @@ -144,10 +144,10 @@ func GetUserRoleFromToken(c *gin.Context) (UserRole, error) { } // Query database for matching user object - fmt.Printf("GetUserRoleFromToken querying for userid '%d'\n", user_id) + log.Printf("GetUserRoleFromToken querying for userid '%d'\n", user_id) err = db.QueryRowx("SELECT users.UserId, users.RoleId, users.UserName, users.Password, roles.RoleName, roles.ReadOnly, roles.Admin FROM users INNER JOIN roles ON users.RoleId = roles.RoleId WHERE users.UserId=?", user_id).StructScan(&ur) if err != nil { - fmt.Printf("GetUserRoleFromToken received error when querying database : '%s'\n", err) + log.Printf("GetUserRoleFromToken received error when querying database : '%s'\n", err) return ur, errors.New("GetUserRoleFromToken user not found") } diff --git a/utils/token/token.go b/utils/token/token.go index 3c36d03..477c149 100644 --- a/utils/token/token.go +++ b/utils/token/token.go @@ -2,6 +2,7 @@ package token import ( "fmt" + "log" "os" "strconv" "strings" @@ -15,7 +16,7 @@ func GenerateToken(user_id uint) (string, error) { token_lifespan, err := strconv.Atoi(os.Getenv("TOKEN_HOUR_LIFESPAN")) if err != nil { - fmt.Printf("GenerateToken Error getting env value TOKEN_HOUR_LIFESPAN\n") + log.Printf("GenerateToken Error getting env value TOKEN_HOUR_LIFESPAN\n") return "", err } diff --git a/utils/utils.go b/utils/utils.go index bf1b479..ca1fd9e 100644 --- a/utils/utils.go +++ b/utils/utils.go @@ -6,7 +6,6 @@ import ( "crypto/x509" "crypto/x509/pkix" "encoding/pem" - "fmt" "log" "math/big" "net" @@ -25,7 +24,7 @@ func GetFilePath(path string) string { // check if filename exists if _, err := os.Stat(path); os.IsNotExist((err)) { - fmt.Printf("File '%s' not found, searching in same directory as binary\n", path) + log.Printf("File '%s' not found, searching in same directory as binary\n", path) // if not, check that it exists in the same directory as the currently executing binary ex, err2 := os.Executable() if err2 != nil { @@ -76,7 +75,7 @@ func GenerateCerts(tlsCert string, tlsKey string) { // Check that the directory exists relativePath := filepath.Dir(tlsCert) - fmt.Printf("GenerateCerts relative path for file creation is '%s'\n", relativePath) + log.Printf("GenerateCerts relative path for file creation is '%s'\n", relativePath) _, err = os.Stat(relativePath) if os.IsNotExist(err) { log.Printf("Certificate path does not exist, creating %s before generating certificate\n", relativePath) @@ -126,13 +125,13 @@ func GenerateCerts(tlsCert string, tlsKey string) { ifaces, err := net.Interfaces() if err != nil { - fmt.Printf("Error enumerating interfaces: %v\n", err) + log.Printf("Error enumerating interfaces: %v\n", err) } for _, i := range ifaces { addrs, err := i.Addrs() if err != nil { - fmt.Printf("Oops: %v\n", err) + log.Printf("Oops: %v\n", err) } for _, address := range addrs {