[PD2] Client done except jwt token, login and register functions

Projs/PD2/certs/CA/CA.srl

@@ -1 +1 @@
-7C475B59D1510F54E042BF4BFDBE811BF4EDAF37
+7C475B59D1510F54E042BF4BFDBE811BF4EDAF38

Projs/PD2/certs/gateway/gateway.crt

@@ -0,0 +1,29 @@
+-----BEGIN CERTIFICATE-----
+MIIFBTCCAu2gAwIBAgIUfEdbWdFRD1TgQr9L/b6BG/TtrzgwDQYJKoZIhvcNAQEL
+BQAwDTELMAkGA1UEAwwCQ0EwHhcNMjQwNTMwMTYyMjIyWhcNMjkwNTI5MTYyMjIy
+WjAoMRQwEgYDVQQLDAtNU0cgU0VSVklDRTEQMA4GA1UEQQwHR0FURVdBWTCCAiIw
+DQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMdXub0WoiMi2RZhnaKW1ncpCe0z
+GNutuD2xfyNG4YcYIxaXcZk/XprJly3txyKARnUj2kz+gR2ZNY75YIbqo5rJQlkf
+ZcIl80stnkxI1eMedZlTs0JfWeobGhhkqr5JI5ylKMYfVNKyhWYac9VAmgIdWS5z
+XJOk9gIdKvPkIHYDXozLZMNwfP+4PH+s11dKWhLcYy+MgO3ynv3kfo/9EdOMpmUa
+ozpBSd/COJXz7XM0MSaaEtx2M7nH8Ok8urQ33a+AtaMYlK3wTiZWM0SNthDyQ6jV
+492vFcHOJ24qrx1wJgB5GYwOmOl32LDh9+tyV7taqUrFutYEir3RRzxbEKPDWIUm
+NTkgtIpuD+I9AiD08jjW5CHmK4zZA4lA8eyga8f9ge5Yul5TtUEkBP/epVrPoeyK
+XEloFKM3/mE3oTLb2+oAiRWbCK+jML1jBEWJu7zmw1b7wBuG9vNZXPnyfIP9Us9R
+kllyV0T41nuqV/coD0C63Lj4zMy0t3QmQfA+YA4NixBdKZx7G8nfHZ83tFHCE7AU
+MkXggJBNZMC+PUrTsTeIYuWQB43fKita9osFF7NodweGZJcEjR44QAqjcmEXmKjg
+VA/vC6jsZV62hyunXMRejWmJ4MF8DkASB6usV4wK7WuyD1EuzMRRlCk487Kxh67j
+eN+hv8AV9TvGRpuRAgMBAAGjQjBAMB0GA1UdDgQWBBTsd56e8HSHAqZvU+gAl7p9
+QwSzPTAfBgNVHSMEGDAWgBTFRNY8++1sHgvGqO21WMbownWw0TANBgkqhkiG9w0B
+AQsFAAOCAgEAjqPKVzU8vgumFmguwrJArbBbCkSP8mQaOg1Gsoz2vn4nrKDpP7hl
+xtZLDF+ynXd0+pJ3u5PIODRk1mllcBJBE7JyB+GcWfura9mpnpO5auuzdBzFd9jq
+mYKd/WNGlJa4iXQgNBCGvlz3gr6Bd//H4cL78cik8/sHSoJ9ZdzIzB3rcl6zTvUd
+3sC3va62cXlJuNbLO087DmSEaHnsFgF5ohLdyrGUoDDye2oPejytEueM2FytNaTF
+HaNylNxTwcmlT6eH6U1icczyvH3WT0JViQHqP1nuHM1jqvPaNn9GW62uxsmr6Xbu
+bTkYkLkKT9Z9NKd5evdyCCtvVsLzdW4zMBA6c3gqiQLGVw2DtrdNsjCO1YA3lj/P
+sV/I1DW7dBT2JtzI0kiRK+GG1kreCeQlzVDfYy+gPoyolr0qOcMVQxvab7iXl4xK
+bJ+tBIR98hDdLqS2S4Wmu3dEO85T5k4zfkhOxrBS8F/gnur2vrmkPypOGpg5jz3G
+0yExzhyQu8XYkFG+LaWDd3eOiECScpkn8TqCgliZatm3CE2xasdbjoND+lYdPeQ8
+ntmbaLVQPUHx/6x3h6OfNRHCx04rqf830U+IkuXdISEI5u8tdXF9qUmlRSmlMezW
+G/CjFJK7JRwDSq2fCnL45aiu/VSQTACoMd58p39WTQHFXhakpx4zeYo=
+-----END CERTIFICATE-----

Projs/PD2/certs/gateway/gateway.csr

@@ -0,0 +1,26 @@
+-----BEGIN CERTIFICATE REQUEST-----
+MIIEbTCCAlUCAQAwKDEUMBIGA1UECwwLTVNHIFNFUlZJQ0UxEDAOBgNVBEEMB0dB
+VEVXQVkwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDHV7m9FqIjItkW
+YZ2iltZ3KQntMxjbrbg9sX8jRuGHGCMWl3GZP16ayZct7ccigEZ1I9pM/oEdmTWO
++WCG6qOayUJZH2XCJfNLLZ5MSNXjHnWZU7NCX1nqGxoYZKq+SSOcpSjGH1TSsoVm
+GnPVQJoCHVkuc1yTpPYCHSrz5CB2A16My2TDcHz/uDx/rNdXSloS3GMvjIDt8p79
+5H6P/RHTjKZlGqM6QUnfwjiV8+1zNDEmmhLcdjO5x/DpPLq0N92vgLWjGJSt8E4m
+VjNEjbYQ8kOo1ePdrxXBziduKq8dcCYAeRmMDpjpd9iw4ffrcle7WqlKxbrWBIq9
+0Uc8WxCjw1iFJjU5ILSKbg/iPQIg9PI41uQh5iuM2QOJQPHsoGvH/YHuWLpeU7VB
+JAT/3qVaz6HsilxJaBSjN/5hN6Ey29vqAIkVmwivozC9YwRFibu85sNW+8Abhvbz
+WVz58nyD/VLPUZJZcldE+NZ7qlf3KA9Auty4+MzMtLd0JkHwPmAODYsQXSmcexvJ
+3x2fN7RRwhOwFDJF4ICQTWTAvj1K07E3iGLlkAeN3yorWvaLBRezaHcHhmSXBI0e
+OEAKo3JhF5io4FQP7wuo7GVetocrp1zEXo1pieDBfA5AEgerrFeMCu1rsg9RLszE
+UZQpOPOysYeu43jfob/AFfU7xkabkQIDAQABoAAwDQYJKoZIhvcNAQELBQADggIB
+ABK/CZ/3vDqCqh6vH95l9zvp4Jn3GAuATODXsrhslSY2kD8mZYHuE45vb4J50r8d
+Trr8GIJsZ2WMAxE9nkf7L62GQ4m0NtW10zUPH7R2SH6jr3HHi6ziElO4Aj6EmbNZ
+seavMjxP+jgTsfsKuOW1+YqlLK7Di5CAQZC/CpX2zIgBY8qxQNMjHJCnc+q/yuYg
+IxAmfN36ibMEPLHdMzK+TvwtLRxcmLP470VzpjE5PYJgavLK6N1HQoTVKfqM5+B3
+2gqV1XwNM4pnyiZaVIwtn5ojbBlkVjYMzFTyBbJOZikXIMiVDCkyphokawnGzlVk
+bJmh5NUBVdwxUAfOXDVwrx+QdZpm5DoV9c1lQ9HlLwyWtd42cW6VMuPt6oCbkR8k
+owPHKV6C/BJeaWWWS4narlrtAquM1N3WB0DjE4sMQezMNA7fwrJcjcDkfvO3eZ0X
+b44Jxn+HJAiZEB8r570w5DCgaRBsRLz9EvYVV1wcrLCX78zkXhn9GXkUNBj8jkUg
+PLy/OTiXt7yHbHQSCMLkmfcCYIcBCfJwqIe5qqDzoiqHiZLbOW5jQtaXEkOEKKa+
+7CiG3EX/UgzGpsUIfe5bomZfaczAZJBbLwW9jr9oWQwMfWf/oQPkGqhZfbcUZJ6h
+xCRe5lPRHOsE9GWZOASKcOKzm6KB0tjvqUz/rdrcntct
+-----END CERTIFICATE REQUEST-----

