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

[PD2] Relatorio inicio

Browse source 
Co-authored-by: tsousa111 <tiagao2001@hotmail.com>
This commit is contained in:
Afonso Franco 2024-05-31 23:14:06 +01:00
parent 6f8219d991
commit b86992a10a
Signed by: afonso
SSH key fingerprint: SHA256:PQTRDHPH3yALEGtHXnXBp3Orfcn21pK20t0tS1kHg54
10 changed files with 192 additions and 289 deletions
Download patch file Download diff file Expand all files Collapse all files

6
Projs/PD2/internal/client/client.go
View file

@ -137,7 +137,7 @@ func Run() {
os.Exit(1)
}
err := registerUser(myUID, password, clientKeyStore)
err := registerUser(password, clientKeyStore)
if err != nil {
printError(err.Error())
os.Exit(1)
@ -188,8 +188,8 @@ func getHTTPClient(tlsConfig *tls.Config) *http.Client {
return &http.Client{Transport: transport}
}
func registerUser(userId string, password string, clientKeyStore cryptoUtils.KeyStore) error {
postRegister := protocol.NewPostRegister(userId, password, clientKeyStore.GetCert().Raw)
func registerUser(password string, clientKeyStore cryptoUtils.KeyStore) error {
postRegister := protocol.NewPostRegister(password, clientKeyStore.GetCert().Raw)
jsonData, err := json.Marshal(postRegister)
if err != nil {

195
Projs/PD2/internal/gateway/forwarder.go
View file

@ -18,174 +18,173 @@ func getHTTPClient(tlsConfig *tls.Config) *http.Client{
return &http.Client{Transport: transport}
}
func forwardStoreUserCert(tlsConfig *tls.Config,uid string,storeUserCertificate protocol.StoreUserCert) (int,[]byte,error) {
client := getHTTPClient(tlsConfig)
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 = parsedURL.JoinPath("certs")
parsedURL = parsedURL.JoinPath(uid)
// Parse the base URL
parsedURL, err := url.Parse(baseURL)
if err != nil {
return 0, nil, fmt.Errorf("error parsing URL: %v", err)
}
parsedURL = parsedURL.JoinPath("certs")
parsedURL = parsedURL.JoinPath(uid)
jsonData, err := json.Marshal(storeUserCertificate)
if err != nil {
return 0,nil,fmt.Errorf("error marshaling JSON: %v", err)
return 0, nil, fmt.Errorf("error marshaling JSON: %v", err)
}
req, err := http.NewRequest("POST", parsedURL.String(), bytes.NewBuffer(jsonData))
req, err := http.NewRequest("POST", parsedURL.String(), bytes.NewBuffer(jsonData))
if err != nil {
return 0,nil,fmt.Errorf("error creating request: %v", err)
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)
resp, err := client.Do(req)
if err != nil {
return 0, nil, fmt.Errorf("error making request: %v", err)
}
defer resp.Body.Close()
// Read response
// Read response
body, err := io.ReadAll(resp.Body)
if err != nil {
return 0,nil,fmt.Errorf("error reading response body: %v", err)
return 0, nil, fmt.Errorf("error reading response body: %v", err)
}
return resp.StatusCode,body,nil
return resp.StatusCode, body, nil
}
func forwardGetMessage(tlsConfig *tls.Config,uid string,num string) (int,[]byte,error) {
client := getHTTPClient(tlsConfig)
func forwardGetMessage(tlsConfig *tls.Config, uid string, num string) (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 = parsedURL.JoinPath("message")
parsedURL = parsedURL.JoinPath(uid)
parsedURL = parsedURL.JoinPath(num)
req, err := http.NewRequest("GET", parsedURL.String(), nil)
// Parse the base URL
parsedURL, err := url.Parse(baseURL)
if err != nil {
return 0,nil,fmt.Errorf("error creating request: %v", err)
return 0, nil, fmt.Errorf("error parsing URL: %v", err)
}
parsedURL = parsedURL.JoinPath("message")
parsedURL = parsedURL.JoinPath(uid)
parsedURL = parsedURL.JoinPath(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)
resp, err := client.Do(req)
if err != nil {
return 0, nil, fmt.Errorf("error making request: %v", err)
}
defer resp.Body.Close()
// Read response
// Read response
body, err := io.ReadAll(resp.Body)
if err != nil {
return 0,nil,fmt.Errorf("error reading response body: %v", err)
return 0, nil, fmt.Errorf("error reading response body: %v", err)
}
return resp.StatusCode,body,nil
return resp.StatusCode, body, nil
}
func forwardGetUnreadMsgsInfo(tlsConfig *tls.Config,uid string,page string,pagesize string) (int,[]byte,error) {
client := getHTTPClient(tlsConfig)
func forwardGetUnreadMsgsInfo(tlsConfig *tls.Config, uid string, page string, pagesize string) (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 = parsedURL.JoinPath("queue")
parsedURL = parsedURL.JoinPath(uid)
query := parsedURL.Query()
query.Set("page", page)
query.Set("pagesize", pagesize)
parsedURL.RawQuery = query.Encode()
req, err := http.NewRequest("GET", parsedURL.String(), nil)
// Parse the base URL
parsedURL, err := url.Parse(baseURL)
if err != nil {
return 0,nil,fmt.Errorf("error creating request: %v", err)
return 0, nil, fmt.Errorf("error parsing URL: %v", err)
}
parsedURL = parsedURL.JoinPath("queue")
parsedURL = parsedURL.JoinPath(uid)
query := parsedURL.Query()
query.Set("page", page)
query.Set("pagesize", 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)
resp, err := client.Do(req)
if err != nil {
return 0, nil, fmt.Errorf("error making request: %v", err)
}
defer resp.Body.Close()
// Read response
// Read response
body, err := io.ReadAll(resp.Body)
if err != nil {
return 0,nil,fmt.Errorf("error reading response body: %v", err)
return 0, nil, fmt.Errorf("error reading response body: %v", err)
}
return resp.StatusCode,body,nil
return resp.StatusCode, body, nil
}
func forwardGetUserCert(tlsConfig *tls.Config,uid string) (int,[]byte,error) {
client := getHTTPClient(tlsConfig)
func forwardGetUserCert(tlsConfig *tls.Config, uid string) (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 = parsedURL.JoinPath("cert")
parsedURL = parsedURL.JoinPath(uid)
req, err := http.NewRequest("GET", parsedURL.String(), nil)
// Parse the base URL
parsedURL, err := url.Parse(baseURL)
if err != nil {
return 0,nil,fmt.Errorf("error creating request: %v", err)
return 0, nil, fmt.Errorf("error parsing URL: %v", err)
}
parsedURL = parsedURL.JoinPath("cert")
parsedURL = parsedURL.JoinPath(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)
resp, err := client.Do(req)
if err != nil {
return 0, nil, fmt.Errorf("error making request: %v", err)
}
defer resp.Body.Close()
// Read response
// Read response
body, err := io.ReadAll(resp.Body)
if err != nil {
return 0,nil,fmt.Errorf("error reading response body: %v", err)
return 0, nil, fmt.Errorf("error reading response body: %v", err)
}
return resp.StatusCode,body,nil
return resp.StatusCode, body, nil
}
func forwardSendMessage(tlsConfig *tls.Config,uid string,sendMsg protocol.SendMsg) (int,[]byte,error) {
client := getHTTPClient(tlsConfig)
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 = parsedURL.JoinPath("message")
parsedURL = parsedURL.JoinPath(uid)
// Parse the base URL
parsedURL, err := url.Parse(baseURL)
if err != nil {
return 0, nil, fmt.Errorf("error parsing URL: %v", err)
}
parsedURL = parsedURL.JoinPath("message")
parsedURL = parsedURL.JoinPath(uid)
jsonData, err := json.Marshal(sendMsg)
if err != nil {
return 0,nil,fmt.Errorf("error marshaling JSON: %v", err)
return 0, nil, fmt.Errorf("error marshaling JSON: %v", err)
}
req, err := http.NewRequest("POST", parsedURL.String(), bytes.NewBuffer(jsonData))
req, err := http.NewRequest("POST", parsedURL.String(), bytes.NewBuffer(jsonData))
if err != nil {
return 0,nil,fmt.Errorf("error creating request: %v", err)
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)
resp, err := client.Do(req)
if err != nil {
return 0, nil, fmt.Errorf("error making request: %v", err)
}
defer resp.Body.Close()
// Read response
// Read response
body, err := io.ReadAll(resp.Body)
if err != nil {
return 0,nil,fmt.Errorf("error reading response body: %v", err)
return 0, nil, fmt.Errorf("error reading response body: %v", err)
}
return resp.StatusCode,body,nil
return resp.StatusCode, body, nil
}

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

@ -104,27 +104,37 @@ func HandleRegister(c *gin.Context, dataStore DataStore, keyStore cryptoUtils.Ke
c.JSON(http.StatusBadRequest, gin.H{"error": "User certificate is invalid"})
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"})
if err := keyStore.CheckCertCA(userCert); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
if err := keyStore.CheckCertTime(userCert); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
if err := keyStore.CheckCertUsage(userCert, "MSG SERVICE"); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
hashedPassword, err := HashPassword(postRegister.Password)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "Could not hash password"})
c.JSON(http.StatusBadRequest, gin.H{"error": "Could not hash password"})
return
}
err = dataStore.InsertUser(postRegister.UID, hashedPassword)
uid,err := keyStore.GetCertPseudonym(userCert)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
err = dataStore.InsertUser(uid, hashedPassword)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "Could not insert user into DB"})
c.JSON(http.StatusBadRequest, gin.H{"error": "Could not insert user into DB"})
return
}
storeUserCertificate := protocol.NewStoreUserCert(userCert.Raw)
statusCode, body, err := forwardStoreUserCert(keyStore.GetGatewayOutgoingTLSConfig(), postRegister.UID, storeUserCertificate)
statusCode, body, err := forwardStoreUserCert(keyStore.GetGatewayOutgoingTLSConfig(),uid, storeUserCertificate)
if err != nil {
log.Println(err.Error())
} else {

4
Projs/PD2/internal/protocol/protocol.go
View file

@ -43,7 +43,6 @@ type (
}
PostRegister struct {
UID string `json:"uid"`
Password string `json:"password"`
Certificate []byte `json:"certificate"`
}
@ -85,9 +84,8 @@ func NewMsgInfo(num int, fromUID string, subject []byte, timestamp time.Time) Ms
}
}
func NewPostRegister(UID string, Password string, Certificate []byte) PostRegister {
func NewPostRegister(Password string, Certificate []byte) PostRegister {
return PostRegister{
UID: UID,
Password: Password,
Certificate: Certificate,
}

14
Projs/PD2/internal/utils/cryptoUtils/cryptoUtils.go
View file

@ -101,15 +101,25 @@ func (k KeyStore) CheckCertTime(cert *x509.Certificate) error {
func (k KeyStore) CheckCertPseudonym(cert *x509.Certificate, pseudonym string) error {
oidMap := ExtractAllOIDValues(cert)
if oidMap["2.5.4.65"] != pseudonym {
return errors.New("Certificate does not belong to the correct pseudonym")
return errors.New("certificate does not belong to the correct pseudonym")
}
return nil
}
// Check if the pseudonym field is set to the correct pseudonym
func (k KeyStore) GetCertPseudonym(cert *x509.Certificate) (string,error){
oidMap := ExtractAllOIDValues(cert)
uid := oidMap["2.5.4.65"]
if uid == "" {
return "",errors.New("certificate does not have a pseudonym field")
}
return uid, nil
}
func (k KeyStore) CheckCertUsage(cert *x509.Certificate, usage string) error {
oidMap := ExtractAllOIDValues(cert)
if oidMap["2.5.4.11"] != usage {
return errors.New("Certificate does not have the correct usage")
return errors.New("certificate does not have the correct usage")
}
return nil
}