Uni/CSI-ES-2324
4
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

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

Browse source
This commit is contained in:
Afonso Franco 2024-05-30 21:02:28 +01:00
parent c94831d0a2
commit 78031d8e70
Signed by: afonso
SSH key fingerprint: SHA256:PQTRDHPH3yALEGtHXnXBp3Orfcn21pK20t0tS1kHg54
16 changed files with 698 additions and 337 deletions
Download patch file Download diff file Expand all files Collapse all files

191
Projs/PD2/internal/gateway/forwarder.go Normal file
View file

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

119
Projs/PD2/internal/gateway/gateway.go
View file

@ -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) {
fmt.Println("Get Message Handler")
func HandleGetMessage(c *gin.Context, keyStore cryptoUtils.KeyStore) {
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) {
fmt.Println("Get Unread Messages Info Handler")
func HandleGetUserCert(c *gin.Context,keyStore cryptoUtils.KeyStore) {
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) {
fmt.Println("Get User Cert Handler")
func HandleSendMessage(c *gin.Context, keyStore cryptoUtils.KeyStore) {
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
}
}
func HandleSendMessage(c *gin.Context) {
fmt.Println("Send Message Handler")
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 := 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
c.JSON(http.StatusOK, gin.H{})
storeUserCertificate := protocol.NewStoreUserCert(userCert.Raw)
statusCode, body, err := forwardStoreUserCert(keyStore.GetGatewayOutgoingTLSConfig(), postRegister.UID, storeUserCertificate)
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(),
}