Projs/PD2/certs/gateway/gateway.key

@@ -0,0 +1,52 @@
+-----BEGIN PRIVATE KEY-----
+MIIJQQIBADANBgkqhkiG9w0BAQEFAASCCSswggknAgEAAoICAQDHV7m9FqIjItkW
+YZ2iltZ3KQntMxjbrbg9sX8jRuGHGCMWl3GZP16ayZct7ccigEZ1I9pM/oEdmTWO
++WCG6qOayUJZH2XCJfNLLZ5MSNXjHnWZU7NCX1nqGxoYZKq+SSOcpSjGH1TSsoVm
+GnPVQJoCHVkuc1yTpPYCHSrz5CB2A16My2TDcHz/uDx/rNdXSloS3GMvjIDt8p79
+5H6P/RHTjKZlGqM6QUnfwjiV8+1zNDEmmhLcdjO5x/DpPLq0N92vgLWjGJSt8E4m
+VjNEjbYQ8kOo1ePdrxXBziduKq8dcCYAeRmMDpjpd9iw4ffrcle7WqlKxbrWBIq9
+0Uc8WxCjw1iFJjU5ILSKbg/iPQIg9PI41uQh5iuM2QOJQPHsoGvH/YHuWLpeU7VB
+JAT/3qVaz6HsilxJaBSjN/5hN6Ey29vqAIkVmwivozC9YwRFibu85sNW+8Abhvbz
+WVz58nyD/VLPUZJZcldE+NZ7qlf3KA9Auty4+MzMtLd0JkHwPmAODYsQXSmcexvJ
+3x2fN7RRwhOwFDJF4ICQTWTAvj1K07E3iGLlkAeN3yorWvaLBRezaHcHhmSXBI0e
+OEAKo3JhF5io4FQP7wuo7GVetocrp1zEXo1pieDBfA5AEgerrFeMCu1rsg9RLszE
+UZQpOPOysYeu43jfob/AFfU7xkabkQIDAQABAoICAAdbBRNFW8e8oDKLeQ/YDYNZ
+nBBo14S5oQgDvet9ENLVkOvjPDGZrUG8aQvsj3HGNnNZlpNLO9PuBJQpPwbTbySF
+wyE7P5u9nz/Zp9LsSBoolFHLTRzInG5/QAQA6Oz7EWmVDY9b9hsNM89r7/TBPL2R
+vCny30piZqJ21ZAozYrVPn6m/amZg79C2taiN9L0fyTdhXpqbpJ5JqU7MnFZNvht
+ovEtnbLHWHS9e62K0erzlNG2EzaX1PpItqrAjyoZuqAgeXNSc6AEcznGaf9gVETF
+T7pR5CXYsU6Urw9JW2tUaU6QqWDp4/oPbks+l1GUh0i2RHNqHuYJRl5RM9X2DUPQ
++f+YzKUKHLKjTr4T9QWwQtYi0e0z3QpZmCqto73ep4K81HjPnsc+cKvSTrQ2vc8R
+thVLZwa7KQIQ7ca8ZWiCuvK759mpuFzcFc6hwyGFjWUQk2jqd4h/1cpMVgZvPIVP
+VhbRZ88Hmwtwz/3HvKEMSYxtSS+K0lklY0lBilRSSFAejWbVrPNVfzz70wWmjo9l
+9+CiGweRgDEsVQJtmGoSq3HlOuuJwgCqHYsbSsDsD9jF/7Op2AB3ZuMIMzT3jN2i
+n4hMz2Bb986OuBiDb3a7N3Fz0JoB5OVDKZjxdVM1kqyetWgXBqzwAvjGbCXuq9aE
+JeIbAys+HYHZ2ZkgtMwdAoIBAQDyMnSljf0JYtDmwPgfHHR6n9soyzOOF8XD8UiM
+wmLvC3YQJezzNYNi3esSKwWIIT0/Cx/yMTQyBhPiqzK4vuYOce+FyFwAaGiQ0jWe
+lQoHdyDDT9jANfayRfyVCxpxywn4gKOzY6imtJJaUkC8AqZG2jsZEQHwdCyL/kMa
+BcvQa3so08pWh2aWBg+WzwZH/UUEE3c4RaVNpeQpFkMa1yzl9clHRx/9a8QL0Nka
+cbqgBuXQUAex26qTJpbWU2jFqPlnEQkgLK5O7XdF+CWV604Jrxd6KAYLpemWtBO1
+LD1ecRJSeGOsp7yva5s9ZzPVvKrIv4JrDwrsXnIQUFjabnjNAoIBAQDStAstjYA9
+I8EY2rDFhL3xBDl1dGtqVtGFmboRfBnwv0NPBWVLM/A46l0V2FWzzeUIVDYqntQW
+JAaen9WiCpBT1hEmPWV2hke2Yl8OYKV7xC/zchCZcb8PCxdOVEd77ymhzE4hHq+W
+TMJ17P86MViCtyE5/IkPtxWI4SOfKXIliCEAIcGBYGPYKX/XFlxtlra6AHncJTEf
+4yZALovCfGjRHwNeUcJgxRUo/tbIJHUOQc7axLdPZXQdajAkrz3F/E4LtjzdsnBv
+pGW7NlXx5lkjLZCZi88Mi3DBB7Ijt2TJnKthznqz8UHMv1+b2HGAxlJAjUmsOug8
+gzXmlD304H3VAoIBAEYWLcU+2oudyeAM1YCDRn25xrz+WJP08yjpqNn64pBUW7z+
+jJwwzy2MFJt0Uax8GfIlcQAwFu+m7Jg6fHoT3BUwCWVIfr8rd575BcU3UeipI5UB
+hTLSKuqZ8CbdSLDHVcJQz45493QOaw+yH8OIbL+yJUnyrwH7TGzSjm54YOuWPtSo
+vTPfCOO/K0Gz9RheBVvRmj1xgg1/RRBSveaFgBunzbBPt8UpK1lT/Y92e9AVTunC
+Twe8Dpd4okuxZW9Vn56gwmhKJcL3Wv2nepDwv+tzfLK/5Ef4oikXQWC7RaMPy4KM
+DiQHgkWtOQZC2DAw4acoLEB44OtXxWBNL/k94L0CggEAAbDsPgtasiLtU9O9g3hT
+RfHwvB6ZFhtoRxg6xBUo6CPA2IuEipv6G5rV8GzyEyVd5zk1zhXEQgE8BF3oCwrm
+qaWYMaRgghkFzlLvzF++NEYY1G1f8LtW+zntj/VhNX9v6BqJrf5fDmfDT8r9KWxn
+93Sc0ahTOUsQ4y5baNWeUurKyQN8WBt78aozmnhVeZOyF8AVOk0aHdVm4zD8ci0p
+cjQ7hLBHTRuH1fJlqumP/vNMQ7k8d2irC+lkRYcaidJClhl6V5UtDdhV8LC4894T
+bRLajEDxAnrEBuiW5257YprdTUWo+nS/QHNwwwFzt8LfuiDoLHe0kXfEIPujm6mJ
+mQKCAQAqsJ6X29gknwUXnQzuwuD8vuQ3K/z+oSFZj9VGWlnwKT4k9rmP3b1mrTKQ
+8mXrVX44BkYgjRO4myDqVdEugBQS6vmGyu+BJR0OYC2MWeWaUU5ABgsh/uR+lWRa
+AHEKbf04OMZN2uj5dcARsDE0501T4znm0EzMKs3pBEzzbX5KuJG/F7s+7bpr+pq/
+IGxW5/kx7TjMvgVYZjPOuF4HbpBDHNU4dL+girPfPmVd7X9hsYs8r6YLB/F4sIQo
+qnDEhiRXFpb4HrFbCoP+HpqAs7jvqnH9VwJdI1XARQjubPui3IrcvyO1IV70qPcQ
+d7UO8BCUj9IMU7pG2RmEWzw35AJJ
+-----END PRIVATE KEY-----

