nathan/smt
1
0
Fork 0
Code Issues 4 Pull Requests Packages Projects Releases 2 Wiki Activity

change to use logging instead of print to stdout

Browse Source
This commit is contained in:
Nathan Coad
2023-04-03 12:00:01 +10:00
parent f2ac6097d6
commit 5cc67501d3
11 changed files with 88 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
controllers/auth.go
View File

@@ -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)

6
controllers/retrieve_secrets.go
View File

@@ -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)

8
controllers/store_secrets.go
View File

@@ -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)

5
main.go
View File

@@ -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)
}

4
middlewares/middlewares.go
View File

@@ -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")

8
models/role.go
View File

@@ -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

58
models/secret.go
View File

@@ -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

38
models/setup.go
View File

@@ -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
}

24
models/user.go
View File

@@ -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")
}

3
utils/token/token.go
View File

@@ -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
}

9
utils/utils.go
View File

@@ -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 {