[PD1] Fixed stuff. Unmarshal still returns map[string]interface{}, need to fix

Projs/PD1/internal/client/client.go

@@ -5,6 +5,7 @@ import (
 	"PD1/internal/utils/cryptoUtils"
 	"PD1/internal/utils/networking"
 	"flag"
+	"fmt"
 )
 
 func Run() {
@@ -34,7 +35,11 @@ func Run() {
 
 		certRequestPacket := protocol.NewRequestUserCertPacket(uid)
 		cl.Connection.Send(certRequestPacket)
-		//certPacket := cl.Connection.Receive()
+        
+        var certPacket protocol.Packet
+		cl.Connection.Receive(&certPacket)
+        uidCert := (certPacket.Body).(protocol.SendUserCertPacket)
+        fmt.Println(uidCert)
 
 		// TODO: Encrypt message
 		//submitMessage(cl, uid, cipherContent)

Projs/PD1/internal/protocol/protocol.go

@@ -1,116 +1,114 @@
 package protocol
 
 import (
-	"time"
+    "time"
 )
 
 type PacketType int
 
 const (
-	ReqUserCertPkt PacketType = iota
+    ReqUserCertPkt PacketType = iota
-	ReqAllMsgPkt
+    ReqAllMsgPkt
-	ReqMsgPkt
+    ReqMsgPkt
-	SubmitMsgPkt
+    SubmitMsgPkt
-	SendUserCertPkt
+    SendUserCertPkt
-	ServerMsgPkt
+    ServerMsgPkt
+)
+
+// Define interfaces for packet bodies
+type (
+    RequestUserCertPacket struct {
+        UID string `json:"uid"`
+    }
+
+    RequestAllMsgPacket struct {
+        FromUID string `json:"from_uid"`
+    }
+
+    RequestMsgPacket struct {
+        Num uint16 `json:"num"`
+    }
+
+    SubmitMessagePacket struct {
+        ToUID   string `json:"to_uid"`
+        Content []byte `json:"content"`
+    }
+
+    SendUserCertPacket struct {
+        UID string `json:"uid"`
+        Key []byte `json:"key"`
+    }
+
+    ServerMessagePacket struct {
+        FromUID   string    `json:"from_uid"`
+        ToUID     string    `json:"to_uid"`
+        Content   []byte    `json:"content"`
+        Timestamp time.Time `json:"timestamp"`
+    }
 )
 
 type PacketBody interface{}
 
 type Packet struct {
-	Flag PacketType
+    Flag PacketType `json:"flag"`
-	Body PacketBody
+    Body PacketBody `json:"body"`
-}
-
-// Client --> Server: Ask for a user's certificate
-type RequestUserCertPacket struct {
-	UID string
 }
 
 func NewRequestUserCertPacket(UID string) Packet {
-	return Packet{
+    return Packet{
-		Flag: ReqUserCertPkt,
+        Flag: ReqUserCertPkt,
-		Body: RequestUserCertPacket{
+        Body: RequestUserCertPacket{
-			UID: UID,
+            UID: UID,
-		},
+        },
-	}
+    }
-}
-
-// Client --> Server: Ask for all the client's messages in the queue
-type RequestAllMsgPacket struct {
-	FromUID string
 }
 
 func NewRequestAllMsgPacket(fromUID string) Packet {
-	return Packet{
+    return Packet{
-		Flag: ReqAllMsgPkt,
+        Flag: ReqAllMsgPkt,
-		Body: RequestAllMsgPacket{
+        Body: RequestAllMsgPacket{
-			FromUID: fromUID,
+            FromUID: fromUID,
-		},
+        },
-	}
+    }
-}
-
-// Client --> Server: Ask for a specific message in the queue
-type RequestMsgPacket struct {
-	Num uint16
 }
 
 func NewRequestMsgPacket(num uint16) Packet {
-	return Packet{
+    return Packet{
-		Flag: ReqMsgPkt,
+        Flag: ReqMsgPkt,
-		Body: RequestMsgPacket{
+        Body: RequestMsgPacket{
-			Num: num,
+            Num: num,
-		},
+        },
-	}
+    }
-}
-
-// Client --> Server: Send message from client to server
-type SubmitMessagePacket struct {
-	ToUID   string
-	Content []byte
 }
 
 func NewSubmitMessagePacket(toUID string, content []byte) Packet {
-	return Packet{
+    return Packet{
-		Flag: SubmitMsgPkt,
+        Flag: SubmitMsgPkt,
-		Body: SubmitMessagePacket{
+        Body: SubmitMessagePacket{
-			ToUID:   toUID,
+            ToUID:   toUID,
-			Content: content},
+            Content: content,
-	}
+        },
-}
+    }
-
-// Server --> Client: Send the client the requested public key
-type SendUserCertPacket struct {
-	UID string
-	Key []byte
 }
 
 func NewSendUserCertPacket(uid string, key []byte) Packet {
-	return Packet{
+    return Packet{
-		Flag: SendUserCertPkt,
+        Flag: SendUserCertPkt,
-		Body: SendUserCertPacket{
+        Body: SendUserCertPacket{
-			UID: uid,
+            UID: uid,
-			Key: key,
+            Key: key,
-		},
+        },
-	}
+    }
-}
-
-// Server --> Client: Send the client a message
-type ServerMessagePacket struct {
-	FromUID   string
-	ToUID     string
-	Content   []byte
-	Timestamp time.Time
 }
 
 func NewServerMessagePacket(fromUID, toUID string, content []byte, timestamp time.Time) Packet {
-	return Packet{
+    return Packet{
-		Flag: ServerMsgPkt,
+        Flag: ServerMsgPkt,
-		Body: ServerMessagePacket{
+        Body: ServerMessagePacket{
-			FromUID:   fromUID,
+            FromUID:   fromUID,
-			ToUID:     toUID,
+            ToUID:     toUID,
-			Content:   content,
+            Content:   content,
-			Timestamp: timestamp,
+            Timestamp: timestamp,
-		},
+        },
-	}
+    }
 }

Projs/PD1/internal/server/datastore.go

@@ -154,3 +154,22 @@ func (ds DataStore) GetUserCertificate(uid string) protocol.Packet {
 	}
 	return protocol.NewSendUserCertPacket(uid, userCert)
 }
+
+func userExists(db *sql.DB, uid string) bool {
+    // Prepare the SQL statement for checking if a user exists
+    query := `
+        SELECT COUNT(*)
+        FROM users
+        WHERE UID = ?
+    `
+
+    var count int
+    // Execute the SQL query
+    err := db.QueryRow(query, uid).Scan(&count)
+    if err != nil {
+        log.Panicln("Error checking if user exists")
+    }
+
+    // If count is greater than 0, the user exists
+    return count > 0
+}

Projs/PD1/internal/server/server.go

@@ -9,17 +9,29 @@ import (
 
 func clientHandler(connection networking.Connection[protocol.Packet], dataStore DataStore) {
 	defer connection.Conn.Close()
-	_ = dataStore
+
+	//Get certificate sent by user
 	clientCert := connection.GetPeerCertificate()
-	oidValueMap := cryptoUtils.ExtractAllOIDValues(clientCert)
+	//Get the OID values
-	fmt.Println(oidValueMap)
+	oidMap := cryptoUtils.ExtractAllOIDValues(clientCert)
+	//Get the UID of this user
+	UID := oidMap["2.5.4.65"]
+	if UID=="" {
+		panic("User certificate does not specify it's PSEUDONYM")
+	}
 
 	for {
-		pac := connection.Receive()
+        var pac protocol.Packet
+		connection.Receive(&pac)
 		switch pac.Flag {
 		case protocol.ReqUserCertPkt:
-			//userCertPacket := dataStore.GetUserCertificate(uid)
+            fmt.Printf("Type of pac.Body: %T\n", pac.Body)
-			//connection.Send(userCertPacket)
+			UserCertPacket, ok := (pac.Body).(protocol.RequestUserCertPacket)
+			if !ok {
+				panic("Could not cast packet to it's type")
+			}
+			userCertPacket := dataStore.GetUserCertificate(UserCertPacket.UID)
+			connection.Send(userCertPacket)
 		case protocol.ReqAllMsgPkt:
 			fmt.Println("ReqAllMsg")
 		case protocol.ReqMsgPkt:

Projs/PD1/internal/utils/cryptoUtils/cryptoUtils.go

@@ -94,7 +94,6 @@ func (k *KeyStore) GetServerTLSConfig() *tls.Config {
 		caCertPool.AddCert(caCert)
 	}
 	tlsConfig.ClientCAs = caCertPool
-	//Request one valid or invalid certificate
     //FIX: SERVER ACCEPTS CONNECTIONS WITH UNMATCHING OR 
     // NO CERTIFICATE, NEEDS TO BE CHANGED SOMEHOW
 	tlsConfig.ClientAuth = tls.RequireAndVerifyClientCert

Projs/PD1/internal/utils/networking/connection.go

@@ -26,12 +26,10 @@ func (c Connection[T]) Send(obj T) {
 	}
 }
 
-func (c Connection[T]) Receive() T {
+func (c Connection[T]) Receive(objPtr *T) {
-	var obj T
+	if err := c.decoder.Decode(objPtr); err != nil {
-	if err := c.decoder.Decode(&obj); err != nil {
 		panic("Failed decoding data or reading it from connection")
 	}
-	return obj
 }
 
 func (c Connection[T]) GetPeerCertificate() *x509.Certificate {