Projs/PD2/internal/client/client.go

@@ -3,16 +3,24 @@ package client
 import (
 	"PD2/internal/protocol"
 	"PD2/internal/utils/cryptoUtils"
-	"PD2/internal/utils/networking"
+	"bytes"
+	"crypto/tls"
 	"crypto/x509"
+	"encoding/json"
 	"errors"
 	"flag"
+	"fmt"
+	"io"
 	"log"
+	"net/http"
+	"net/url"
 	"os"
 	"sort"
 	"strconv"
 )
 
+const baseURL = "https://127.0.0.1:9090"
+
 func Run() {
 	var userFile string
 	flag.StringVar(&userFile, "user", "userdata.p12", "Specify user data file")
@@ -28,6 +36,8 @@ func Run() {
 		log.Fatalln(err)
 	}
 
+    token = cryptoUtils.GetUserToken()
+
 	command := flag.Arg(0)
 	switch command {
 	case "send":
@@ -65,10 +75,11 @@ func Run() {
 			}
 		}
 
-		err := askQueueCommand(clientKeyStore, page, pageSize)
+		page, pageSize, listClientMessageInfo, err := askQueueCommand(clientKeyStore, page, pageSize)
 		if err != nil {
 			log.Fatalln(err)
 		}
+        showMessagesInfo(page, pageSize, listClientMessageInfo)
 
 	case "getmsg":
 		if flag.NArg() < 2 {
@@ -81,10 +92,11 @@ func Run() {
 		if err != nil {
 			log.Fatalln(err)
 		}
-		err = getMsgCommand(clientKeyStore, num)
+		msg, err := getMsgCommand(clientKeyStore, num)
 		if err != nil {
 			printError(err.Error())
 		}
+		showMessage(msg)
 
 	case "help":
 		showHelp()
@@ -96,6 +108,11 @@ func Run() {
 
 }
 
+func getHTTPClient(tlsConfig *tls.Config) *http.Client {
+	transport := &http.Transport{TLSClientConfig: tlsConfig}
+	return &http.Client{Transport: transport}
+}
+
 func sendCommand(clientKeyStore cryptoUtils.KeyStore, plainSubject, plainBody, uid string) error {
 	//Turn content to bytes
 	plainSubjectBytes, err := Marshal(plainSubject)
@@ -107,18 +124,10 @@ func sendCommand(clientKeyStore cryptoUtils.KeyStore, plainSubject, plainBody, u
 		return err
 	}
 
-    // FIX: adapt to api
+	receiverCert, err := getUserCert(clientKeyStore, uid)
-	cl, err := networking.NewClient[protocol.Packet](&clientKeyStore)
 	if err != nil {
 		return err
 	}
-	defer cl.Connection.Conn.Close()
-
-	receiverCert, err := getUserCert(cl, clientKeyStore, uid)
-	if err != nil {
-		return err
-	}
-    // NOTE: this will stay the same
 	subject, err := clientKeyStore.EncryptMessageContent(receiverCert, uid, plainSubjectBytes)
 	if err != nil {
 		return err
@@ -128,159 +137,257 @@ func sendCommand(clientKeyStore cryptoUtils.KeyStore, plainSubject, plainBody, u
 		return err
 	}
 
-    // FIX: adapt to api
+	client := getHTTPClient(clientKeyStore.GetClientTLSConfig())
-	sendMsgPacket := protocol.NewSendMsgPacket(uid, subject, body)
+
-	if err := cl.Connection.Send(sendMsgPacket); err != nil {
+	// Parse the base URL
-		return err
+	parsedURL, err := url.Parse(baseURL)
-	}
-	answerSendMsg, err := cl.Connection.Receive()
 	if err != nil {
-		return err
+		return fmt.Errorf("error parsing URL: %v", err)
 	}
-	if answerSendMsg.Flag == protocol.FlagReportError {
+	parsedURL.JoinPath("message")
-		reportError, err := protocol.UnmarshalReportError(answerSendMsg.Body)
+
-		if err != nil {
+	sendMsgPacket := protocol.NewSendMsg(uid, subject, body)
+
+	jsonData, err := json.Marshal(sendMsgPacket)
+	if err != nil {
+		return fmt.Errorf("error marshaling JSON: %v", err)
+	}
+
+	//TODO: ADD THE HEADER WITH THE TOKEN
+	req, err := http.NewRequest("POST", parsedURL.String(), bytes.NewBuffer(jsonData))
+	if err != nil {
+		return fmt.Errorf("error creating request: %v", err)
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return fmt.Errorf("error making request: %v", err)
+	}
+	defer resp.Body.Close()
+
+	// Read response
+	responseBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("error reading response body: %v", err)
+	}
+
+	if resp.StatusCode != 200 {
+		var reportError protocol.ReportError
+		if err := json.Unmarshal(responseBody, &reportError); err != nil {
 			return err
 		}
 		return errors.New(reportError.ErrorMessage)
 	}
-	return nil
 
+	return nil
 }
 
-func getMsgCommand(clientKeyStore cryptoUtils.KeyStore, num int) error {
+func getMsgCommand(clientKeyStore cryptoUtils.KeyStore, num int) (ClientMessage, error) {
-	cl, err := networking.NewClient[protocol.Packet](&clientKeyStore)
+
+	client := getHTTPClient(clientKeyStore.GetClientTLSConfig())
+
+	// Parse the base URL
+	parsedURL, err := url.Parse(baseURL)
 	if err != nil {
-		return err
+		return ClientMessage{}, fmt.Errorf("error parsing URL: %v", err)
 	}
-	defer cl.Connection.Conn.Close()
+	parsedURL.JoinPath("message")
-	packet := protocol.NewGetMsgPacket(num)
+
-	if err := cl.Connection.Send(packet); err != nil {
+	newGetMsg := protocol.NewGetMsg(num)
-		return err
+
+	jsonData, err := json.Marshal(newGetMsg)
+	if err != nil {
+		return ClientMessage{}, fmt.Errorf("error marshaling JSON: %v", err)
 	}
 
-	receivedMsgPacket, err := cl.Connection.Receive()
+	//TODO: ADD THE HEADER WITH THE TOKEN
+	req, err := http.NewRequest("GET", parsedURL.String(), bytes.NewBuffer(jsonData))
 	if err != nil {
-		return err
+		return ClientMessage{}, fmt.Errorf("error creating request: %v", err)
 	}
-	if receivedMsgPacket.Flag == protocol.FlagReportError {
+
-		reportError, err := protocol.UnmarshalReportError(receivedMsgPacket.Body)
+	resp, err := client.Do(req)
-		if err != nil {
+	if err != nil {
-			return err
+		return ClientMessage{}, fmt.Errorf("error making request: %v", err)
+	}
+
+	defer resp.Body.Close()
+
+	// Read response
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return ClientMessage{}, fmt.Errorf("error reading response body: %v", err)
+	}
+
+	if resp.StatusCode != 200 {
+		var reportError protocol.ReportError
+		if err := json.Unmarshal(body, &reportError); err != nil {
+			return ClientMessage{}, err
 		}
-		return errors.New(reportError.ErrorMessage)
+		return ClientMessage{}, errors.New(reportError.ErrorMessage)
 	}
-	answerGetMsg, err := protocol.UnmarshalAnswerGetMsg(receivedMsgPacket.Body)
+
+	var answerGetMsg protocol.AnswerGetMsg
+	if err := json.Unmarshal(body, &answerGetMsg); err != nil {
+		return ClientMessage{}, err
+	}
+
+	senderCert, err := getUserCert(clientKeyStore, answerGetMsg.FromUID)
 	if err != nil {
-		return err
+		return ClientMessage{}, err
 	}
-	senderCert, err := getUserCert(cl, clientKeyStore, answerGetMsg.FromUID)
+
+	oidMap := cryptoUtils.ExtractAllOIDValues(clientKeyStore.GetCert())
+	myUID := oidMap["2.5.4.65"]
+	if myUID == "" {
+		return ClientMessage{}, errors.New("no pseudonym field on my certificate")
+	}
+
+	decSubjectBytes, err := clientKeyStore.DecryptMessageContent(senderCert, myUID, answerGetMsg.Subject)
 	if err != nil {
-		return err
+		return ClientMessage{}, err
 	}
-	decSubjectBytes, err := clientKeyStore.DecryptMessageContent(senderCert, answerGetMsg.Subject)
+	decBodyBytes, err := clientKeyStore.DecryptMessageContent(senderCert, myUID, answerGetMsg.Body)
 	if err != nil {
-		return err
+		return ClientMessage{}, err
 	}
-	decBodyBytes, err := clientKeyStore.DecryptMessageContent(senderCert, answerGetMsg.Body)
+	messageSubject, err := Unmarshal(decSubjectBytes)
 	if err != nil {
-		return err
+		return ClientMessage{}, err
 	}
-	subject, err := Unmarshal(decSubjectBytes)
+	messageBody, err := Unmarshal(decBodyBytes)
 	if err != nil {
-		return err
+		return ClientMessage{}, err
 	}
-	body, err := Unmarshal(decBodyBytes)
+	message := newClientMessage(answerGetMsg.FromUID, answerGetMsg.ToUID, messageSubject, messageBody, answerGetMsg.Timestamp)
-	if err != nil {
+	return message, nil
-		return err
-	}
-	message := newClientMessage(answerGetMsg.FromUID, answerGetMsg.ToUID, subject, body, answerGetMsg.Timestamp)
-	showMessage(message)
-	return nil
 }
 
-func getUserCert(cl networking.Client[protocol.Packet], keyStore cryptoUtils.KeyStore, uid string) (*x509.Certificate, error) {
+func getUserCert(keyStore cryptoUtils.KeyStore, uid string) (*x509.Certificate, error) {
-	getUserCertPacket := protocol.NewGetUserCertPacket(uid)
+
-	if err := cl.Connection.Send(getUserCertPacket); err != nil {
+	client := getHTTPClient(keyStore.GetClientTLSConfig())
-		return nil, err
+
-	}
+	// Parse the base URL
-	var answerGetUserCertPacket *protocol.Packet
+	parsedURL, err := url.Parse(baseURL)
-	answerGetUserCertPacket, err := cl.Connection.Receive()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("error parsing URL: %v", err)
 	}
-	if answerGetUserCertPacket.Flag == protocol.FlagReportError {
+	parsedURL.JoinPath("cert")
-		reportError, err := protocol.UnmarshalReportError(answerGetUserCertPacket.Body)
+	parsedURL.JoinPath(uid)
+
+	//TODO: ADD THE HEADER WITH THE TOKEN
+	req, err := http.NewRequest("GET", parsedURL.String(), nil)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request: %v", err)
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("error making request: %v", err)
+	}
+	defer resp.Body.Close()
+
+	// Read response
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("error reading response body: %v", err)
+	}
+
+	if resp.StatusCode == 200 {
+		var answerGetUserCert protocol.AnswerGetUserCert
+		if err := json.Unmarshal(body, &answerGetUserCert); err != nil {
+			return nil, err
+		}
+
+		userCert, err := x509.ParseCertificate(answerGetUserCert.Certificate)
 		if err != nil {
 			return nil, err
 		}
+		if err := keyStore.CheckCert(userCert, uid, "MSG SERVICE"); err != nil {
+			return nil, err
+		}
+		return userCert, nil
+	} else {
+		var reportError protocol.ReportError
+		if err := json.Unmarshal(body, &reportError); err != nil {
+			return nil, err
+		}
 		return nil, errors.New(reportError.ErrorMessage)
 	}
-	answerGetUserCert, err := protocol.UnmarshalAnswerGetUserCert(answerGetUserCertPacket.Body)
+
-	if err != nil {
-		return nil, err
-	}
-	userCert, err := x509.ParseCertificate(answerGetUserCert.Certificate)
-	if err != nil {
-		return nil, err
-	}
-	if err := keyStore.CheckCert(userCert, uid); err != nil {
-		return nil, err
-	}
-	return userCert, nil
 }
 
-func getManyMessagesInfo(cl networking.Client[protocol.Packet], keyStore cryptoUtils.KeyStore) (protocol.AnswerGetUnreadMsgsInfo, map[string]*x509.Certificate, error) {
+func getUnreadMessagesInfo(keyStore cryptoUtils.KeyStore, page int, pageSize int) (protocol.AnswerGetUnreadMsgsInfo, map[string]*x509.Certificate, error) {
-	answerGetUnreadMsgsInfoPacket, err := cl.Connection.Receive()
+	client := getHTTPClient(keyStore.GetClientTLSConfig())
+
+	// Parse the base URL
+	parsedURL, err := url.Parse(baseURL)
 	if err != nil {
-		return protocol.NewAnswerGetUnreadMsgsInfo(0, 0, nil), nil, err
+		return protocol.AnswerGetUnreadMsgsInfo{}, nil, fmt.Errorf("error parsing URL: %v", err)
 	}
-	if answerGetUnreadMsgsInfoPacket.Flag == protocol.FlagReportError {
+	parsedURL.JoinPath("queue")
-		reportError, err := protocol.UnmarshalReportError(answerGetUnreadMsgsInfoPacket.Body)
+
-		if err != nil {
+	getUnreadMessagesInfo := protocol.NewGetUnreadMsgsInfo(page, pageSize)
+
+	jsonData, err := json.Marshal(getUnreadMessagesInfo)
+	if err != nil {
+		return protocol.AnswerGetUnreadMsgsInfo{}, nil, fmt.Errorf("error marshaling JSON: %v", err)
+	}
+
+	//TODO: ADD THE HEADER WITH THE TOKEN
+	req, err := http.NewRequest("GET", parsedURL.String(), bytes.NewBuffer(jsonData))
+	if err != nil {
+		return protocol.AnswerGetUnreadMsgsInfo{}, nil, fmt.Errorf("error creating request: %v", err)
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return protocol.AnswerGetUnreadMsgsInfo{}, nil, fmt.Errorf("error making request: %v", err)
+	}
+	defer resp.Body.Close()
+
+	// Read response
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return protocol.AnswerGetUnreadMsgsInfo{}, nil, fmt.Errorf("error reading response body: %v", err)
+	}
+
+	if resp.StatusCode == 200 {
+		//Create Set of needed certificates
+		var answerGetUnreadMsgsInfo protocol.AnswerGetUnreadMsgsInfo
+		if err := json.Unmarshal(body, &answerGetUnreadMsgsInfo); err != nil {
 			return protocol.AnswerGetUnreadMsgsInfo{}, nil, err
 		}
-		return protocol.NewAnswerGetUnreadMsgsInfo(0, 0, nil), nil, errors.New(reportError.ErrorMessage)
-	}
-	answerGetUnreadMsgsInfo, err := protocol.UnmarshalAnswerGetUnreadMsgsInfo(answerGetUnreadMsgsInfoPacket.Body)
-	if err != nil {
-		return protocol.AnswerGetUnreadMsgsInfo{}, nil, err
-	}
 
-	//Create Set of needed certificates
+		senderSet := map[string]bool{}
-	senderSet := map[string]bool{}
+		for _, messageInfo := range answerGetUnreadMsgsInfo.MessagesInfo {
-	for _, messageInfo := range answerGetUnreadMsgsInfo.MessagesInfo {
+			senderSet[messageInfo.FromUID] = true
-		senderSet[messageInfo.FromUID] = true
-	}
-	certificatesMap := map[string]*x509.Certificate{}
-	//Get senders' certificates
-	for senderUID := range senderSet {
-		senderCert, err := getUserCert(cl, keyStore, senderUID)
-		if err == nil {
-			certificatesMap[senderUID] = senderCert
 		}
+
+		certificatesMap := map[string]*x509.Certificate{}
+		//Get senders' certificates
+		for senderUID := range senderSet {
+			senderCert, err := getUserCert(keyStore, senderUID)
+			if err == nil {
+				certificatesMap[senderUID] = senderCert
+			}
+		}
+		return answerGetUnreadMsgsInfo, certificatesMap, nil
+	} else {
+		var reportError protocol.ReportError
+		if err := json.Unmarshal(body, &reportError); err != nil {
+			return protocol.AnswerGetUnreadMsgsInfo{}, nil, err
+		}
+		return protocol.AnswerGetUnreadMsgsInfo{}, nil, errors.New(reportError.ErrorMessage)
+
 	}
-	return answerGetUnreadMsgsInfo, certificatesMap, nil
 }
 
-func askQueueCommand(clientKeyStore cryptoUtils.KeyStore, page int, pageSize int) error {
+func askQueueCommand(clientKeyStore cryptoUtils.KeyStore, page int, pageSize int) (int, int, []ClientMessageInfo, error) {
-	cl, err := networking.NewClient[protocol.Packet](&clientKeyStore)
-	if err != nil {
-		return err
-	}
-	defer cl.Connection.Conn.Close()
-	return askQueueRec(cl, clientKeyStore, page, pageSize)
-}
 
-func askQueueRec(cl networking.Client[protocol.Packet], clientKeyStore cryptoUtils.KeyStore, page int, pageSize int) error {
+	unreadMsgsInfo, certificates, err := getUnreadMessagesInfo(clientKeyStore, page, pageSize)
-
-	requestUnreadMsgsQueuePacket := protocol.NewGetUnreadMsgsInfoPacket(page, pageSize)
-	if err := cl.Connection.Send(requestUnreadMsgsQueuePacket); err != nil {
-		return err
-	}
-	unreadMsgsInfo, certificates, err := getManyMessagesInfo(cl, clientKeyStore)
 	if err != nil {
-		return err
+		return 0, 0, nil, err
 	}
 	var clientMessages []ClientMessageInfo
 	for _, message := range unreadMsgsInfo.MessagesInfo {
@@ -295,7 +402,12 @@ func askQueueRec(cl networking.Client[protocol.Packet], clientKeyStore cryptoUti
 			clientMessages = append(clientMessages, clientMessageInfo)
 			continue
 		}
-		decryptedSubjectBytes, err := clientKeyStore.DecryptMessageContent(senderCert, message.Subject)
+		oidMap := cryptoUtils.ExtractAllOIDValues(clientKeyStore.GetCert())
+		myUID := oidMap["2.5.4.65"]
+		if myUID == "" {
+			return 0, 0, nil, errors.New("no pseudonym field on my certificate")
+		}
+		decryptedSubjectBytes, err := clientKeyStore.DecryptMessageContent(senderCert, myUID, message.Subject)
 		if err != nil {
 			clientMessageInfo = newClientMessageInfo(message.Num, message.FromUID, "", message.Timestamp, err)
 			clientMessages = append(clientMessages, clientMessageInfo)
@@ -315,13 +427,5 @@ func askQueueRec(cl networking.Client[protocol.Packet], clientKeyStore cryptoUti
 		return clientMessages[i].Num > clientMessages[j].Num
 	})
 
-	action := showMessagesInfo(unreadMsgsInfo.Page, unreadMsgsInfo.NumPages, clientMessages)
+	return unreadMsgsInfo.Page, unreadMsgsInfo.NumPages, clientMessages, nil
-	switch action {
-	case -1:
-		return askQueueRec(cl, clientKeyStore, max(1, unreadMsgsInfo.Page-1), pageSize)
-	case 1:
-		return askQueueRec(cl, clientKeyStore, max(1, unreadMsgsInfo.Page+1), pageSize)
-	default:
-		return nil
-	}
 }

Projs/PD2/internal/gateway/forwarder.go

@@ -0,0 +1,191 @@
+package gateway
+
+import (
+	"PD2/internal/protocol"
+	"bytes"
+	"crypto/tls"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+)
+
+const baseURL = "https://127.0.0.1:8080"
+
+func getHTTPClient(tlsConfig *tls.Config) *http.Client{
+	transport := &http.Transport{TLSClientConfig: tlsConfig}
+	return &http.Client{Transport: transport}
+}
+
+func forwardStoreUserCert(tlsConfig *tls.Config,uid string,storeUserCertificate protocol.StoreUserCert) (int,[]byte,error) {
+    client := getHTTPClient(tlsConfig)
+
+    // Parse the base URL
+    parsedURL, err := url.Parse(baseURL)
+    if err != nil {
+        return 0,nil,fmt.Errorf("error parsing URL: %v", err)
+    }
+    parsedURL.JoinPath("certs")
+    parsedURL.JoinPath(uid)
+
+	jsonData, err := json.Marshal(storeUserCertificate)
+	if err != nil {
+		return 0,nil,fmt.Errorf("error marshaling JSON: %v", err)
+	}
+
+    req, err := http.NewRequest("POST", parsedURL.String(), bytes.NewBuffer(jsonData))
+	if err != nil {
+		return 0,nil,fmt.Errorf("error creating request: %v", err)
+	}
+
+    resp, err := client.Do(req)
+    if err != nil {
+		return 0,nil,fmt.Errorf("error making request: %v", err)
+	}
+	defer resp.Body.Close()
+
+    // Read response
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return 0,nil,fmt.Errorf("error reading response body: %v", err)
+	}
+
+    return resp.StatusCode,body,nil
+}
+
+func forwardGetMessage(tlsConfig *tls.Config,uid string,getMsg protocol.GetMsg) (int,[]byte,error) {
+    client := getHTTPClient(tlsConfig)
+
+    // Parse the base URL
+    parsedURL, err := url.Parse(baseURL)
+    if err != nil {
+        return 0,nil,fmt.Errorf("error parsing URL: %v", err)
+    }
+    parsedURL.JoinPath("message")
+    parsedURL.JoinPath(uid)
+    parsedURL.JoinPath(fmt.Sprint(getMsg.Num))
+
+    
+    req, err := http.NewRequest("GET", parsedURL.String(), nil)
+	if err != nil {
+		return 0,nil,fmt.Errorf("error creating request: %v", err)
+	}
+
+    resp, err := client.Do(req)
+    if err != nil {
+		return 0,nil,fmt.Errorf("error making request: %v", err)
+	}
+	defer resp.Body.Close()
+
+    // Read response
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return 0,nil,fmt.Errorf("error reading response body: %v", err)
+	}
+
+    return resp.StatusCode,body,nil
+}
+
+func forwardGetUnreadMsgsInfo(tlsConfig *tls.Config,uid string,getUnreadMsgsInfo protocol.GetUnreadMsgsInfo) (int,[]byte,error) {
+    client := getHTTPClient(tlsConfig)
+
+    // Parse the base URL
+    parsedURL, err := url.Parse(baseURL)
+    if err != nil {
+        return 0,nil,fmt.Errorf("error parsing URL: %v", err)
+    }
+    parsedURL.JoinPath("queue")
+    parsedURL.JoinPath(uid)
+
+    query := parsedURL.Query()
+    query.Set("page", fmt.Sprint(getUnreadMsgsInfo.Page))
+    query.Set("pagesize", fmt.Sprint(getUnreadMsgsInfo.PageSize))
+    parsedURL.RawQuery = query.Encode()
+
+    req, err := http.NewRequest("GET", parsedURL.String(), nil)
+	if err != nil {
+		return 0,nil,fmt.Errorf("error creating request: %v", err)
+	}
+
+    resp, err := client.Do(req)
+    if err != nil {
+		return 0,nil,fmt.Errorf("error making request: %v", err)
+	}
+	defer resp.Body.Close()
+
+    // Read response
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return 0,nil,fmt.Errorf("error reading response body: %v", err)
+	}
+
+    return resp.StatusCode,body,nil
+}
+
+func forwardGetUserCert(tlsConfig *tls.Config,getUserCert protocol.GetUserCert) (int,[]byte,error) {
+    client := getHTTPClient(tlsConfig)
+
+    // Parse the base URL
+    parsedURL, err := url.Parse(baseURL)
+    if err != nil {
+        return 0,nil,fmt.Errorf("error parsing URL: %v", err)
+    }
+    parsedURL.JoinPath("cert")
+    parsedURL.JoinPath(getUserCert.UID)
+    
+    req, err := http.NewRequest("GET", parsedURL.String(), nil)
+	if err != nil {
+		return 0,nil,fmt.Errorf("error creating request: %v", err)
+	}
+
+    resp, err := client.Do(req)
+    if err != nil {
+		return 0,nil,fmt.Errorf("error making request: %v", err)
+	}
+	defer resp.Body.Close()
+
+    // Read response
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return 0,nil,fmt.Errorf("error reading response body: %v", err)
+	}
+
+    return resp.StatusCode,body,nil
+}
+
+func forwardSendMessage(tlsConfig *tls.Config,uid string,sendMsg protocol.SendMsg) (int,[]byte,error) {
+    client := getHTTPClient(tlsConfig)
+
+    // Parse the base URL
+    parsedURL, err := url.Parse(baseURL)
+    if err != nil {
+        return 0,nil,fmt.Errorf("error parsing URL: %v", err)
+    }
+    parsedURL.JoinPath("message")
+    parsedURL.JoinPath(uid)
+
+	jsonData, err := json.Marshal(sendMsg)
+	if err != nil {
+		return 0,nil,fmt.Errorf("error marshaling JSON: %v", err)
+	}
+
+    req, err := http.NewRequest("POST", parsedURL.String(), bytes.NewBuffer(jsonData))
+	if err != nil {
+		return 0,nil,fmt.Errorf("error creating request: %v", err)
+	}
+
+    resp, err := client.Do(req)
+    if err != nil {
+		return 0,nil,fmt.Errorf("error making request: %v", err)
+	}
+	defer resp.Body.Close()
+
+    // Read response
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return 0,nil,fmt.Errorf("error reading response body: %v", err)
+	}
+
+    return resp.StatusCode,body,nil
+}

Projs/PD2/internal/gateway/gateway.go

@@ -4,28 +4,96 @@ import (
 	"PD2/internal/protocol"
 	"PD2/internal/utils/cryptoUtils"
 	"crypto/x509"
-	"fmt"
 	"log"
 	"net/http"
 
 	"github.com/gin-gonic/gin"
 )
 
-func HandleGetMessage(c *gin.Context) {
+func HandleGetMessage(c *gin.Context, keyStore cryptoUtils.KeyStore) {
-	fmt.Println("Get Message Handler")
+	var getMsg protocol.GetMsg
+	err := c.Bind(getMsg)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Request body is not a GetMsg"})
+		return
+	}
+
+	uid, exists := c.Get("uid")
+	if !exists {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "User does not exist"})
+		return
+	}
+
+	uidString := uid.(string)
+
+	statusCode, body, err := forwardGetMessage(keyStore.GetGatewayOutgoingTLSConfig(), uidString, getMsg)
+	if err != nil {
+		log.Println(err.Error())
+	} else {
+		c.JSON(statusCode, body)
+	}
+}
+func HandleGetUnreadMsgsInfo(c *gin.Context, keyStore cryptoUtils.KeyStore) {
+	var getUnreadMsgsInfo protocol.GetUnreadMsgsInfo
+	err := c.Bind(getUnreadMsgsInfo)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Request body is not a GetUnreadMsgsInfo"})
+		return
+	}
+
+	uid, exists := c.Get("uid")
+	if !exists {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "User does not exist"})
+		return
+	}
+
+	uidString := uid.(string)
+
+	statusCode, body, err := forwardGetUnreadMsgsInfo(keyStore.GetGatewayOutgoingTLSConfig(), uidString, getUnreadMsgsInfo)
+	if err != nil {
+		log.Println(err.Error())
+	} else {
+		c.JSON(statusCode, body)
+	}
 
 }
-func HandleGetUnreadMsgsInfo(c *gin.Context) {
+func HandleGetUserCert(c *gin.Context,keyStore cryptoUtils.KeyStore) {
-	fmt.Println("Get Unread Messages Info Handler")
+	var getUserCert protocol.GetUserCert
+	err := c.Bind(getUserCert)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Request body is not a GetUserCert"})
+		return
+	}
 
+	statusCode, body, err := forwardGetUserCert(keyStore.GetGatewayOutgoingTLSConfig(), getUserCert)
+	if err != nil {
+		log.Println(err.Error())
+	} else {
+		c.JSON(statusCode, body)
+	}
 }
-func HandleGetUserCert(c *gin.Context) {
+func HandleSendMessage(c *gin.Context, keyStore cryptoUtils.KeyStore) {
-	fmt.Println("Get User Cert Handler")
+	var sendMsg protocol.SendMsg
+	err := c.Bind(sendMsg)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Request body is not a SendMsg"})
+		return
+	}
 
-}
+	uid, exists := c.Get("uid")
-func HandleSendMessage(c *gin.Context) {
+	if !exists {
-	fmt.Println("Send Message Handler")
+		c.JSON(http.StatusBadRequest, gin.H{"error": "User does not exist"})
+		return
+	}
 
+	uidString := uid.(string)
+
+	statusCode, body, err := forwardSendMessage(keyStore.GetGatewayOutgoingTLSConfig(), uidString, sendMsg)
+	if err != nil {
+		log.Println(err.Error())
+	} else {
+		c.JSON(statusCode, body)
+	}
 }
 
 func HandleRegister(c *gin.Context, dataStore DataStore, keyStore cryptoUtils.KeyStore) {
@@ -36,22 +104,12 @@ func HandleRegister(c *gin.Context, dataStore DataStore, keyStore cryptoUtils.Ke
 		return
 	}
 
-	//Check if the certificate pseudonym matches the uid in postRegister
-	//And if it's signed by the CA
 	userCert, err := x509.ParseCertificate(postRegister.Certificate)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"error": "User certificate is invalid"})
 		return
 	}
 
