adding chain authentication

Author: p-shubh

.gitignore

@@ -35,4 +35,6 @@ erebrus-linux-x64
 # bin folder
 /bin
 
-env.text
+env.text
+D:/jjsahdd/server.json
+D:/jjsahdd/wg0.conf

.sample-env

@@ -8,7 +8,7 @@ REGION=EU
 
 # PASETO Specifications
 PASETO_EXPIRATION_IN_HOURS=168
-AUTH_EULA=I Accept the Erebrus Terms of Service https://erebrus.io/terms.html for accessing the application. Challenge ID: 
+AUTH_EULA=I Accept the Erebrus Terms of Service https://erebrus.io/terms.html for accessing the application. 
 SIGNED_BY=Erebrus
 FOOTER=Erebrus 2024
 

api/v1/authenticate/authenticate.go

@@ -1,13 +1,15 @@
 package authenticate
 
 import (
+	"fmt"
 	"net/http"
 	"os"
 
 	"github.com/NetSepio/erebrus/api/v1/authenticate/challengeid"
 	"github.com/NetSepio/erebrus/util/pkg/auth"
 	"github.com/NetSepio/erebrus/util/pkg/claims"
-	"github.com/NetSepio/erebrus/util/pkg/cryptosign"
+	"github.com/NetSepio/gateway/util/pkg/logwrapper"
+	"github.com/TheLazarusNetwork/go-helpers/httpo"
 
 	"github.com/gin-gonic/gin"
 	log "github.com/sirupsen/logrus"
@@ -38,27 +40,95 @@ func authenticate(c *gin.Context) {
 	}
 	userAuthEULA := os.Getenv("AUTH_EULA")
 	message := userAuthEULA + req.ChallengeId
-	walletAddress, isCorrect, err := cryptosign.CheckSign(req.Signature, req.ChallengeId, message)
+	// walletAddress, isCorrect, err := cryptosign.CheckSign(req.Signature, req.ChallengeId, message)
 
-	if err == cryptosign.ErrFlowIdNotFound {
-		log.WithFields(log.Fields{
-			"err": err,
-		}).Error("FlowId Not Found")
-		errResponse := ErrAuthenticate(err.Error())
-		c.JSON(http.StatusNotFound, errResponse)
-		return
-	}
+	// if err == cryptosign.ErrChallangeIdNotFound {
+	// 	log.WithFields(log.Fields{
+	// 		"err": err,
+	// 	}).Error("FlowId Not Found")
+	// 	errResponse := ErrAuthenticate(err.Error())
+	// 	c.JSON(http.StatusNotFound, errResponse)
+	// 	return
+	// }
 
-	if err != nil {
-		log.WithFields(log.Fields{
-			"err": err,
-		}).Error("failed to CheckSignature")
-		errResponse := ErrAuthenticate(err.Error())
-		c.JSON(http.StatusInternalServerError, errResponse)
-		return
+	// if err != nil {
+	// 	log.WithFields(log.Fields{
+	// 		"err": err,
+	// 	}).Error("failed to CheckSignature")
+	// 	errResponse := ErrAuthenticate(err.Error())
+	// 	c.JSON(http.StatusInternalServerError, errResponse)
+	// 	return
+	// }
+
+	var (
+		isCorrect bool
+		// userId     string
+		walletAddr string
+	)
+
+	switch req.ChainName {
+	case "EVM", "PEAQ":
+		userAuthEULA := userAuthEULA
+		message := userAuthEULA + req.ChallengeId
+		walletAddr, isCorrect, err = CheckSignEth(req.Signature, req.ChallengeId, message)
+
+		if err == ErrChallangeIdNotFound {
+			httpo.NewErrorResponse(http.StatusNotFound, "Challange Id not found")
+			return
+		}
+
+		if err != nil {
+			logwrapper.Errorf("failed to CheckSignature, error %v", err.Error())
+			httpo.NewErrorResponse(http.StatusInternalServerError, "Unexpected error occurred").SendD(c)
+			return
+		}
+
+	case "APTOS":
+		userAuthEULA := userAuthEULA
+		message := fmt.Sprintf("APTOS\nmessage: %v\nnonce: %v", userAuthEULA, req.ChallengeId)
+		walletAddr, isCorrect, err = CheckSign(req.Signature, req.ChallengeId, message, req.PubKey)
+
+		if err == ErrChallangeIdNotFound {
+			httpo.NewErrorResponse(http.StatusNotFound, "Challange Id not found")
+			return
+		}
+
+		if err != nil {
+			logwrapper.Errorf("failed to CheckSignature, error %v", err.Error())
+			httpo.NewErrorResponse(http.StatusInternalServerError, "Unexpected error occurred").SendD(c)
+			return
+		}
+
+	case "SUI":
+		walletAddr, isCorrect, err = CheckSignSui(req.Signature, req.ChallengeId)
+
+		if err == ErrChallangeIdNotFound {
+			httpo.NewErrorResponse(http.StatusNotFound, "Challange Id not found")
+			return
+		}
+
+		if err != nil {
+			logwrapper.Errorf("failed to CheckSignature, error %v", err.Error())
+			httpo.NewErrorResponse(http.StatusInternalServerError, "Unexpected error occurred").SendD(c)
+			return
+		}
+
+	case "SOLANA":
+		walletAddr, isCorrect, err = CheckSignSol(req.Signature, req.ChallengeId, message, req.PubKey)
+
+		if err == ErrChallangeIdNotFound {
+			httpo.NewErrorResponse(http.StatusNotFound, "Challange Id not found")
+			return
+		}
+
+		if err != nil {
+			logwrapper.Errorf("failed to CheckSignature, error %v", err.Error())
+			httpo.NewErrorResponse(http.StatusInternalServerError, "Unexpected error occurred").SendD(c)
+			return
+		}
 	}
 	if isCorrect {
-		customClaims := claims.New(walletAddress)
+		customClaims := claims.New(walletAddr)
 		pasetoToken, err := auth.GenerateTokenPaseto(customClaims)
 		if err != nil {
 			log.WithFields(log.Fields{

api/v1/authenticate/challengeid/challengid.go

@@ -2,6 +2,7 @@ package challengeid
 
 import (
 	"encoding/hex"
+	"math/big"
 	"net/http"
 	"os"
 	"regexp"
@@ -61,17 +62,19 @@ func GetChallengeId(c *gin.Context) {
 
 	if err := ValidateAddress(chainName, walletAddress); err != nil {
 
-		info := " pass chain name between SOLANA, PEAQ, APTOS, SUI, ECLIPSE"
+		info := "chain name = " + chainName + "; pass chain name between SOLANA, PEAQ, APTOS, SUI, ECLIPSE, EVM"
 
 		switch err {
 		case ErrInvalidChain:
 			log.WithFields(log.Fields{"err": ErrInvalidChain}).Error("failed to create client")
 			response := core.MakeErrorResponse(http.StatusNotAcceptable, ErrInvalidChain.Error()+info, nil, nil, nil)
 			c.JSON(http.StatusNotAcceptable, response)
+			return
 		case ErrInvalidAddress:
 			log.WithFields(log.Fields{"err": ErrInvalidAddress}).Error("failed to create client")
 			response := core.MakeErrorResponse(http.StatusNotAcceptable, ErrInvalidAddress.Error(), nil, nil, nil)
 			c.JSON(http.StatusNotAcceptable, response)
+			return
 		}
 		return
 	}
@@ -117,6 +120,7 @@ func GenerateChallengeId(walletAddress string, chainName string) (string, error)
 	var dbdata MemoryDB
 	dbdata.WalletAddress = walletAddress
 	dbdata.Timestamp = time.Now()
+	dbdata.ChainName = chainName
 	Data = map[string]MemoryDB{
 		challengeId: dbdata,
 	}
@@ -126,10 +130,14 @@ func GenerateChallengeId(walletAddress string, chainName string) (string, error)
 // ValidateAddress validates a wallet address for the specified blockchain
 func ValidateAddress(chain, address string) error {
 	// Convert chain name to lowercase for case-insensitive comparison
-	chain = strings.ToLower(chain)
+	// chain = strings.ToLower(chain)
 
 	switch chain {
-	case "SOLANA", "SOL", "ECLIPSE":
+	case "EVM":
+		if !ValidateAddressEtherium(address) {
+			return ErrInvalidAddress
+		}
+	case "SOLANA", "ECLIPSE":
 		if !ValidateSolanaAddress(address) {
 			return ErrInvalidAddress
 		}
@@ -139,7 +147,7 @@ func ValidateAddress(chain, address string) error {
 			return ErrInvalidAddress
 		}
 
-	case "APTOS", "APT":
+	case "APTOS":
 		if !ValidateAptosAddress(address) {
 			return ErrInvalidAddress
 		}
@@ -201,3 +209,11 @@ func ValidateSuiAddress(address string) bool {
 	_, err := hex.DecodeString(address)
 	return err == nil
 }
+
+func ValidateAddressEtherium(address string) bool {
+	if len(address) != 42 || !strings.HasPrefix(address, "0x") {
+		return false
+	}
+	_, isValid := big.NewInt(0).SetString(address[2:], 16)
+	return isValid
+}