Merge pull request #78 from FIWARE/feat/update-qr-ui

Update QR v2 interface

Author: wistefan

common/cache.go

@@ -12,6 +12,7 @@ type Cache interface {
 	Add(k string, x interface{}, d time.Duration) error
 	Get(k string) (interface{}, bool)
 	Set(k string, x interface{}, d time.Duration)
+	GetWithExpiration(k string) (interface{}, time.Time, bool)
 	Delete(k string)
 }
 

openapi/api_api_test.go

@@ -46,8 +46,8 @@ type mockVerifier struct {
 func (mV *mockVerifier) ReturnLoginQR(host string, protocol string, callback string, sessionId string, clientId string, nonce string, requestType string) (qr string, err error) {
 	return mV.mockQR, mV.mockError
 }
-func (mV *mockVerifier) ReturnLoginQRV2(host string, protocol string, callback string, sessionId string, clientId string, scope string, nonce string, requestMode string) (qr string, err error) {
-	return mV.mockQR, mV.mockError
+func (mV *mockVerifier) ReturnLoginQRV2(host string, protocol string, callback string, sessionId string, clientId string, scope string, nonce string, requestMode string) (qrInfo verifier.QRLoginInfo, err error) {
+	return verifier.QRLoginInfo{QR: mV.mockQR}, mV.mockError
 }
 func (mV *mockVerifier) StartSiopFlow(host string, protocol string, callback string, sessionId string, clientId string, nonce string, requestType string) (connectionString string, err error) {
 	return mV.mockConnectionString, mV.mockError

openapi/api_frontend.go

@@ -10,6 +10,7 @@
 package openapi
 
 import (
+	"html/template"
 	"net/http"
 	"slices"
 
@@ -141,13 +142,19 @@ func VerifierLoginQr(c *gin.Context) {
 		requestMode = DEFAULT_REQUEST_MODE
 	}
 
-	qr, err := getFrontendVerifier().ReturnLoginQRV2(c.Request.Host, "https", redirectUri, state, clientId, scope, nonce, requestMode)
+	qrInfo, err := getFrontendVerifier().ReturnLoginQRV2(c.Request.Host, "https", redirectUri, state, clientId, scope, nonce, requestMode)
 	if err != nil {
 		c.AbortWithStatusJSON(500, ErrorMessage{"qr_generation_error", err.Error()})
 		return
 	}
 
-	c.HTML(http.StatusOK, "verifier_present_qr_v2", gin.H{"qrcode": qr, "wsUrl": getFrontendVerifier().GetHost() + "/ws?state=" + state})
+	c.HTML(http.StatusOK, "verifier_present_qr_v2", gin.H{
+		"qrcode":      template.URL(qrInfo.QR),
+		"wsUrl":       getFrontendVerifier().GetHost() + "/ws?state=" + state,
+		"qrExpireAt":  qrInfo.ExpireAt.UnixMilli(),
+		"qrDuration":  qrInfo.TotalDuration,
+		"authRequest": template.URL(qrInfo.AuthenticationRequest),
+	})
 }
 
 // VerifierPageLoginExpired - Presents a page when the login session is expired

tir/tirClient_test.go

@@ -40,6 +40,9 @@ func (mc mockCache) Add(k string, x interface{}, d time.Duration) error { return
 func (mc mockCache) Set(k string, x interface{}, d time.Duration)       {}
 func (mc mockCache) Get(k string) (interface{}, bool)                   { return nil, false }
 func (mc mockCache) Delete(k string)                                    {}
+func (mc mockCache) GetWithExpiration(k string) (interface{}, time.Time, bool) {
+	return nil, time.Now(), false
+}
 
 func TestIsTrustedParticipant(t *testing.T) {
 	type test struct {
@@ -126,7 +129,7 @@ func getNotFoundResponse() *http.Response {
 	return &http.Response{StatusCode: 404}
 }
 func getUnparsableResponse() *http.Response {
-	issuer := io.NopCloser(strings.NewReader(fmt.Sprintf("did-i-dachs")))
+	issuer := io.NopCloser(strings.NewReader("did-i-dachs"))
 	response := http.Response{
 		StatusCode: 200,
 		Body:       issuer,

verifier/verifier.go

@@ -78,10 +78,18 @@ var ErrorInvalidNonce = errors.New("invalid_nonce")
 
 // Actual implementation of the verfifier functionality
 
+// Verifier QR Information
+type QRLoginInfo struct {
+	QR                    string
+	ExpireAt              time.Time
+	TotalDuration         int
+	AuthenticationRequest string
+}
+
 // verifier interface
 type Verifier interface {
 	ReturnLoginQR(host string, protocol string, callback string, sessionId string, clientId string, nonce string, requestMode string) (qr string, err error)
-	ReturnLoginQRV2(host string, protocol string, callback string, sessionId string, clientId string, scope string, nonce string, requestMode string) (qr string, err error)
+	ReturnLoginQRV2(host string, protocol string, callback string, sessionId string, clientId string, scope string, nonce string, requestMode string) (qrLoginInfo QRLoginInfo, err error)
 	StartSiopFlow(host string, protocol string, callback string, state string, clientId string, nonce string, requestMode string) (connectionString string, err error)
 	StartSameDeviceFlow(host string, protocol string, sessionId string, redirectPath string, clientId string, nonce string, requestMode string, scope string, requestProtocol string) (authenticationRequest string, err error)
 	GetToken(authorizationCode string, redirectUri string, validated bool) (jwtString string, expiration int64, err error)
@@ -136,6 +144,8 @@ type CredentialVerifier struct {
 	verifierConfig configModel.Verifier
 	// JWT token expiration time in minutes
 	jwtExpiration time.Duration
+	// Session duration in seconds
+	sessionDuration time.Duration
 }
 
 // allow singleton access to the verifier
@@ -358,6 +368,7 @@ func InitVerifier(config *configModel.Configuration) (err error) {
 		verifierConfig.ClientIdentification,
 		*verifierConfig,
 		time.Duration(verifierConfig.JwtExpiration) * time.Minute,
+		time.Duration(verifierConfig.SessionExpiry),
 	}
 
 	logging.Log().Debug("Successfully initalized the verifier")
@@ -395,29 +406,36 @@ func (v *CredentialVerifier) ReturnLoginQR(host string, protocol string, callbac
 /**
 *   Initializes the cross-device login flow and returns all neccessary information as a qr-code
 **/
-func (v *CredentialVerifier) ReturnLoginQRV2(host string, protocol string, redircetUri string, sessionId string, clientId string, scope string, nonce string, requestMode string) (qr string, err error) {
+func (v *CredentialVerifier) ReturnLoginQRV2(host string, protocol string, redircetUri string, sessionId string, clientId string, scope string, nonce string, requestMode string) (qrInfo QRLoginInfo, err error) {
 
 	for _, v := range v.supportedRequestModes {
 		logging.Log().Warnf("Supported: %s", v)
 	}
 
 	if !slices.Contains(v.supportedRequestModes, requestMode) {
 		logging.Log().Infof("QR with mode %s was requested, but only %v is supported.", requestMode, v.supportedRequestModes)
-		return qr, ErrorUnsupportedRequestMode
+		return qrInfo, ErrorUnsupportedRequestMode
 	}
 
 	logging.Log().Debugf("Generate a login qr for %s.", redircetUri)
 	authenticationRequest, err := v.initOid4VPCrossDevice(host, protocol, redircetUri, sessionId, clientId, scope, nonce, requestMode)
 
 	if err != nil {
-		return qr, err
+		return qrInfo, err
 	}
 
 	png, err := qrcode.Encode(authenticationRequest, qrcode.Medium, 256)
 	base64Img := base64.StdEncoding.EncodeToString(png)
 	base64Img = "data:image/png;base64," + base64Img
 
-	return base64Img, err
+	_, expireAt, _ := v.sessionCache.GetWithExpiration(sessionId)
+	qrInfo = QRLoginInfo{
+		QR:                    base64Img,
+		ExpireAt:              expireAt,
+		TotalDuration:         int(v.sessionDuration),
+		AuthenticationRequest: authenticationRequest,
+	}
+	return qrInfo, err
 }
 
 /**

verifier/verifier_test.go

@@ -249,6 +249,11 @@ func (msc *mockSessionCache) Delete(k string) {
 	delete(msc.sessions, k)
 }
 
+func (msc *mockSessionCache) GetWithExpiration(k string) (interface{}, time.Time, bool) {
+	v, found := msc.sessions[k]
+	return v, <-time.After(5 * time.Second), found
+}
+
 func (mtc *mockTokenCache) Add(k string, x interface{}, d time.Duration) error {
 	if mtc.errorToThrow != nil {
 		return mtc.errorToThrow
@@ -270,6 +275,11 @@ func (mtc *mockTokenCache) Delete(k string) {
 	delete(mtc.tokens, k)
 }
 
+func (mtc *mockTokenCache) GetWithExpiration(k string) (interface{}, time.Time, bool) {
+	v, found := mtc.tokens[k]
+	return v, <-time.After(5 * time.Second), found
+}
+
 type siopInitTest struct {
 	testName             string
 	testHost             string