[PD2] login and register done

Projs/PD2/internal/client/client.go

@@ -20,6 +20,7 @@ import (
 )
 
 const baseURL = "https://127.0.0.1:9090"
+const tokenFolder = "token/"
 
 func Run() {
 	var userFile string
@@ -36,9 +37,27 @@ func Run() {
 		log.Fatalln(err)
 	}
 
-	token = cryptoUtils.GetUserToken()
+	oidMap := cryptoUtils.ExtractAllOIDValues(clientKeyStore.GetCert())
-
+	myUID := oidMap["2.5.4.65"]
+	if myUID == "" {
+		printError("no pseudonym field on my certificate")
+		os.Exit(1)
+	}
 	command := flag.Arg(0)
+	// Check if token is in memory
+	var token string
+	if command != "login" && command != "register" {
+		tokenFile, err := os.ReadFile(tokenFolder + myUID)
+		if err != nil {
+			printError(err.Error())
+			os.Exit(1)
+		}
+		token := string(tokenFile)
+		if token == "" {
+			printError("MSG SERVICE: token read error")
+			os.Exit(1)
+		}
+	}
 	switch command {
 	case "send":
 		if flag.NArg() != 3 {
@@ -49,7 +68,7 @@ func Run() {
 		uid := flag.Arg(1)
 		plainSubject := flag.Arg(2)
 		plainBody := readStdin("Enter message content (limited to 1000 bytes):")
-		err := sendCommand(clientKeyStore, plainSubject, plainBody, uid)
+		err := sendCommand(clientKeyStore, plainSubject, plainBody, uid, token)
 		if err != nil {
 			log.Fatalln(err)
 		}
@@ -75,7 +94,7 @@ func Run() {
 			}
 		}
 
-		page, pageSize, listClientMessageInfo, err := askQueueCommand(clientKeyStore, page, pageSize)
+		page, pageSize, listClientMessageInfo, err := askQueueCommand(clientKeyStore, page, pageSize, token)
 		if err != nil {
 			log.Fatalln(err)
 		}
@@ -92,44 +111,76 @@ func Run() {
 		if err != nil {
 			log.Fatalln(err)
 		}
-		msg, err := getMsgCommand(clientKeyStore, num)
+		msg, err := getMsgCommand(clientKeyStore, num, token)
 		if err != nil {
 			printError(err.Error())
+			os.Exit(1)
 		}
 		showMessage(msg)
 	case "register":
 		// call register
-		if flag.NArg() > 3 {
+		if flag.NArg() > 2 {
 			printError("MSG SERVICE: command error!")
 			showHelp()
 			os.Exit(1)
 		}
 		userId := flag.Arg(1)
-		password := flag.Arg(2)
+		if userId == "" {
-		if userId == "" || password == "" {
 			printError("MSG SERVICE: command error!")
 			showHelp()
 			os.Exit(1)
 		}
-        err := registerUser(userId, password, clientKeyStore)
-        if err != nil {
-            printError(err.Error())
-        }
-        // TODO: print register successful
-	case "login":
-		if flag.NArg() > 3 {
-			printError("MSG SERVICE: command error!")
-			showHelp()
-			os.Exit(1)
-		}
-		userId := flag.Arg(1)
-		password := flag.Arg(2)
-        err := login(userId,password,clientKeyStore)
-        if err != nil {
-            printError(err.Error())
-        }
 
-        // TODO: print logged in
+		password := readStdin("Enter password: ")
+		if password == "" {
+			printError("MSG SERVICE: command error!")
+			showHelp()
+			os.Exit(1)
+		}
+		passwordConfirmation := readStdin("Confirm password: ")
+		if password != passwordConfirmation {
+			printError("MSG SERVICE: passwords do not match")
+			os.Exit(1)
+		}
+
+		err := registerUser(userId, password, clientKeyStore)
+		if err != nil {
+			printError(err.Error())
+			os.Exit(1)
+		}
+		// TODO: print register successful
+	case "login":
+		if flag.NArg() != 1 {
+			printError("MSG SERVICE: command error!")
+			showHelp()
+			os.Exit(1)
+		}
+		password := readStdin("Enter password: ")
+		if password == "" {
+			printError("MSG SERVICE: command error!")
+			showHelp()
+			os.Exit(1)
+		}
+		token, err := login(myUID, password, clientKeyStore)
+		if err != nil {
+			printError(err.Error())
+			os.Exit(1)
+		}
+
+		tokenFile, err := os.OpenFile(tokenFolder+myUID, os.O_CREATE|os.O_WRONLY, 0600)
+		if err != nil {
+			printError(err.Error())
+			os.Exit(1)
+		}
+		defer tokenFile.Close()
+		// TODO: Maybe encrypt token
+		_, err = tokenFile.WriteString(token)
+		if err != nil {
+			printError(err.Error())
+			os.Exit(1)
+		}
+
+		// TODO: print logged in
 	case "help":
 		showHelp()
 
@@ -184,65 +235,60 @@ func registerUser(userId string, password string, clientKeyStore cryptoUtils.Key
 		}
 		return errors.New(reportError.ErrorMessage)
 	}
-
 	return nil
 }
 
-type Token struct {
+func login(userId string, password string, clientKeyStore cryptoUtils.KeyStore) (string, error) {
-    Value string `json:"token"`
-}
-
-func login(userId string, password string, clientKeyStore cryptoUtils.KeyStore) error {
 	postLogin := protocol.NewPostLogin(userId, password)
 
 	jsonData, err := json.Marshal(postLogin)
 	if err != nil {
-		return err
+		return "", err
 	}
 
 	client := getHTTPClient(clientKeyStore.GetClientTLSConfig())
 
 	parsedURL, err := url.Parse(baseURL)
 	if err != nil {
-		return err
+		return "", err
 	}
-	parsedURL.JoinPath("Login")
+	parsedURL.JoinPath("login")
 
 	req, err := http.NewRequest("POST", parsedURL.String(), bytes.NewBuffer(jsonData))
 	if err != nil {
-		return fmt.Errorf("error creating request: %v", err)
+		return "", fmt.Errorf("error creating request: %v", err)
 	}
 
 	resp, err := client.Do(req)
 	if err != nil {
-		return fmt.Errorf("error making request: %v", err)
+		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)
+		return "", fmt.Errorf("error reading response body: %v", err)
 	}
 
 	if resp.StatusCode != http.StatusOK {
 		var reportError protocol.ReportError
 		if err := json.Unmarshal(responseBody, &reportError); err != nil {
-			return err
+			return "", err
 		}
-		return errors.New(reportError.ErrorMessage)
+		return "", errors.New(reportError.ErrorMessage)
 	}
-    var token Token
+	token := struct {
-    err = json.Unmarshal(responseBody,token)
+		TokenString string `json:"token"`
-    if err != nil {
+	}{}
-        return err
+	err = json.Unmarshal(responseBody, &token)
-    }
+	if err != nil {
-    // TODO: persist token to disk
+		return "", err
-
+	}
-	return nil
+	return token.TokenString, nil
 }
 
-func sendCommand(clientKeyStore cryptoUtils.KeyStore, plainSubject, plainBody, uid string) error {
+func sendCommand(clientKeyStore cryptoUtils.KeyStore, plainSubject, plainBody, recieverUID string, token string) error {
 	//Turn content to bytes
 	plainSubjectBytes, err := Marshal(plainSubject)
 	if err != nil {
@@ -253,15 +299,15 @@ func sendCommand(clientKeyStore cryptoUtils.KeyStore, plainSubject, plainBody, u
 		return err
 	}
 
-	receiverCert, err := getUserCert(clientKeyStore, uid)
+	receiverCert, err := getUserCert(clientKeyStore, recieverUID, token)
 	if err != nil {
 		return err
 	}
-	subject, err := clientKeyStore.EncryptMessageContent(receiverCert, uid, plainSubjectBytes)
+	subject, err := clientKeyStore.EncryptMessageContent(receiverCert, recieverUID, plainSubjectBytes)
 	if err != nil {
 		return err
 	}
-	body, err := clientKeyStore.EncryptMessageContent(receiverCert, uid, plainBodyBytes)
+	body, err := clientKeyStore.EncryptMessageContent(receiverCert, recieverUID, plainBodyBytes)
 	if err != nil {
 		return err
 	}
@@ -275,7 +321,7 @@ func sendCommand(clientKeyStore cryptoUtils.KeyStore, plainSubject, plainBody, u
 	}
 	parsedURL.JoinPath("message")
 
-	sendMsgPacket := protocol.NewSendMsg(uid, subject, body)
+	sendMsgPacket := protocol.NewSendMsg(recieverUID, subject, body)
 
 	jsonData, err := json.Marshal(sendMsgPacket)
 	if err != nil {
@@ -311,8 +357,7 @@ func sendCommand(clientKeyStore cryptoUtils.KeyStore, plainSubject, plainBody, u
 	return nil
 }
 
-func getMsgCommand(clientKeyStore cryptoUtils.KeyStore, num int) (ClientMessage, error) {
+func getMsgCommand(clientKeyStore cryptoUtils.KeyStore, num int, token string) (ClientMessage, error) {
-
 	client := getHTTPClient(clientKeyStore.GetClientTLSConfig())
 
 	// Parse the base URL
@@ -361,7 +406,7 @@ func getMsgCommand(clientKeyStore cryptoUtils.KeyStore, num int) (ClientMessage,
 		return ClientMessage{}, err
 	}
 
-	senderCert, err := getUserCert(clientKeyStore, answerGetMsg.FromUID)
+	senderCert, err := getUserCert(clientKeyStore, answerGetMsg.FromUID, token)
 	if err != nil {
 		return ClientMessage{}, err
 	}
@@ -392,7 +437,7 @@ func getMsgCommand(clientKeyStore cryptoUtils.KeyStore, num int) (ClientMessage,
 	return message, nil
 }
 
-func getUserCert(keyStore cryptoUtils.KeyStore, uid string) (*x509.Certificate, error) {
+func getUserCert(keyStore cryptoUtils.KeyStore, uid string, token string) (*x509.Certificate, error) {
 
 	client := getHTTPClient(keyStore.GetClientTLSConfig())
 
@@ -446,7 +491,7 @@ func getUserCert(keyStore cryptoUtils.KeyStore, uid string) (*x509.Certificate,
 
 }
 
-func getUnreadMessagesInfo(keyStore cryptoUtils.KeyStore, page int, pageSize int) (protocol.AnswerGetUnreadMsgsInfo, map[string]*x509.Certificate, error) {
+func getUnreadMessagesInfo(keyStore cryptoUtils.KeyStore, page int, pageSize int, token string) (protocol.AnswerGetUnreadMsgsInfo, map[string]*x509.Certificate, error) {
 	client := getHTTPClient(keyStore.GetClientTLSConfig())
 
 	// Parse the base URL
@@ -496,7 +541,7 @@ func getUnreadMessagesInfo(keyStore cryptoUtils.KeyStore, page int, pageSize int
 		certificatesMap := map[string]*x509.Certificate{}
 		//Get senders' certificates
 		for senderUID := range senderSet {
-			senderCert, err := getUserCert(keyStore, senderUID)
+			senderCert, err := getUserCert(keyStore, senderUID, token)
 			if err == nil {
 				certificatesMap[senderUID] = senderCert
 			}
@@ -512,9 +557,9 @@ func getUnreadMessagesInfo(keyStore cryptoUtils.KeyStore, page int, pageSize int
 	}
 }
 
-func askQueueCommand(clientKeyStore cryptoUtils.KeyStore, page int, pageSize int) (int, int, []ClientMessageInfo, error) {
+func askQueueCommand(clientKeyStore cryptoUtils.KeyStore, page int, pageSize int, token string) (int, int, []ClientMessageInfo, error) {
 
-	unreadMsgsInfo, certificates, err := getUnreadMessagesInfo(clientKeyStore, page, pageSize)
+	unreadMsgsInfo, certificates, err := getUnreadMessagesInfo(clientKeyStore, page, pageSize, token)
 	if err != nil {
 		return 0, 0, nil, err
 	}