From c01ef202a8c1dc020b90f957d71f441d588cb119 Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 04:30:23 +0300
Subject: [PATCH 01/29] Add server cmd gui

---
 cmd/gui/main.go            | 77 ++++++++++++++++++--------------------
 dockerfile                 |  2 +-
 go.mod                     | 44 +++++++++++++++++-----
 internal/miniature/http.go |  4 +-
 4 files changed, 74 insertions(+), 53 deletions(-)

diff --git a/cmd/gui/main.go b/cmd/gui/main.go
index 9fd6e42..c7254f1 100644
--- a/cmd/gui/main.go
+++ b/cmd/gui/main.go
@@ -20,7 +20,7 @@ func main() {
 	defer ui.Close()
 	termWidth, termHeight := ui.TerminalDimensions()
 	title := widgets.NewParagraph()
-	title.Text = "Welcome to Miniatureby DevGenie, press q to quit"
+	title.Text = "Welcome to Miniature by DevGenie, press q to quit. Total runtime: n/a"
 	title.TextStyle.Modifier = ui.ModifierBold
 	title.WrapText = true
 	title.TextStyle.Fg = ui.ColorGreen
@@ -30,48 +30,46 @@ func main() {
 	title.PaddingRight = 1
 	title.PaddingLeft = 1
 
+	info := widgets.NewList()
+	info.BorderStyle.Fg = ui.ColorCyan
+	info.Title = "Info"
+	info.TitleStyle.Fg = ui.ColorGreen
 
-	systemStats := widgets.NewList()
-	systemStats.BorderStyle.Fg = ui.ColorCyan
-	systemStats.Title = "System"
-	systemStats.TitleStyle.Fg = ui.ColorGreen
+	networkDataIn := widgets.NewSparkline()
+	networkDataIn.Title = "Bytes in"
+	networkDataIn.Data = make([]float64, 0)
+	networkDataIn.LineColor = ui.ColorGreen
+	networkDataIn.TitleStyle.Modifier = ui.ModifierBold
+	networkDataIn.TitleStyle.Fg = ui.ColorGreen
 
-	peerStats := widgets.NewList()
-	peerStats.BorderStyle.Fg = ui.ColorCyan
-	peerStats.Title = "Peers"
-	peerStats.TitleStyle.Fg = ui.ColorGreen
+	networkDataOut := widgets.NewSparkline()
+	networkDataOut.Title = "Bytes out"
+	networkDataOut.Data = make([]float64, 0)
+	networkDataOut.LineColor = ui.ColorCyan
+	networkDataOut.TitleStyle.Modifier = ui.ModifierBold
+	networkDataOut.TitleStyle.Fg = ui.ColorCyan
 
-	networkStats := widgets.NewList()
-	networkStats.BorderStyle.Fg = ui.ColorCyan
-	networkStats.Title = "Network"
-	networkStats.TitleStyle.Fg = ui.ColorGreen
-
-	networkData := widgets.NewSparkline()
-	networkData.Title = "Peers connected: 0"
-	networkData.LineColor = ui.ColorCyan
-	networkData.Data = make([]float64, 1)
-	networkData.TitleStyle.Modifier = ui.ModifierBold
-	networkData.TitleStyle.Fg = ui.ColorGreen
-
-	sparklineGroup := widgets.NewSparklineGroup(networkData)
+	sparklineGroup := widgets.NewSparklineGroup(networkDataIn, networkDataOut)
+	sparklineGroup.Title = "Network stats"
 
 	grid := ui.NewGrid()
 	grid.SetRect(0, 0, termWidth, termHeight)
 
 	grid.Set(
-		ui.NewRow(0.4/6,title),
+		ui.NewRow(0.4/6, title),
 		ui.NewRow(5.6/6,
 			ui.NewCol(1.0/4,
-				ui.NewRow(2.0/6,systemStats),
-				ui.NewRow(2.0/6,peerStats),
-				ui.NewRow(2.0/6,networkStats),
+				ui.NewRow(2.0/6, info),
 			),
 			ui.NewCol(3.0/4, sparklineGroup),
 		),
 	)
 
 	ui.Render(grid)
-	tickerCount := 1
+	lastConnIn := new(int)
+	lastConnOut := new(int)
+	*lastConnIn = 0
+	*lastConnOut = 0
 	uiEvents := ui.PollEvents()
 	ticker := time.NewTicker(time.Second).C
 	for {
@@ -89,21 +87,18 @@ func main() {
 			}
 		case <-ticker:
 			usageStats := callStats()
-			generalStatsRows := []string{fmt.Sprintf("Available: %d", usageStats.AvailableSlots),
-										fmt.Sprintf("Total: %d", usageStats.AvailableSlots),
-										fmt.Sprintf("Connected: %d", usageStats.Peers),
-										fmt.Sprintf("Bytes in: %d", usageStats.ConnectionsIn),
-										fmt.Sprintf("Bytes out: %d", usageStats.ConnectionsOut),
-									}
-			
-			systemStatsRows := []string{fmt.Sprintf("Running time: %s", usageStats.TimeElapsed),
+			title.Text = fmt.Sprintf("Welcome to Miniature by DevGenie, press q to quit. Total runtime: %s", usageStats.TimeElapsed)
+			generalStatsRows := []string{
+				fmt.Sprintf("Available connections: %d", usageStats.AvailableSlots),
+				fmt.Sprintf("Peers connected: %d", usageStats.Peers),
+				fmt.Sprintf("Total bytes in: %d", usageStats.ConnectionsIn),
+				fmt.Sprintf("Total bytes out: %d", usageStats.ConnectionsOut),
 			}
-			networkData.Data = append(networkData.Data, float64(usageStats.Peers))
-			peerStats.Rows = generalStatsRows
-			systemStats.Rows = systemStatsRows
+
+			networkDataIn.Data = append(networkDataIn.Data, float64(usageStats.ConnectionsIn))
+			networkDataOut.Data = append(networkDataOut.Data, float64(usageStats.ConnectionsOut))
+			info.Rows = generalStatsRows
 			ui.Render(grid)
-			tickerCount++
-			networkData.Title = fmt.Sprintf("Peers Connected: %d %s", tickerCount, termWidth)
 		}
 	}
 }
@@ -128,4 +123,4 @@ func callStats() miniature.Stats {
 	var responseObject miniature.Stats
 	json.Unmarshal(bodyBytes, &responseObject)
 	return responseObject
-}
\ No newline at end of file
+}
diff --git a/dockerfile b/dockerfile
index 5a44f13..28a3134 100644
--- a/dockerfile
+++ b/dockerfile
@@ -1,4 +1,4 @@
-FROM golang:1.12.5-alpine
+FROM golang:1.21.5-alpine
 RUN apk update
 RUN apk upgrade
 RUN apk add git
diff --git a/go.mod b/go.mod
index cefd96a..c45d217 100644
--- a/go.mod
+++ b/go.mod
@@ -1,19 +1,43 @@
 module github.com/devgenie/miniature
 
-go 1.12
+go 1.21
+
+toolchain go1.21.5
 
 require (
+	fyne.io/fyne/v2 v2.1.3
 	github.com/aead/ecdh v0.2.0
-	github.com/gizak/termui/v3 v3.1.0 // indirect
-	github.com/go-chi/chi v1.5.4 // indirect
-	github.com/google/uuid v1.2.0 // indirect
-	github.com/lithammer/shortuuid/v3 v3.0.5
+	github.com/gizak/termui/v3 v3.1.0
+	github.com/go-chi/chi v1.5.4
 	github.com/pierrec/lz4 v2.6.0+incompatible
-	github.com/pierrec/lz4/v4 v4.1.3
+	github.com/rickb777/date v1.20.5
 	github.com/robfig/cron v1.2.0
 	github.com/songgao/water v0.0.0-20200317203138-2b4b6d7c09d8
-	golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 // indirect
-	golang.org/x/net v0.0.0-20210220033124-5f55cee0dc0d
-	golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43 // indirect
-	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b
+	golang.org/x/net v0.18.0
+	gopkg.in/yaml.v3 v3.0.1
+)
+
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/frankban/quicktest v1.14.2 // indirect
+	github.com/fredbi/uri v0.0.0-20181227131451-3dcfdacbaaf3 // indirect
+	github.com/fsnotify/fsnotify v1.4.9 // indirect
+	github.com/go-gl/gl v0.0.0-20210813123233-e4099ee2221f // indirect
+	github.com/go-gl/glfw/v3.3/glfw v0.0.0-20211024062804-40e447a793be // indirect
+	github.com/godbus/dbus/v5 v5.0.4 // indirect
+	github.com/goki/freetype v0.0.0-20181231101311-fa8a33aabaff // indirect
+	github.com/mattn/go-runewidth v0.0.2 // indirect
+	github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7 // indirect
+	github.com/nsf/termbox-go v0.0.0-20190121233118-02980233997d // indirect
+	github.com/onsi/gomega v1.30.0 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/rickb777/plural v1.4.1 // indirect
+	github.com/srwiley/oksvg v0.0.0-20200311192757-870daf9aa564 // indirect
+	github.com/srwiley/rasterx v0.0.0-20200120212402-85cb7272f5e9 // indirect
+	github.com/stretchr/testify v1.6.1 // indirect
+	github.com/yuin/goldmark v1.4.13 // indirect
+	golang.org/x/crypto v0.15.0 // indirect
+	golang.org/x/image v0.0.0-20200430140353-33d19683fad8 // indirect
+	golang.org/x/sys v0.14.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
 )