-	oidMap := cryptoUtils.ExtractAllOIDValues(userCert)
-	//Check if certificate usage is MSG SERVICE
-	usage := oidMap["2.5.4.11"]
-	if usage != "MSG SERVICE" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Certificate usage is not \"MSG SERVICE\""})
-		return
-	}
-
 	err = keyStore.CheckCert(userCert, postRegister.UID, "MSG SERVICE")
 	if err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"error": "User certificate is invalid, not trusted, belongs to another user or has incorrect usage field"})
@@ -68,9 +126,13 @@ func HandleRegister(c *gin.Context, dataStore DataStore, keyStore cryptoUtils.Ke
 		log.Fatalln("Could not insert user into DB")
 	}
 
-	//TODO: Send the certificate to the server
+	storeUserCertificate := protocol.NewStoreUserCert(userCert.Raw)
-
+	statusCode, body, err := forwardStoreUserCert(keyStore.GetGatewayOutgoingTLSConfig(), postRegister.UID, storeUserCertificate)
-	c.JSON(http.StatusOK, gin.H{})
+	if err != nil {
+		log.Println(err.Error())
+	} else {
+		c.JSON(statusCode, body)
+	}
 
 }
 
@@ -101,7 +163,6 @@ func HandleLogin(c *gin.Context, dataStore DataStore, keyStore cryptoUtils.KeySt
 }
 
 func AuthMiddleware(c *gin.Context) {
-	fmt.Println("Authentication Middleware")
 	tokenList := c.Request.Header["Token"]
 	if tokenList == nil {
 		c.JSON(http.StatusUnauthorized, gin.H{"error": "No authentication token provided"})
@@ -137,19 +198,19 @@ func Run() {
 	})
 
 	auth.GET("/message/:num", func(c *gin.Context) {
-		HandleGetMessage(c)
+		HandleGetMessage(c, keyStore)
 	})
 
 	auth.GET("/queue", func(c *gin.Context) {
-		HandleGetUnreadMsgsInfo(c)
+		HandleGetUnreadMsgsInfo(c, keyStore)
 	})
 
 	auth.GET("/cert/:user", func(c *gin.Context) {
-		HandleGetUserCert(c)
+		HandleGetUserCert(c, keyStore)
 	})
 
 	auth.POST("/message", func(c *gin.Context) {
-		HandleSendMessage(c)
+		HandleSendMessage(c, keyStore)
 	})
 
 	router.POST("/register", func(c *gin.Context) {
@@ -161,7 +222,7 @@ func Run() {
 	})
 
 	server := http.Server{
-		Addr:      "0.0.0.0:8080",
+		Addr:      "0.0.0.0:9090",
 		Handler:   router,
 		TLSConfig: keyStore.GetGatewayIncomingTLSConfig(),
 	}

Projs/PD2/internal/protocol/protocol.go

@@ -31,6 +31,10 @@ type (
 		Certificate []byte `json:"certificate"`
 	}
 
+	StoreUserCert struct {
+		Certificate []byte `json:"certificate"`
+	}
+
 	AnswerGetUnreadMsgsInfo struct {
 		Page         int       `json:"page"`
 		NumPages     int       `json:"num_pages"`
@@ -59,8 +63,8 @@ type (
 	}
 
 	PostLogin struct {
-		UID         string `json:"uid"`
+		UID      string `json:"uid"`
-		Password    string `json:"password"`
+		Password string `json:"password"`
 	}
 
 	ReportError struct {
@@ -113,19 +117,24 @@ func NewMsgInfo(num int, fromUID string, subject []byte, timestamp time.Time) Ms
 	}
 }
 
-func NewPostRegister(UID string,Password string,Certificate []byte) PostRegister {
+func NewPostRegister(UID string, Password string, Certificate []byte) PostRegister {
-    return PostRegister{
+	return PostRegister{
-        UID: UID,
+		UID:         UID,
-        Password: Password,
+		Password:    Password,
-        Certificate: Certificate,
+		Certificate: Certificate,
-    }
+	}
+}
+func NewStoreUserCert(certificate []byte) StoreUserCert {
+	return StoreUserCert{
+		Certificate: certificate,
+	}
 }
 
-func NewPostLogin(UID string,Password string) PostLogin {
+func NewPostLogin(UID string, Password string) PostLogin {
-    return PostLogin{
+	return PostLogin{
-        UID: UID,
+		UID:      UID,
-        Password: Password,
+		Password: Password,
-    }
+	}
 }
 
 func NewAnswerGetMsg(fromUID, toUID string, subject []byte, body []byte, timestamp time.Time, last bool) AnswerGetMsg {

Projs/PD2/internal/server/datastore.go

@@ -226,11 +226,6 @@ func (ds DataStore) userExists(uid string) bool {
 }
 
 func (ds DataStore) storeUserCertIfNotExists(uid string, cert x509.Certificate) error {
-	// Check if the user already exists
-	if ds.userExists(uid) {
-		return nil
-	}
-
 	// Insert the user certificate
 	insertQuery := `
         INSERT INTO users (UID, userCert)

Projs/PD2/internal/server/server.go

@@ -3,6 +3,7 @@ package server
 import (
 	"PD2/internal/protocol"
 	"PD2/internal/utils/cryptoUtils"
+	"crypto/x509"
 	"log"
 	"net/http"
 	"strconv"
@@ -20,20 +21,58 @@ func HandleGetUserCert(c *gin.Context, dataStore DataStore) {
 	}
 }
 
-func HandleGetUnreadMsgsInfo(c *gin.Context, dataStore DataStore) {
+func HandleStoreUserCert(c *gin.Context, dataStore DataStore) {
 	user := c.Param("user")
-
+	var storeUserCert protocol.StoreUserCert
-	var getUnreadMsgsInfo protocol.GetUnreadMsgsInfo
+	if err := c.Bind(storeUserCert); err != nil {
-	if err := c.BindJSON(getUnreadMsgsInfo); err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
 		return
 	}
 
-	if getUnreadMsgsInfo.Page <= 0 || getUnreadMsgsInfo.PageSize <= 0 {
+	userCert, err := x509.ParseCertificate(storeUserCert.Certificate)
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Page and PageSize need to be >= 1"})
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "User certificate is invalid"})
 		return
 	}
-	unreadMsgsInfo, err := dataStore.GetUnreadMsgsInfo(user, getUnreadMsgsInfo.Page, getUnreadMsgsInfo.PageSize)
+
+	err = dataStore.storeUserCertIfNotExists(user, *userCert)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "User already has a certificate stored in the database"})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{})
+}
+
+func HandleGetUnreadMsgsInfo(c *gin.Context, dataStore DataStore) {
+	user := c.Param("user")
+	pageStr := c.Query("page")
+	pagesizeStr := c.Query("pagesize")
+
+    var page int
+    var err error
+	if pageStr != "" {
+		page, err = strconv.Atoi(pageStr)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "Page is not a number"})
+		}
+	} else {
+        page = 1
+	}
+	var pagesize int
+	if pagesizeStr != "" {
+		pagesize, err = strconv.Atoi(pagesizeStr)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "Pagesize is not a number"})
+		}
+	} else {
+		pagesize = 5
+	}
+
+	if page <= 0 || pagesize <= 0 {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Page and Pagesize need to be >= 1"})
+		return
+	}
+	unreadMsgsInfo, err := dataStore.GetUnreadMsgsInfo(user, page, pagesize)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
 		return
@@ -115,15 +154,19 @@ func Run() {
 		HandleSendMessage(c, dataStore)
 	})
 
+	r.POST("/cert/:user", func(c *gin.Context) {
+		HandleStoreUserCert(c, dataStore)
+	})
+
 	server := http.Server{
-		Addr:      "0.0.0.0:8080",
+		Addr:    "0.0.0.0:8080",
-		Handler:   r,
+		Handler: r,
-        //TODO: Verify if it's the gateway
+		//TODO: Verify if it's the gateway
 		TLSConfig: serverKeyStore.GetServerTLSConfig(),
 	}
 
 	err = server.ListenAndServeTLS("", "")
-    if err!=nil {
+	if err != nil {
-        log.Fatal(err.Error())
+		log.Fatal(err.Error())
-    }
+	}
 }

Projs/PD2/internal/utils/cryptoUtils/cryptoUtils.go

@@ -11,7 +11,6 @@ import (
 	"errors"
 	"time"
 
-	"log"
 	"os"
 
 	"golang.org/x/crypto/chacha20poly1305"
@@ -143,25 +142,7 @@ func (k *KeyStore) GetTLSConfig() *tls.Config {
 func (k *KeyStore) GetGatewayIncomingTLSConfig() *tls.Config {
 	tlsConfig := k.GetTLSConfig()
 
-	tlsConfig.ClientAuth = tls.RequireAnyClientCert
+	tlsConfig.ClientAuth = tls.NoClientCert
-	tlsConfig.VerifyPeerCertificate = func(rawCerts [][]byte, _ [][]*x509.Certificate) error {
-		for _, certBytes := range rawCerts {
-			cert, err := x509.ParseCertificate(certBytes)
-			if err != nil {
-				return err
-			}
-			if err = k.CheckCertCA(cert); err != nil {
-				return err
-			}
-			if err = k.CheckCertTime(cert); err != nil {
-				return err
-			}
-			if err = k.CheckCertUsage(cert, "MSG SERVICE"); err != nil {
-				return err
-			}
-		}
-		return nil
-	}
 	return tlsConfig
 }
 

Projs/PD2/internal/utils/networking/client.go

@@ -1,23 +0,0 @@
-package networking
-
-import (
-	"crypto/tls"
-)
-
-
-type ClientTLSConfigProvider interface {
-    GetClientTLSConfig() *tls.Config
-}
-
-type Client[T any] struct {
-	Connection Connection[T]
-}
-
-func NewClient[T any](clientTLSConfigProvider ClientTLSConfigProvider) (Client[T],error) {
-    dialConn, err := tls.Dial("tcp", "localhost:8080", clientTLSConfigProvider.GetClientTLSConfig())
-	if err != nil {
-        return Client[T]{},err
-	}
-	conn := NewConnection[T](dialConn)
-	return Client[T]{Connection: conn},nil
-}

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

@@ -1,51 +0,0 @@
-package networking
-
-import (
-	"crypto/tls"
-	"crypto/x509"
-	"encoding/json"
-	"io"
-	"log"
-)
-
-type Connection[T any] struct {
-	Conn    *tls.Conn
-	encoder *json.Encoder
-	decoder *json.Decoder
-}
-
-func NewConnection[T any](netConn *tls.Conn) Connection[T] {
-	return Connection[T]{
-		Conn:    netConn,
-		encoder: json.NewEncoder(netConn),
-		decoder: json.NewDecoder(netConn),
-	}
-}
-
-func (c Connection[T]) Send(obj T) error {
-    if err := c.encoder.Encode(&obj); err!=nil {
-		if err == io.EOF {
-			log.Println("Connection closed by peer")
-		} 
-        return err
-    }
-    //Return true as connection active
-    return nil
-}
-
-func (c Connection[T]) Receive() (*T, error) {
-	var obj T
-	if err := c.decoder.Decode(&obj); err != nil {
-		if err == io.EOF {
-			log.Println("Connection closed by peer")
-		} 	
-        return nil,err
-    }
-    //Return true as connection active
-	return &obj, nil
-}
-
-func (c Connection[T]) GetPeerCertificate() *x509.Certificate {
-	state := c.Conn.ConnectionState()
-	return state.PeerCertificates[0]
-}

Projs/PD2/internal/utils/networking/server.go

@@ -1,56 +0,0 @@
-package networking
-
-import (
-	"crypto/tls"
-	"log"
-	"net"
-)
-
-type ServerTLSConfigProvider interface {
-	GetServerTLSConfig() *tls.Config
-}
-
-type Server[T any] struct {
-	listener net.Listener
-	C        chan Connection[T]
-}
-
-func NewServer[T any](serverTLSConfigProvider ServerTLSConfigProvider) (Server[T], error) {
-
-	listener, err := tls.Listen("tcp", "127.0.0.1:8080", serverTLSConfigProvider.GetServerTLSConfig())
-	if err != nil {
-		return Server[T]{}, err
-	}
-	return Server[T]{
-		listener: listener,
-		C:        make(chan Connection[T]),
-	}, nil
-}
-
-func (s *Server[T]) ListenLoop() {
-
-	for {
-		listenerConn, err := s.listener.Accept()
-		if err != nil {
-			log.Println("Server could not accept connection")
-            continue
-		}
-		tlsConn, ok := listenerConn.(*tls.Conn)
-		if !ok {
-			log.Println("Connection is not a TLS connection")
-            continue
-		}
-		if err := tlsConn.Handshake(); err != nil {
-			log.Println(err)
-            continue
-		}
-
-		state := tlsConn.ConnectionState()
-		if len(state.PeerCertificates) == 0 {
-			log.Println("Client did not provide a certificate")
-            continue
-		}
-		conn := NewConnection[T](tlsConn)
-		s.C <- conn
-	}
-}