diff --git a/internal/miniature/http.go b/internal/miniature/http.go
index 39885a9..13e59df 100644
--- a/internal/miniature/http.go
+++ b/internal/miniature/http.go
@@ -8,6 +8,7 @@ import (
 
 	"github.com/go-chi/chi"
 	"github.com/go-chi/chi/middleware"
+	"github.com/rickb777/date/period"
 )
 
 // HTTPServer ...
@@ -55,7 +56,8 @@ func (httpServer *HTTPServer) handleStats(w http.ResponseWriter, r *http.Request
 		serverStats.Peers = httpServer.server.connectionPool.ConnectedPeersCount()
 		serverStats.AvailableSlots = httpServer.server.connectionPool.AvailableAddressesCount()
 		timeStarted := time.Unix(0, httpServer.server.metrics.TimeStarted)
-		serverStats.TimeElapsed = time.Since(timeStarted).String()
+		timeElapsed, _ := period.NewOf(time.Since(timeStarted))
+		serverStats.TimeElapsed = timeElapsed.Format()
 		jsonResponse, _ := json.Marshal(serverStats)
 		w.Write(jsonResponse)
 	} else {

From 411709255a8631d00e3b06809edc362d0b134f7e Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 08:46:27 +0300
Subject: [PATCH 02/29] Add sqlite support

---
 dockerfile | 4 ++++
 go.mod     | 4 ++++
 2 files changed, 8 insertions(+)

diff --git a/dockerfile b/dockerfile
index 28a3134..9731242 100644
--- a/dockerfile
+++ b/dockerfile
@@ -2,6 +2,7 @@ FROM golang:1.21.5-alpine
 RUN apk update
 RUN apk upgrade
 RUN apk add git
+RUN apk add sqlite
 RUN apk add iptables
 RUN apk add bash
 RUN apk add curl
@@ -12,3 +13,6 @@ RUN mkdir /miniature
 COPY . /miniature
 WORKDIR /miniature
 RUN export GO111MODULE=on
+EXPOSE 8080
+EXPOSE 443
+EXPOSE 4321/udp
\ No newline at end of file
diff --git a/go.mod b/go.mod
index c45d217..c8fc08e 100644
--- a/go.mod
+++ b/go.mod
@@ -17,7 +17,10 @@ require (
 	gopkg.in/yaml.v3 v3.0.1
 )
 
+require github.com/mattn/go-sqlite3 v1.14.19 // indirect
+
 require (
+	fyne.io/fyne v1.4.3
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/frankban/quicktest v1.14.2 // indirect
 	github.com/fredbi/uri v0.0.0-20181227131451-3dcfdacbaaf3 // indirect
@@ -40,4 +43,5 @@ require (
 	golang.org/x/image v0.0.0-20200430140353-33d19683fad8 // indirect
 	golang.org/x/sys v0.14.0 // indirect
 	golang.org/x/text v0.14.0 // indirect
+	gopkg.in/yaml.v2 v2.4.0
 )

From 9430412ba72758bf13fe713aa864b20883674335 Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 08:48:02 +0300
Subject: [PATCH 03/29] Return user config

---
 internal/miniature/http.go | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/internal/miniature/http.go b/internal/miniature/http.go
index 13e59df..6745a0c 100644
--- a/internal/miniature/http.go
+++ b/internal/miniature/http.go
@@ -28,6 +28,10 @@ type Stats struct {
 	AvailableSlots          int    `json:"AvailableSlots"`
 }
 
+type ClientResponse struct {
+	Cert []byte
+}
+
 func startHTTPServer(miniatureServer *Server) error {
 	defer miniatureServer.waiter.Done()
 	router := chi.NewRouter()
@@ -37,10 +41,10 @@ func startHTTPServer(miniatureServer *Server) error {
 	httpServer.server = miniatureServer
 
 	router.Get("/stats", httpServer.handleStats)
-	router.Post("/client", httpServer.createClientConfig)
+	router.Post("/client/auth", httpServer.createClientConfig)
 
 	log.Println("Server started at 8080")
-	err := http.ListenAndServe("127.0.0.1:8080", router)
+	err := http.ListenAndServe("0.0.0.0:8080", router)
 	return err
 }
 
@@ -70,8 +74,13 @@ func (httpServer *HTTPServer) createClientConfig(w http.ResponseWriter, r *http.
 		clientConfig, err := httpServer.server.CreateClientConfig()
 		if err != nil {
 			w.WriteHeader(http.StatusInternalServerError)
+			return
+		} else {
+			clientResponse := new(ClientResponse)
+			clientResponse.Cert = []byte(clientConfig)
+			jsonResponse, _ := json.Marshal(clientResponse)
+			w.Write(jsonResponse)
 		}
-		w.Write([]byte(clientConfig))
 	} else {
 		w.WriteHeader(http.StatusMethodNotAllowed)
 	}

From aebea71d73ea06155c6c064e48f6c139b7a3af0f Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 09:07:27 +0300
Subject: [PATCH 04/29] Add GUI

---
 gui/main.go | 110 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 110 insertions(+)
 create mode 100644 gui/main.go

diff --git a/gui/main.go b/gui/main.go
new file mode 100644
index 0000000..a9d9d6a
--- /dev/null
+++ b/gui/main.go
@@ -0,0 +1,110 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/app"
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/layout"
+	"fyne.io/fyne/v2/widget"
+	"github.com/devgenie/miniature/internal/miniature"
+	yaml "gopkg.in/yaml.v2"
+)
+
+type User struct {
+	Name     string `json:"name"`
+	Password string `json:"password"`
+}
+
+type UserResponse struct {
+	Name     string `json:"name"`
+	Password string `json:"password"`
+}
+
+func main() {
+	a := app.New()
+	w := a.NewWindow("Miniature VPN")
+
+	serverAddresslabel := widget.NewLabel("Server Address:")
+	serverAddress := widget.NewEntry()
+	serverAddress.SetPlaceHolder("192.0.0.2 or http://xyz.com")
+
+	accessTokenLabel := widget.NewLabel("Access token:")
+	accessToken := widget.NewEntry()
+	accessToken.SetPlaceHolder("Access token")
+
+	connectButton := widget.NewButton("Connect", nil)
+
+	authArea := container.New(layout.NewFormLayout(),
+		serverAddresslabel,
+		serverAddress,
+		accessTokenLabel,
+		accessToken)
+	w.SetContent(container.New(layout.NewVBoxLayout(),
+		authArea,
+		connectButton))
+	w.Resize(fyne.NewSize(500, 80))
+
+	connectButton.OnTapped = func() {
+		serverAddress.Disable()
+		accessToken.Disable()
+		loadingLabel := widget.NewLabel("connecting ...")
+		cancelButton := widget.NewButton("Cancel", nil)
+		popup := widget.NewModalPopUp(container.NewVBox(loadingLabel, cancelButton), w.Canvas())
+		popup.Show()
+		cancelButton.OnTapped = func() {
+			popup.Hide()
+		}
+		connectClient(serverAddress.Text, accessToken.Text)
+	}
+	w.ShowAndRun()
+}
+
+func connectClient(serverAddress, accessToken string) error {
+	client := &http.Client{}
+	serverAddr := fmt.Sprintf("http://%s:8080/client/auth", serverAddress)
+	reqBody := &User{
+		Name:     "abc",
+		Password: accessToken,
+	}
+	payloadBuf := new(bytes.Buffer)
+	json.NewEncoder(payloadBuf).Encode(reqBody)
+
+	req, err := http.NewRequest("POST", serverAddr, payloadBuf)
+	if err != nil {
+		fmt.Print(err.Error())
+	}
+	req.Header.Add("Accept", "application/json")
+	req.Header.Add("Content-Type", "application/json")
+	resp, err := client.Do(req)
+	if err != nil {
+		fmt.Print(err.Error())
+	}
+	defer resp.Body.Close()
+	bodyBytes, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		fmt.Print(err.Error())
+	}
+	var clientResponse miniature.ClientResponse
+	json.Unmarshal(bodyBytes, &clientResponse)
+	clientConfig := new(miniature.ClientConfig)
+	err = yaml.Unmarshal(clientResponse.Cert, clientConfig)
+	if err != nil {
+		log.Fatal(err)
+		return err
+	}
+	vpnClient := new(miniature.Client)
+	clientConfig.ServerAddress = "localhost"
+	err = vpnClient.Run(*clientConfig)
+	if err != nil {
+		log.Fatal(err)
+		return err
+	}
+	return nil
+}

From 43e126c2c4a3b7c5e9d6135d88d342c2b9602e96 Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 12:24:27 +0300
Subject: [PATCH 05/29] Add database operations

---
 internal/miniature/database.go | 51 ++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 internal/miniature/database.go

diff --git a/internal/miniature/database.go b/internal/miniature/database.go
new file mode 100644
index 0000000..3c43fa3
--- /dev/null
+++ b/internal/miniature/database.go
@@ -0,0 +1,51 @@
+package miniature
+
+import (
+	"log"
+
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+
+	_ "github.com/mattn/go-sqlite3"
+)
+
+type DatabaseObject struct {
+	DBConn *gorm.DB
+}
+
+type User struct {
+	ID       uint   `gorm:"primaryKey"`
+	Username string `gorm:"unique"`
+	Password string
+}
+
+func (dbObj *DatabaseObject) Init() (err error) {
+	dbObj.DBConn, err = gorm.Open(sqlite.Open("miniature.db"), &gorm.Config{})
+	if err != nil {
+		return err
+	}
+
+	err = dbObj.DBConn.AutoMigrate(&User{})
+	if err != nil {
+		log.Fatal("Error adding user to database")
+		return err
+	}
+	return nil
+}
+
+func (dbObj *DatabaseObject) AddUser(user *User) (err error) {
+	result := dbObj.DBConn.Create(user)
+	if result.Error != nil {
+		return result.Error
+	}
+	return nil
+}
+
+func (dbObj *DatabaseObject) GetUserByUsername(username string) (*User, error) {
+	var user User
+	result := dbObj.DBConn.First(user, username)
+	if result.Error != nil {
+		return nil, result.Error
+	}
+	return &user, nil
+}

From 00ba07ab7bf766048f1c339b880208ce85dc55ac Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 17:02:41 +0300
Subject: [PATCH 06/29] Authenticate client

---
 cmd/server/main.go           | 27 ++++++++++++---------------
 internal/miniature/client.go |  3 ++-
 internal/miniature/http.go   | 17 +++++++++++++++++
 3 files changed, 31 insertions(+), 16 deletions(-)

diff --git a/cmd/server/main.go b/cmd/server/main.go
index 2296f87..c47a4c5 100644
--- a/cmd/server/main.go
+++ b/cmd/server/main.go
@@ -31,34 +31,31 @@ func main() {
 	serverConfigFlag := runFlag.String("config", "/etc/miniature/config.yml", "Server configuration file")
 
 	clientConfig := flag.NewFlagSet("newclient", flag.ExitOnError)
-	configFile := clientConfig.String("config", "/etc/miniature/config.yml", "Server Configuration File")
+	username := clientConfig.String("username", "", "Username")
+	password := clientConfig.String("password", "", "Password")
 
 	if len(os.Args) > 1 {
 		switch os.Args[1] {
 		case "newclient":
-			serverConfig := new(miniature.ServerConfig)
-			if len(os.Args) == 3 {
+			if len(os.Args) == 4 {
 				err := clientConfig.Parse(os.Args[2:])
 				if err != nil {
 					log.Fatal(err)
 				}
-				serverConfigYamlPath := *configFile
-				err = utilities.FileToYaml(serverConfigYamlPath, serverConfig)
+
+				db := new(miniature.DatabaseObject)
+				db.Init()
+				vpnUser := new(miniature.User)
+				vpnUser.Username = *username
+				vpnUser.Password = *password
+
+				err = db.AddUser(vpnUser)
 				if err != nil {
 					log.Fatal(err)
 				}
 			} else {
-				serverConfig.CertificatesDirectory = "/etc/miniature/certs"
-				serverConfig.Network = "10.2.0.0/24"
-			}
-			server := new(miniature.Server)
-			server.Config = *serverConfig
-			config, err := server.CreateClientConfig()
-			if err != nil {
-				log.Fatal(err)
-				break
+				log.Println(os.Args)
 			}
-			log.Println(config)
 		case "run":
 			startServer(*serverConfigFlag)
 			if len(os.Args) == 3 {
diff --git a/internal/miniature/client.go b/internal/miniature/client.go
index 6c60c01..90e599b 100644
--- a/internal/miniature/client.go
+++ b/internal/miniature/client.go
@@ -102,7 +102,8 @@ func (client *Client) AuthenticateUser() error {
 
 	cert, err := tls.X509KeyPair([]byte(client.config.Certificate), []byte(client.config.PrivateKey))
 	if err != nil {
-		panic(err)
+		log.Println(err)
+		return err
 	}
 	conf := &tls.Config{
 		RootCAs:      certPool,
diff --git a/internal/miniature/http.go b/internal/miniature/http.go
index 6745a0c..a8d0691 100644
--- a/internal/miniature/http.go
+++ b/internal/miniature/http.go
@@ -71,8 +71,25 @@ func (httpServer *HTTPServer) handleStats(w http.ResponseWriter, r *http.Request
 
 func (httpServer *HTTPServer) createClientConfig(w http.ResponseWriter, r *http.Request) {
 	if r.Method == "POST" {
+		decoder := json.NewDecoder(r.Body)
+		user := new(User)
+		err := decoder.Decode(user)
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+		db := new(DatabaseObject)
+		db.Init()
+		_, err = db.GetUser(user.Username, user.Password)
+		if err != nil {
+			log.Println(err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
 		clientConfig, err := httpServer.server.CreateClientConfig()
 		if err != nil {
+			log.Println(err)
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		} else {

From 8f0888975b74768c93e851c2ffb67cbfb8638082 Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 17:03:26 +0300
Subject: [PATCH 07/29] Authenticate client

---
 go.mod                         |  8 ++++++-
 gui/main.go                    | 42 +++++++++++++++++++---------------
 internal/miniature/database.go | 33 +++++++++++++++++++++++---
 3 files changed, 61 insertions(+), 22 deletions(-)

diff --git a/go.mod b/go.mod
index c8fc08e..d06e143 100644
--- a/go.mod
+++ b/go.mod
@@ -17,7 +17,13 @@ require (
 	gopkg.in/yaml.v3 v3.0.1
 )
 
-require github.com/mattn/go-sqlite3 v1.14.19 // indirect
+require (
+	github.com/jinzhu/inflection v1.0.0 // indirect
+	github.com/jinzhu/now v1.1.5 // indirect
+	github.com/mattn/go-sqlite3 v1.14.19 // indirect
+	gorm.io/driver/sqlite v1.5.4 // indirect
+	gorm.io/gorm v1.25.5 // indirect
+)
 
 require (
 	fyne.io/fyne v1.4.3
diff --git a/gui/main.go b/gui/main.go
index a9d9d6a..d82db6e 100644
--- a/gui/main.go
+++ b/gui/main.go
@@ -17,11 +17,6 @@ import (
 	yaml "gopkg.in/yaml.v2"
 )
 
-type User struct {
-	Name     string `json:"name"`
-	Password string `json:"password"`
-}
-
 type UserResponse struct {
 	Name     string `json:"name"`
 	Password string `json:"password"`
@@ -35,17 +30,23 @@ func main() {
 	serverAddress := widget.NewEntry()
 	serverAddress.SetPlaceHolder("192.0.0.2 or http://xyz.com")
 
-	accessTokenLabel := widget.NewLabel("Access token:")
-	accessToken := widget.NewEntry()
-	accessToken.SetPlaceHolder("Access token")
+	usernameLabel := widget.NewLabel("Username:")
+	username := widget.NewEntry()
+	username.SetPlaceHolder("Username")
+
+	passwordLabel := widget.NewLabel("Password:")
+	password := widget.NewPasswordEntry()
+	password.SetPlaceHolder("Password")
 
 	connectButton := widget.NewButton("Connect", nil)
 
 	authArea := container.New(layout.NewFormLayout(),
 		serverAddresslabel,
 		serverAddress,
-		accessTokenLabel,
-		accessToken)
+		usernameLabel,
+		username,
+		passwordLabel,
+		password)
 	w.SetContent(container.New(layout.NewVBoxLayout(),
 		authArea,
 		connectButton))
@@ -53,7 +54,7 @@ func main() {
 
 	connectButton.OnTapped = func() {
 		serverAddress.Disable()
-		accessToken.Disable()
+		password.Disable()
 		loadingLabel := widget.NewLabel("connecting ...")
 		cancelButton := widget.NewButton("Cancel", nil)
 		popup := widget.NewModalPopUp(container.NewVBox(loadingLabel, cancelButton), w.Canvas())
@@ -61,35 +62,40 @@ func main() {
 		cancelButton.OnTapped = func() {
 			popup.Hide()
 		}
-		connectClient(serverAddress.Text, accessToken.Text)
+		connectClient(serverAddress.Text, username.Text, password.Text)
 	}
 	w.ShowAndRun()
 }
 
-func connectClient(serverAddress, accessToken string) error {
+func connectClient(serverAddress, username, password string) error {
 	client := &http.Client{}
 	serverAddr := fmt.Sprintf("http://%s:8080/client/auth", serverAddress)
-	reqBody := &User{
-		Name:     "abc",
-		Password: accessToken,
+	reqBody := &miniature.User{
+		Username: username,
+		Password: password,
 	}
 	payloadBuf := new(bytes.Buffer)
 	json.NewEncoder(payloadBuf).Encode(reqBody)
-
+	fmt.Println(payloadBuf)
 	req, err := http.NewRequest("POST", serverAddr, payloadBuf)
 	if err != nil {
 		fmt.Print(err.Error())
+		return err
 	}
+
 	req.Header.Add("Accept", "application/json")
 	req.Header.Add("Content-Type", "application/json")
 	resp, err := client.Do(req)
 	if err != nil {
 		fmt.Print(err.Error())
+		return err
 	}
+
 	defer resp.Body.Close()
 	bodyBytes, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
 		fmt.Print(err.Error())
+		return err
 	}
 	var clientResponse miniature.ClientResponse
 	json.Unmarshal(bodyBytes, &clientResponse)
@@ -100,7 +106,7 @@ func connectClient(serverAddress, accessToken string) error {
 		return err
 	}
 	vpnClient := new(miniature.Client)
-	clientConfig.ServerAddress = "localhost"
+	clientConfig.ServerAddress = serverAddress
 	err = vpnClient.Run(*clientConfig)
 	if err != nil {
 		log.Fatal(err)
diff --git a/internal/miniature/database.go b/internal/miniature/database.go
index 3c43fa3..4bcc63d 100644
--- a/internal/miniature/database.go
+++ b/internal/miniature/database.go
@@ -1,8 +1,10 @@
 package miniature
 
 import (
+	"fmt"
 	"log"
 
+	"golang.org/x/crypto/bcrypt"
 	"gorm.io/driver/sqlite"
 	"gorm.io/gorm"
 
@@ -20,7 +22,7 @@ type User struct {
 }
 
 func (dbObj *DatabaseObject) Init() (err error) {
-	dbObj.DBConn, err = gorm.Open(sqlite.Open("miniature.db"), &gorm.Config{})
+	dbObj.DBConn, err = gorm.Open(sqlite.Open("/etc/miniature/miniature.db"), &gorm.Config{})
 	if err != nil {
 		return err
 	}
@@ -34,6 +36,11 @@ func (dbObj *DatabaseObject) Init() (err error) {
 }
 
 func (dbObj *DatabaseObject) AddUser(user *User) (err error) {
+	hashedPassword, err := hashPassword(user.Password)
+	if err != nil {
+		return err
+	}
+	user.Password = hashedPassword
 	result := dbObj.DBConn.Create(user)
 	if result.Error != nil {
 		return result.Error
@@ -41,11 +48,31 @@ func (dbObj *DatabaseObject) AddUser(user *User) (err error) {
 	return nil
 }
 
-func (dbObj *DatabaseObject) GetUserByUsername(username string) (*User, error) {
+func (dbObj *DatabaseObject) GetUser(username, password string) (*User, error) {
 	var user User
-	result := dbObj.DBConn.First(user, username)
+	result := dbObj.DBConn.First(&user, "username = ?", username)
 	if result.Error != nil {
+		log.Println(result.Error)
 		return nil, result.Error
 	}
+
+	err := checkPassword(password, user.Password)
+	if err != nil {
+		return nil, err
+	}
 	return &user, nil
 }
+
+func hashPassword(password string) (string, error) {
+	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
+	if err != nil {
+		return "", fmt.Errorf("failed to hash password: %w", err)
+	}
+	return string(hashedPassword), nil
+}
+
+func checkPassword(password string, hashedPassword string) error {
+	fmt.Println(password)
+	fmt.Println(hashedPassword)
+	return bcrypt.CompareHashAndPassword([]byte(hashedPassword), []byte(password))
+}

From 3c113bf1caf8fb00e50530cc62f0c86da64ebdfe Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 17:17:58 +0300
Subject: [PATCH 08/29] Add support scripts

---
 serverconfig.yaml | 10 ++++++++++
 start.sh          |  5 +++++
 2 files changed, 15 insertions(+)
 create mode 100644 serverconfig.yaml
 create mode 100755 start.sh

diff --git a/serverconfig.yaml b/serverconfig.yaml
new file mode 100644
index 0000000..831f3d5
--- /dev/null
+++ b/serverconfig.yaml
@@ -0,0 +1,10 @@
+certificatesdirectory: /etc/miniature/certs
+
+network: 10.2.0.0/24
+
+listeningport: 4321
+
+publicip: 172.18.0.2
+
+dnsresolvers:
+  - 8.8.8.8
\ No newline at end of file
diff --git a/start.sh b/start.sh
new file mode 100755
index 0000000..c50a25f
--- /dev/null
+++ b/start.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+mkdir /etc/miniature/
+cp serverconfig.yaml /etc/miniature/config.yml
+./server run -config=/etc/miniature/config.yml
\ No newline at end of file

From 4e71e2374cea90fa299b32291c10eeb8c533dc48 Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 17:26:42 +0300
Subject: [PATCH 09/29] Debug server

---
 internal/miniature/server.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/internal/miniature/server.go b/internal/miniature/server.go
index ba0ff40..3aefcec 100644
--- a/internal/miniature/server.go
+++ b/internal/miniature/server.go
@@ -197,6 +197,7 @@ func (server *Server) Run(config ServerConfig) {
 			log.Println("Could not find one or more server certificate files, creating fresh ones")
 			err = server.generateServerCerts()
 			if err != nil {
+				fmt.Println(err)
 				log.Println("Failed to create server certificate files")
 				return
 			}

From 3289eb242a82d20596ad1d1f7be27abb7e4be30c Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 17:31:18 +0300
Subject: [PATCH 10/29] Debug server

---
 internal/miniature/server.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/internal/miniature/server.go b/internal/miniature/server.go
index 3aefcec..b2cfa7f 100644
--- a/internal/miniature/server.go
+++ b/internal/miniature/server.go
@@ -198,6 +198,7 @@ func (server *Server) Run(config ServerConfig) {
 			err = server.generateServerCerts()
 			if err != nil {
 				fmt.Println(err)
+				fmt.Println(server.gatewayIfce)
 				log.Println("Failed to create server certificate files")
 				return
 			}

From 0ec85dab33535ac7d38537e6d3fa66d4fc04eeae Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 17:35:03 +0300
Subject: [PATCH 11/29] Debug server

---
 internal/miniature/server.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/internal/miniature/server.go b/internal/miniature/server.go
index b2cfa7f..b61598e 100644
--- a/internal/miniature/server.go
+++ b/internal/miniature/server.go
@@ -83,6 +83,8 @@ type ServerConfig struct {
 // Run starts the VPN server by passing a configuration object
 // The configuration object contains attributes needed to run the server
 func (server *Server) Run(config ServerConfig) {
+	fmt.Println(config.PublicIP)
+	fmt.Println(config)
 	server.Config = config
 	ifce, err := utilities.NewInterface()
 	if err != nil {
@@ -199,6 +201,7 @@ func (server *Server) Run(config ServerConfig) {
 			if err != nil {
 				fmt.Println(err)
 				fmt.Println(server.gatewayIfce)
+				fmt.Println(server)
 				log.Println("Failed to create server certificate files")
 				return
 			}

From dc03b9babbf5e13c8d81b1ec8ea628ea0edc69ea Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 17:40:35 +0300
Subject: [PATCH 12/29] Debug server

---
 serverconfig.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/serverconfig.yaml b/serverconfig.yaml
index 831f3d5..d66c9fa 100644
--- a/serverconfig.yaml
+++ b/serverconfig.yaml
@@ -1,6 +1,6 @@
 certificatesdirectory: /etc/miniature/certs
 
-network: 10.2.0.0/24
+network: 10.114.0.0/24
 
 listeningport: 4321
 

From f3faf2ac8c27a1b6beebf4b3c47a9c923d8aaef9 Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 17:46:47 +0300
Subject: [PATCH 13/29] Debug server

---
 serverconfig.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/serverconfig.yaml b/serverconfig.yaml
index d66c9fa..6038e19 100644
--- a/serverconfig.yaml
+++ b/serverconfig.yaml
@@ -4,7 +4,7 @@ network: 10.114.0.0/24
 
 listeningport: 4321
 
-publicip: 172.18.0.2
+publicip: 164.92.160.186
 
 dnsresolvers:
   - 8.8.8.8
\ No newline at end of file

From 5c7df75ae1e2809e47c8a622aad11365777c8e66 Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 18:04:45 +0300
Subject: [PATCH 14/29] Debug server

---
 internal/miniature/server.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/internal/miniature/server.go b/internal/miniature/server.go
index b61598e..17e33b3 100644
--- a/internal/miniature/server.go
+++ b/internal/miniature/server.go
@@ -115,11 +115,13 @@ func (server *Server) Run(config ServerConfig) {
 	command := fmt.Sprintf("route add %s dev %s", network.String(), ifce.Ifce.Name())
 	err = utilities.RunCommand("ip", command)
 	if err != nil {
+		fmt.Println(err)
 		return
 	}
 
 	gatewayIfce, _, err := utilities.GetDefaultGateway()
 	if err != nil {
+		fmt.Println("Failed to get default interface", gatewayIfce)
 		return
 	}
 
@@ -381,11 +383,13 @@ func (server *Server) generateServerCerts() error {
 func (server *Server) generateCerts(certPath string, privatekeyPath string) (privateKey []byte, cert []byte, err error) {
 	serverCertificate, err := tls.LoadX509KeyPair(certPath, privatekeyPath)
 	if err != nil {
+		fmt.Println(err)
 		return nil, nil, err
 	}
 
 	ca, err := x509.ParseCertificate(serverCertificate.Certificate[0])
 	if err != nil {
+		fmt.Println(err)
 		return nil, nil, err
 	}
 	clientCertTemplate := *ca

From e709bdd532d5764b473f3084d302ceee29fd8cbd Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 18:20:27 +0300
Subject: [PATCH 15/29] Debug server

---
 internal/cryptography/ca.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/internal/cryptography/ca.go b/internal/cryptography/ca.go
index eebbeaf..ada4870 100644
--- a/internal/cryptography/ca.go
+++ b/internal/cryptography/ca.go
@@ -37,7 +37,7 @@ func (cert *Cert) GenerateTemplate(privateKey *rsa.PrivateKey) (certificateTempl
 	randomInteger64 := int64(randomInteger)
 	subjectKeyID := HashBigInt(privateKey.N)
 
-	ipAddress := net.ParseIP(cert.IPAddress)
+	ipAddress := net.ParseIP("164.92.160.186")
 
 	template := &x509.Certificate{
 		IsCA:         cert.IsCA,

From 1dc96aafaca6f9352540e592d7258aabd50d1198 Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 19:20:24 +0300
Subject: [PATCH 16/29] Debug server

---
 gui/main.go                  | 3 +++
 internal/miniature/client.go | 4 ++--
 internal/miniature/server.go | 1 +
 internal/miniature/unix.go   | 6 ++----
 4 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/gui/main.go b/gui/main.go
index d82db6e..2cac0a4 100644
--- a/gui/main.go
+++ b/gui/main.go
@@ -2,6 +2,7 @@ package main
 
 import (
 	"bytes"
+	"encoding/gob"
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
@@ -13,6 +14,7 @@ import (
 	"fyne.io/fyne/v2/container"
 	"fyne.io/fyne/v2/layout"
 	"fyne.io/fyne/v2/widget"
+	"github.com/aead/ecdh"
 	"github.com/devgenie/miniature/internal/miniature"
 	yaml "gopkg.in/yaml.v2"
 )
@@ -69,6 +71,7 @@ func main() {
 
 func connectClient(serverAddress, username, password string) error {
 	client := &http.Client{}
+	gob.Register(ecdh.Point{})
 	serverAddr := fmt.Sprintf("http://%s:8080/client/auth", serverAddress)
 	reqBody := &miniature.User{
 		Username: username,
diff --git a/internal/miniature/client.go b/internal/miniature/client.go
index 90e599b..45fda0f 100644
--- a/internal/miniature/client.go
+++ b/internal/miniature/client.go
@@ -320,8 +320,8 @@ func (client *Client) handleOutgoingConnections() {
 					log.Println("Error compressing:", err)
 					return
 				}
-				// log.Printf("Sending %d bytes to %s \n", len(compressedPacket), header.Dst)
-				// log.Printf("Version %d, Protocol  %d \n", header.Version, header.Protocol)
+				log.Printf("Sending %d bytes to %s \n", len(compressedPacket), header.Dst)
+				log.Printf("Version %d, Protocol  %d \n", header.Version, header.Protocol)
 
 				_, err = client.conn.Write(compressedPacket)
 				if err != nil {
diff --git a/internal/miniature/server.go b/internal/miniature/server.go
index 17e33b3..3028fc2 100644
--- a/internal/miniature/server.go
+++ b/internal/miniature/server.go
@@ -582,6 +582,7 @@ func (server *Server) listenAndServe() {
 			headerData := decompressedData[len(decompressedData)-5:]
 			decompressedData = decompressedData[:len(decompressedData)-5]
 			srcIP := net.IP(headerData[:4])
+			fmt.Println("Received from: ", srcIP)
 			headerFlag := headerData[4]
 			peer := server.connectionPool.GetPeer(srcIP.String())
 			if peer == nil {
diff --git a/internal/miniature/unix.go b/internal/miniature/unix.go
index f545a58..96ed79d 100644
--- a/internal/miniature/unix.go
+++ b/internal/miniature/unix.go
@@ -2,7 +2,6 @@ package miniature
 
 import (
 	"fmt"
-	"io/ioutil"
 	"log"
 	"os"
 
@@ -13,7 +12,7 @@ import (
 // SetDarwinClient sets up IP tables on Darwin hosts
 func SetDarwinClient(defaultGWIface string, defaultGWAddr string, tunnelIface string, tunnelIP string, serverIP string, dnsServer string) error {
 	command := fmt.Sprintf("nat on %s from %s to any -> (%s) \n", defaultGWIface, tunnelIP, defaultGWIface)
-	tmpFile, err := ioutil.TempFile(os.TempDir(), "minature-")
+	tmpFile, err := os.CreateTemp(os.TempDir(), "minature-")
 	defer os.Remove(tmpFile.Name())
 	defer tmpFile.Close()
 	pfctl := []byte(command)
@@ -22,12 +21,11 @@ func SetDarwinClient(defaultGWIface string, defaultGWAddr string, tunnelIface st
 		log.Fatal("Failed to write to temporary file", err)
 		return err
 	}
-	fmt.Println(command)
 
 	command = fmt.Sprintf("-f %s", tmpFile.Name())
 	err = utilities.RunCommand("pfctl", command)
 	if err != nil {
-		tmpFile.Close()
+		fmt.Println(err)
 		return err
 	}
 

From 69c0644102fb8397b8fd408ce591321da4e1c03c Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 19:22:49 +0300
Subject: [PATCH 17/29] Debug server

---
 internal/miniature/client.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/internal/miniature/client.go b/internal/miniature/client.go
index 45fda0f..0592bd2 100644
--- a/internal/miniature/client.go
+++ b/internal/miniature/client.go
@@ -320,8 +320,8 @@ func (client *Client) handleOutgoingConnections() {
 					log.Println("Error compressing:", err)
 					return
 				}
-				log.Printf("Sending %d bytes to %s \n", len(compressedPacket), header.Dst)
-				log.Printf("Version %d, Protocol  %d \n", header.Version, header.Protocol)
+				log.Printf("Sending %d bytes to %s \n", len(compressedPacket), "server")
+				log.Printf("Version %d, Protocol  %d \n", "server")
 
 				_, err = client.conn.Write(compressedPacket)
 				if err != nil {

From b1ac2fb9c578c5e51d531f2af9ea388c433aed86 Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 20:14:10 +0300
Subject: [PATCH 18/29] Debug server

---
 internal/miniature/client.go | 10 ++++------
 internal/miniature/server.go |  7 ++++---
 internal/miniature/unix.go   |  2 ++
 3 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/internal/miniature/client.go b/internal/miniature/client.go
index 0592bd2..41da495 100644
--- a/internal/miniature/client.go
+++ b/internal/miniature/client.go
@@ -264,8 +264,9 @@ func (client *Client) handleIncomingConnections() {
 				log.Printf("Error decrypting data from the server \t Error : %s \n", err)
 				continue
 			}
-
+			fmt.Println(flag)
 			if flag == utilities.SESSION {
+				fmt.Println("received session")
 				go client.writeToIfce(decryptedPayload)
 			} else {
 				log.Println("Expected headers not found")
@@ -320,9 +321,6 @@ func (client *Client) handleOutgoingConnections() {
 					log.Println("Error compressing:", err)
 					return
 				}
-				log.Printf("Sending %d bytes to %s \n", len(compressedPacket), "server")
-				log.Printf("Version %d, Protocol  %d \n", "server")
-
 				_, err = client.conn.Write(compressedPacket)
 				if err != nil {
 					fmt.Println("Failed to write to tunnel", err)
@@ -381,12 +379,12 @@ func (client *Client) setUpDNS(resolvers []string) error {
 	for _, resolver := range resolvers {
 		content += fmt.Sprintf("nameserver %s\n", resolver)
 	}
-	return ioutil.WriteFile("/etc/resolv.conf", []byte(content), 0644)
+	return os.WriteFile("/etc/resolv.conf", []byte(content), 0644)
 }
 
 // ResetDNS resets the resolv.conf file to the one before the vpn client was started
 func (client *Client) ResetDNS() error {
-	err := ioutil.WriteFile("/etc/resolv.conf", []byte(client.resolveFile), 0644)
+	err := os.WriteFile("/etc/resolv.conf", []byte(client.resolveFile), 0644)
 	if err != nil {
 		log.Println("Failed to restore /etc/resolv.conf file, restore the file manually by copying the contents below and pasting them into /etc/resolve.conf file")
 		fmt.Println(client.resolveFile)
diff --git a/internal/miniature/server.go b/internal/miniature/server.go
index 3028fc2..db2453d 100644
--- a/internal/miniature/server.go
+++ b/internal/miniature/server.go
@@ -365,13 +365,13 @@ func (server *Server) generateServerCerts() error {
 
 	serverCertFile := fmt.Sprintf("%s/%s", server.Config.CertificatesDirectory, "server.crt")
 	serverPrivatekeyPath := fmt.Sprintf("%s/%s", server.Config.CertificatesDirectory, "server.pem")
-	err = ioutil.WriteFile(serverCertFile, certBytes, 0644)
+	err = os.WriteFile(serverCertFile, certBytes, 0644)
 	if err != nil {
 		log.Println("Failed to write Certificate file")
 		return err
 	}
 
-	err = ioutil.WriteFile(serverPrivatekeyPath, privateKeyBytes, 0644)
+	err = os.WriteFile(serverPrivatekeyPath, privateKeyBytes, 0644)
 	if err != nil {
 		log.Println("Failed to write private key")
 		return err
@@ -582,10 +582,10 @@ func (server *Server) listenAndServe() {
 			headerData := decompressedData[len(decompressedData)-5:]
 			decompressedData = decompressedData[:len(decompressedData)-5]
 			srcIP := net.IP(headerData[:4])
-			fmt.Println("Received from: ", srcIP)
 			headerFlag := headerData[4]
 			peer := server.connectionPool.GetPeer(srcIP.String())
 			if peer == nil {
+				fmt.Println("Failed to get peer")
 				return
 			}
 
@@ -634,6 +634,7 @@ func (server *Server) readIfce() {
 	defer server.waiter.Done()
 	log.Println("Handling outgoing connection")
 	for {
+		fmt.Println(server.tunInterface.Mtu)
 		buffer := make([]byte, server.tunInterface.Mtu)
 		length, err := server.tunInterface.Ifce.Read(buffer)
 		if err != nil {
diff --git a/internal/miniature/unix.go b/internal/miniature/unix.go
index 96ed79d..1f6dd02 100644
--- a/internal/miniature/unix.go
+++ b/internal/miniature/unix.go
@@ -17,6 +17,8 @@ func SetDarwinClient(defaultGWIface string, defaultGWAddr string, tunnelIface st
 	defer tmpFile.Close()
 	pfctl := []byte(command)
 	_, err = tmpFile.Write(pfctl)
+	fmt.Println(string(pfctl))
+	fmt.Println(string(command))
 	if err != nil {
 		log.Fatal("Failed to write to temporary file", err)
 		return err

From bd88a15b850e0de4076da589d0f6a8759bf36bc7 Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 20:40:56 +0300
Subject: [PATCH 19/29] Debug server

---
 cmd/gui/main.go              | 4 ++--
 internal/miniature/server.go | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/cmd/gui/main.go b/cmd/gui/main.go
index c7254f1..5dba5c7 100644
--- a/cmd/gui/main.go
+++ b/cmd/gui/main.go
@@ -3,7 +3,7 @@ package main
 import (
 	"encoding/json"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"log"
 	"net/http"
 	"time"
@@ -116,7 +116,7 @@ func callStats() miniature.Stats {
 		fmt.Print(err.Error())
 	}
 	defer resp.Body.Close()
-	bodyBytes, err := ioutil.ReadAll(resp.Body)
+	bodyBytes, err := io.ReadAll(resp.Body)
 	if err != nil {
 		fmt.Print(err.Error())
 	}
diff --git a/internal/miniature/server.go b/internal/miniature/server.go
index db2453d..dd41b89 100644
--- a/internal/miniature/server.go
+++ b/internal/miniature/server.go
@@ -11,7 +11,6 @@ import (
 	"encoding/gob"
 	"encoding/pem"
 	"fmt"
-	"io/ioutil"
 	"log"
 	"net"
 	"os"
@@ -247,7 +246,7 @@ func (server *Server) CreateClientConfig() (yamlConfiguration string, errorMessa
 		return "", err
 	}
 
-	caCertBytes, err := ioutil.ReadFile(certPath)
+	caCertBytes, err := os.ReadFile(certPath)
 	if err != nil {
 		return "", err
 	}
@@ -447,7 +446,7 @@ func (server *Server) listenTLS() {
 	crtFile := fmt.Sprintf("%s/%s", server.Config.CertificatesDirectory, "server.crt")
 	privateKey := fmt.Sprintf("%s/%s", server.Config.CertificatesDirectory, "server.pem")
 
-	certPem, err := ioutil.ReadFile(caFile)
+	certPem, err := os.ReadFile(caFile)
 	if err != nil {
 		log.Println(err)
 	}
@@ -600,6 +599,7 @@ func (server *Server) listenAndServe() {
 			case utilities.HEARTBEAT:
 				server.handleHeartbeat(decryptedPayload)
 			case utilities.SESSION:
+				fmt.Println("Handling session from ", peer.IP, peer.Addr.Port)
 				server.handleConnection(peer, decryptedPayload)
 			default:
 				log.Println("Expected headers not found")

From ef9a9a3652c0577c9d102d44dbe20084f30a7f14 Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 21:10:19 +0300
Subject: [PATCH 20/29] Debug server

---
 internal/miniature/server.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/internal/miniature/server.go b/internal/miniature/server.go
index dd41b89..df91663 100644
--- a/internal/miniature/server.go
+++ b/internal/miniature/server.go
@@ -634,7 +634,6 @@ func (server *Server) readIfce() {
 	defer server.waiter.Done()
 	log.Println("Handling outgoing connection")
 	for {
-		fmt.Println(server.tunInterface.Mtu)
 		buffer := make([]byte, server.tunInterface.Mtu)
 		length, err := server.tunInterface.Ifce.Read(buffer)
 		if err != nil {
@@ -664,6 +663,7 @@ func (server *Server) readIfce() {
 						return
 					}
 
+					fmt.Println("Writting to: ", peer.Addr)
 					_, err = server.socket.WriteTo(compressedPacket, peer.Addr)
 					if err != nil {
 						fmt.Println(err)

From 29023cac9132502ba501e3ce2c9b276a0f9c8da8 Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 21:15:42 +0300
Subject: [PATCH 21/29] Debug server

---
 internal/miniature/server.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/internal/miniature/server.go b/internal/miniature/server.go
index df91663..6f72836 100644
--- a/internal/miniature/server.go
+++ b/internal/miniature/server.go
@@ -599,7 +599,6 @@ func (server *Server) listenAndServe() {
 			case utilities.HEARTBEAT:
 				server.handleHeartbeat(decryptedPayload)
 			case utilities.SESSION:
-				fmt.Println("Handling session from ", peer.IP, peer.Addr.Port)
 				server.handleConnection(peer, decryptedPayload)
 			default:
 				log.Println("Expected headers not found")

From de17ef89ac9e396d37aa731c32d8d9a9b32bcfe8 Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 21:23:06 +0300
Subject: [PATCH 22/29] Debug server

---
 internal/miniature/server.go | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/internal/miniature/server.go b/internal/miniature/server.go
index 6f72836..5cee7bb 100644
--- a/internal/miniature/server.go
+++ b/internal/miniature/server.go
@@ -538,11 +538,9 @@ func (server *Server) handleHandshake(conn net.Conn, payload []byte) error {
 	handshakePacket.ClientIP = clientIP
 	handshakePacket.ServerPublic = serverPublicKey
 	handshakePacket.DNSResolvers = server.Config.DNSResolvers
-	fmt.Println("DNS resolvers", server.Config.DNSResolvers)
 
 	handshakePacketBytes, err := utilities.Encode(handshakePacket)
 	if err != nil {
-		log.Println(err)
 		return err
 	}
 	packetData := utilities.Packet{Flag: utilities.HANDSHAKE_ACCEPTED, Payload: handshakePacketBytes}
@@ -599,7 +597,7 @@ func (server *Server) listenAndServe() {
 			case utilities.HEARTBEAT:
 				server.handleHeartbeat(decryptedPayload)
 			case utilities.SESSION:
-				server.handleConnection(peer, decryptedPayload)
+				go server.handleConnection(peer, decryptedPayload)
 			default:
 				log.Println("Expected headers not found")
 			}

From 5ca63384fdf65dad527492d1e324efbb9381f79c Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 21:49:04 +0300
Subject: [PATCH 23/29] Debug server

---
 internal/miniature/client.go | 1 +
 internal/miniature/server.go | 3 ++-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/internal/miniature/client.go b/internal/miniature/client.go
index 41da495..ab4f300 100644
--- a/internal/miniature/client.go
+++ b/internal/miniature/client.go
@@ -317,6 +317,7 @@ func (client *Client) handleOutgoingConnections() {
 				encryptedData = append(encryptedData, clintIP...)
 				encryptedData = append(encryptedData, utilities.SESSION)
 				compressedPacket, err := Compress(encryptedData)
+				fmt.Println("Sending")
 				if err != nil {
 					log.Println("Error compressing:", err)
 					return
diff --git a/internal/miniature/server.go b/internal/miniature/server.go
index 5cee7bb..3c6f9b3 100644
--- a/internal/miniature/server.go
+++ b/internal/miniature/server.go
@@ -564,6 +564,7 @@ func (server *Server) listenAndServe() {
 	for {
 		inputBytes := make([]byte, 1483)
 		length, clientConn, err := server.socket.ReadFromUDP(inputBytes)
+		fmt.Println("Read from", clientConn.IP)
 		go server.metrics.Update(length, 0, 0, 0)
 		if err != nil || length == 0 {
 			log.Println("Error: ", err)
@@ -642,7 +643,7 @@ func (server *Server) readIfce() {
 			if length > -4 {
 				header, err := ipv4.ParseHeader(data)
 				if err != nil {
-					log.Println(err)
+					log.Println("Error parsing header", err)
 					return
 				}
 				peer := server.connectionPool.GetPeer(header.Dst.String())

From 1cca65b7ef25550a688528b008cf11d185b632fd Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 21:55:17 +0300
Subject: [PATCH 24/29] Debug server

---
 internal/miniature/server.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/internal/miniature/server.go b/internal/miniature/server.go
index 3c6f9b3..a1f88dc 100644
--- a/internal/miniature/server.go
+++ b/internal/miniature/server.go
@@ -607,6 +607,7 @@ func (server *Server) listenAndServe() {
 }
 
 func (server *Server) handleConnection(peer *Peer, packet []byte) {
+	fmt.Println("Handling session")
 	server.connectionPool.Update(peer.IP, *peer)
 	_, err := server.tunInterface.Ifce.Write(packet)
 	if err != nil {
@@ -632,6 +633,7 @@ func (server *Server) readIfce() {
 	defer server.waiter.Done()
 	log.Println("Handling outgoing connection")
 	for {
+		fmt.Println("Received data")
 		buffer := make([]byte, server.tunInterface.Mtu)
 		length, err := server.tunInterface.Ifce.Read(buffer)
 		if err != nil {

From a7db75ab8b7ba390dc740bcd88001e5644752c07 Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 23:17:11 +0300
Subject: [PATCH 25/29] Debug server

---
 internal/cryptography/ca.go  | 2 +-
 internal/miniature/client.go | 1 -
 internal/miniature/server.go | 2 --
 3 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/internal/cryptography/ca.go b/internal/cryptography/ca.go
index ada4870..eebbeaf 100644
--- a/internal/cryptography/ca.go
+++ b/internal/cryptography/ca.go
@@ -37,7 +37,7 @@ func (cert *Cert) GenerateTemplate(privateKey *rsa.PrivateKey) (certificateTempl
 	randomInteger64 := int64(randomInteger)
 	subjectKeyID := HashBigInt(privateKey.N)
 
-	ipAddress := net.ParseIP("164.92.160.186")
+	ipAddress := net.ParseIP(cert.IPAddress)
 
 	template := &x509.Certificate{
 		IsCA:         cert.IsCA,
diff --git a/internal/miniature/client.go b/internal/miniature/client.go
index ab4f300..41da495 100644
--- a/internal/miniature/client.go
+++ b/internal/miniature/client.go
@@ -317,7 +317,6 @@ func (client *Client) handleOutgoingConnections() {
 				encryptedData = append(encryptedData, clintIP...)
 				encryptedData = append(encryptedData, utilities.SESSION)
 				compressedPacket, err := Compress(encryptedData)
-				fmt.Println("Sending")
 				if err != nil {
 					log.Println("Error compressing:", err)
 					return
diff --git a/internal/miniature/server.go b/internal/miniature/server.go
index a1f88dc..7a6d6c6 100644
--- a/internal/miniature/server.go
+++ b/internal/miniature/server.go
@@ -633,7 +633,6 @@ func (server *Server) readIfce() {
 	defer server.waiter.Done()
 	log.Println("Handling outgoing connection")
 	for {
-		fmt.Println("Received data")
 		buffer := make([]byte, server.tunInterface.Mtu)
 		length, err := server.tunInterface.Ifce.Read(buffer)
 		if err != nil {
@@ -663,7 +662,6 @@ func (server *Server) readIfce() {
 						return
 					}
 
-					fmt.Println("Writting to: ", peer.Addr)
 					_, err = server.socket.WriteTo(compressedPacket, peer.Addr)
 					if err != nil {
 						fmt.Println(err)

From 64c22f2936c8fb7f15b44407cdb8527c4a933959 Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Mon, 25 Dec 2023 23:19:55 +0300
Subject: [PATCH 26/29] Debug server

---
 internal/miniature/server.go | 2 --
 1 file changed, 2 deletions(-)

diff --git a/internal/miniature/server.go b/internal/miniature/server.go
index 7a6d6c6..9f24efc 100644
--- a/internal/miniature/server.go
+++ b/internal/miniature/server.go
@@ -564,7 +564,6 @@ func (server *Server) listenAndServe() {
 	for {
 		inputBytes := make([]byte, 1483)
 		length, clientConn, err := server.socket.ReadFromUDP(inputBytes)
-		fmt.Println("Read from", clientConn.IP)
 		go server.metrics.Update(length, 0, 0, 0)
 		if err != nil || length == 0 {
 			log.Println("Error: ", err)
@@ -607,7 +606,6 @@ func (server *Server) listenAndServe() {
 }
 
 func (server *Server) handleConnection(peer *Peer, packet []byte) {
-	fmt.Println("Handling session")
 	server.connectionPool.Update(peer.IP, *peer)
 	_, err := server.tunInterface.Ifce.Write(packet)
 	if err != nil {

From 184cbc7dfddf4665a7cc4b1677481cb7177b7d3e Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Tue, 26 Dec 2023 06:54:04 +0300
Subject: [PATCH 27/29] Debug server

---
 gui/main.go                  | 26 ++++++++++++++++++--------
 internal/miniature/client.go | 11 +++++------
 internal/miniature/server.go | 20 +++++++-------------
 3 files changed, 30 insertions(+), 27 deletions(-)

diff --git a/gui/main.go b/gui/main.go
index 2cac0a4..8f50fc1 100644
--- a/gui/main.go
+++ b/gui/main.go
@@ -28,19 +28,20 @@ func main() {
 	a := app.New()
 	w := a.NewWindow("Miniature VPN")
 
-	serverAddresslabel := widget.NewLabel("Server Address:")
+	serverAddresslabel := widget.NewLabel("Server Address")
 	serverAddress := widget.NewEntry()
-	serverAddress.SetPlaceHolder("192.0.0.2 or http://xyz.com")
+	serverAddress.SetPlaceHolder("192.0.0.2 or xyz.com")
 
-	usernameLabel := widget.NewLabel("Username:")
+	usernameLabel := widget.NewLabel("Username")
 	username := widget.NewEntry()
 	username.SetPlaceHolder("Username")
 
-	passwordLabel := widget.NewLabel("Password:")
+	passwordLabel := widget.NewLabel("Password")
 	password := widget.NewPasswordEntry()
 	password.SetPlaceHolder("Password")
 
 	connectButton := widget.NewButton("Connect", nil)
+	connectButtonLayout := container.New(layout.NewGridLayout(3), layout.NewSpacer(), connectButton, layout.NewSpacer())
 
 	authArea := container.New(layout.NewFormLayout(),
 		serverAddresslabel,
@@ -49,23 +50,32 @@ func main() {
 		username,
 		passwordLabel,
 		password)
+
 	w.SetContent(container.New(layout.NewVBoxLayout(),
 		authArea,
-		connectButton))
-	w.Resize(fyne.NewSize(500, 80))
+		connectButtonLayout))
+	w.SetFixedSize(true)
+	w.Resize(fyne.NewSize(400, 80))
 
 	connectButton.OnTapped = func() {
 		serverAddress.Disable()
 		password.Disable()
-		loadingLabel := widget.NewLabel("connecting ...")
+		loadingLabel := widget.NewLabel("Authenticating")
+		loadingBar := widget.NewProgressBarInfinite()
 		cancelButton := widget.NewButton("Cancel", nil)
-		popup := widget.NewModalPopUp(container.NewVBox(loadingLabel, cancelButton), w.Canvas())
+		popup := widget.NewModalPopUp(container.NewVBox(loadingLabel, loadingBar, cancelButton), w.Canvas())
+		popup.Resize(fyne.NewSize(200, 100))
 		popup.Show()
 		cancelButton.OnTapped = func() {
 			popup.Hide()
+			serverAddress.Enable()
+			password.Enable()
 		}
 		connectClient(serverAddress.Text, username.Text, password.Text)
 	}
+
+	w.SetPadded(true)
+	w.CenterOnScreen()
 	w.ShowAndRun()
 }
 
diff --git a/internal/miniature/client.go b/internal/miniature/client.go
index 41da495..c2c801b 100644
--- a/internal/miniature/client.go
+++ b/internal/miniature/client.go
@@ -264,16 +264,15 @@ func (client *Client) handleIncomingConnections() {
 				log.Printf("Error decrypting data from the server \t Error : %s \n", err)
 				continue
 			}
-			fmt.Println(flag)
+
 			if flag == utilities.SESSION {
-				fmt.Println("received session")
 				go client.writeToIfce(decryptedPayload)
 			} else {
 				log.Println("Expected headers not found")
 			}
 		} else {
 			if err := client.AuthenticateUser(); err != nil {
-				log.Println(err)
+				log.Println("Failed to authenticate client", err)
 				return
 			}
 		}
@@ -283,7 +282,7 @@ func (client *Client) handleIncomingConnections() {
 func (client *Client) writeToIfce(packet []byte) {
 	_, err := client.ifce.Ifce.Write(packet)
 	if err != nil {
-		fmt.Println(err)
+		fmt.Println("Failed to write to interface", err)
 		return
 	}
 }
@@ -347,7 +346,7 @@ func (client *Client) HeartBeat() {
 
 	encryptedData, err := codec.Encrypt(client.secret, encodedPeer)
 	if err != nil {
-		log.Println(err)
+		log.Println("Failed to encrypt data", err)
 		return
 	}
 
@@ -410,7 +409,7 @@ func (client *Client) CleanUp() {
 			common.DeleteRoute(route.Destination)
 			err := common.AddRoute(route)
 			if err != nil {
-				log.Println(err)
+				log.Println("Failed to add route", err)
 			}
 		}
 	}
diff --git a/internal/miniature/server.go b/internal/miniature/server.go
index 9f24efc..ae18386 100644
--- a/internal/miniature/server.go
+++ b/internal/miniature/server.go
@@ -82,8 +82,6 @@ type ServerConfig struct {
 // Run starts the VPN server by passing a configuration object
 // The configuration object contains attributes needed to run the server
 func (server *Server) Run(config ServerConfig) {
-	fmt.Println(config.PublicIP)
-	fmt.Println(config)
 	server.Config = config
 	ifce, err := utilities.NewInterface()
 	if err != nil {
@@ -93,8 +91,7 @@ func (server *Server) Run(config ServerConfig) {
 
 	_, network, err := net.ParseCIDR(config.Network)
 	if err != nil {
-		log.Println(err)
-		log.Println("Failed to parse cidre")
+		log.Println("Failed to parse cidre", err)
 		return
 	}
 
@@ -106,7 +103,7 @@ func (server *Server) Run(config ServerConfig) {
 	fmt.Println("TunIP", server.connectionPool.NetworkAddress)
 	err = ifce.Configure(ip, ip, 1300)
 	if err != nil {
-		log.Printf("Error: %s \n", err)
+		log.Println("Failed to configure interface:", err)
 		return
 	}
 
@@ -120,7 +117,7 @@ func (server *Server) Run(config ServerConfig) {
 
 	gatewayIfce, _, err := utilities.GetDefaultGateway()
 	if err != nil {
-		fmt.Println("Failed to get default interface", gatewayIfce)
+		fmt.Println("Failed to get default interface", gatewayIfce, err)
 		return
 	}
 
@@ -200,9 +197,6 @@ func (server *Server) Run(config ServerConfig) {
 			log.Println("Could not find one or more server certificate files, creating fresh ones")
 			err = server.generateServerCerts()
 			if err != nil {
-				fmt.Println(err)
-				fmt.Println(server.gatewayIfce)
-				fmt.Println(server)
 				log.Println("Failed to create server certificate files")
 				return
 			}
@@ -609,7 +603,7 @@ func (server *Server) handleConnection(peer *Peer, packet []byte) {
 	server.connectionPool.Update(peer.IP, *peer)
 	_, err := server.tunInterface.Ifce.Write(packet)
 	if err != nil {
-		fmt.Println(err)
+		fmt.Println("Failed to write to tun interface", err)
 		return
 	}
 }
@@ -634,7 +628,7 @@ func (server *Server) readIfce() {
 		buffer := make([]byte, server.tunInterface.Mtu)
 		length, err := server.tunInterface.Ifce.Read(buffer)
 		if err != nil {
-			log.Println(err)
+			log.Println("Failed to read from tun interface", err)
 			continue
 		}
 
@@ -656,13 +650,13 @@ func (server *Server) readIfce() {
 
 					compressedPacket, err := Compress(sendPacket)
 					if err != nil {
-						log.Println(err)
+						log.Println("Failed to compress packet", err)
 						return
 					}
 
 					_, err = server.socket.WriteTo(compressedPacket, peer.Addr)
 					if err != nil {
-						fmt.Println(err)
+						fmt.Println("Failed to write to socket", err)
 						return
 					}
 					go server.metrics.Update(0, len(sendPacket), len(compressedPacket), length)

From 50911cca640a4ae1fc319befb6a334b15720d410 Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Tue, 26 Dec 2023 06:55:20 +0300
Subject: [PATCH 28/29] Debug server

---
 internal/miniature/server.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/internal/miniature/server.go b/internal/miniature/server.go
index ae18386..02e404c 100644
--- a/internal/miniature/server.go
+++ b/internal/miniature/server.go
@@ -100,7 +100,6 @@ func (server *Server) Run(config ServerConfig) {
 	log.Printf("Generated %v ip addresses \n", server.connectionPool.AvailableAddressesCount())
 
 	ip := net.ParseIP(server.connectionPool.NetworkAddress)
-	fmt.Println("TunIP", server.connectionPool.NetworkAddress)
 	err = ifce.Configure(ip, ip, 1300)
 	if err != nil {
 		log.Println("Failed to configure interface:", err)

From afd2b6f16db94419bf4a71780dc68afbf41cfae0 Mon Sep 17 00:00:00 2001
From: devgenie <jonen54@gmail.com>
Date: Tue, 26 Dec 2023 07:06:03 +0300
Subject: [PATCH 29/29] Debug server

---
 internal/miniature/database.go | 3 ---
 internal/miniature/http.go     | 4 ++--
 internal/miniature/server.go   | 2 +-
 3 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/internal/miniature/database.go b/internal/miniature/database.go
index 4bcc63d..3e11094 100644
--- a/internal/miniature/database.go
+++ b/internal/miniature/database.go
@@ -52,7 +52,6 @@ func (dbObj *DatabaseObject) GetUser(username, password string) (*User, error) {
 	var user User
 	result := dbObj.DBConn.First(&user, "username = ?", username)
 	if result.Error != nil {
-		log.Println(result.Error)
 		return nil, result.Error
 	}
 
@@ -72,7 +71,5 @@ func hashPassword(password string) (string, error) {
 }
 
 func checkPassword(password string, hashedPassword string) error {
-	fmt.Println(password)
-	fmt.Println(hashedPassword)
 	return bcrypt.CompareHashAndPassword([]byte(hashedPassword), []byte(password))
 }
diff --git a/internal/miniature/http.go b/internal/miniature/http.go
index a8d0691..1b6c78c 100644
--- a/internal/miniature/http.go
+++ b/internal/miniature/http.go
@@ -82,14 +82,14 @@ func (httpServer *HTTPServer) createClientConfig(w http.ResponseWriter, r *http.
 		db.Init()
 		_, err = db.GetUser(user.Username, user.Password)
 		if err != nil {
-			log.Println(err)
+			log.Println("Failed to fetch user", err)
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
 
 		clientConfig, err := httpServer.server.CreateClientConfig()
 		if err != nil {
-			log.Println(err)
+			log.Println("Failed to create client config", err)
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		} else {
diff --git a/internal/miniature/server.go b/internal/miniature/server.go
index 02e404c..3bee5d5 100644
--- a/internal/miniature/server.go
+++ b/internal/miniature/server.go
@@ -520,7 +520,7 @@ func (server *Server) handleHandshake(conn net.Conn, payload []byte) error {
 	serverKEX := ecdh.Generic(elliptic.P256())
 	serverPrivateKey, serverPublicKey, err := serverKEX.GenerateKey(rand.Reader)
 	if err != nil {
-		log.Println(err)
+		log.Println("Failed to generate key", err)
 		return err
 	}
 	peer := server.connectionPool.NewPeer()