17825157645

Committed 18 Sep 2025 10:02AM UTC coverage: 44.884% (+0.7%) from 44.17%

Build # 17825157645

Build Type

Pull #67

github

Committed by

wistefan

Commit Message

support deep link responses

Pull Request Pull Request #67: Token exchange

Run Details

98 of 129 new or added lines in 3 files covered. (75.97%)

349 existing lines in 7 files now uncovered.

1531 of 3411 relevant lines covered (44.88%)

0.51 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

21.88

/verifier/presentation_parser.go

package verifier

import (
        "context"
        "errors"
        "net/http"
        "strings"
        "time"

        configModel "github.com/fiware/VCVerifier/config"
        "github.com/fiware/VCVerifier/jades"
        "github.com/fiware/VCVerifier/logging"
        "github.com/hellofresh/health-go/v5"
        "github.com/piprate/json-gold/ld"
        "github.com/trustbloc/vc-go/proof/defaults"
        sdv "github.com/trustbloc/vc-go/sdjwt/verifier"
        "github.com/trustbloc/vc-go/verifiable"
)

var ErrorNoValidationEndpoint = errors.New("no_validation_endpoint_configured")
var ErrorNoValidationHost = errors.New("no_validation_host_configured")

var defaultPresentationOptions = []verifiable.PresentationOpt{
        verifiable.WithPresProofChecker(defaults.NewDefaultProofChecker(JWTVerfificationMethodResolver{})),
        verifiable.WithPresJSONLDDocumentLoader(NewCachingDocumentLoader(ld.NewDefaultDocumentLoader(http.DefaultClient)))}

var defaultSdJwtParserOptions = []sdv.ParseOpt{
        sdv.WithSignatureVerifier(defaults.NewDefaultProofChecker(JWTVerfificationMethodResolver{})),
        sdv.WithHolderVerificationRequired(false),
        sdv.WithHolderSigningAlgorithms([]string{"ES256", "PS256"}),
        sdv.WithIssuerSigningAlgorithms([]string{"ES256", "PS256"}),
}

// allow singleton access to the parser
var presentationParser PresentationParser

// allow singleton access to the parser
var sdJwtParser SdJwtParser

// parser interface
type PresentationParser interface {
        ParsePresentation(tokenBytes []byte) (*verifiable.Presentation, error)
}

type SdJwtParser interface {
        Parse(tokenString string) (map[string]interface{}, error)
}

type ConfigurablePresentationParser struct {
        PresentationOpts []verifiable.PresentationOpt
}

type ConfigurableSdJwtParser struct {
        ParserOpts []sdv.ParseOpt
}

/**
* Global singelton access to the parser
**/
func GetSdJwtParser() SdJwtParser {
        if sdJwtParser == nil {
                logging.Log().Error("SdJwtParser is not initialized.")
        }
        return sdJwtParser
}

/**
* Global singelton access to the parser
**/
func GetPresentationParser() PresentationParser {
        if presentationParser == nil {
                logging.Log().Error("PresentationParser is not initialized.")
        }
        return presentationParser
}

// init the presentation parser depending on the config, either with or without did:elsi support
func InitPresentationParser(config *configModel.Configuration, healthCheck *health.Health) error {
        elsiConfig := &config.Elsi
        err := validateConfig(elsiConfig)
        if err != nil {
                logging.Log().Warnf("No valid elsi configuration provided. Error: %v", err)
                return err
        }
        if elsiConfig.Enabled {
                jAdESValidator := &jades.ExternalJAdESValidator{
                        HttpClient:        &http.Client{},
                        ValidationAddress: buildAddress(elsiConfig.ValidationEndpoint.Host, elsiConfig.ValidationEndpoint.ValidationPath),
                        HealthAddress:     buildAddress(elsiConfig.ValidationEndpoint.Host, elsiConfig.ValidationEndpoint.HealthPath)}

                elsiProofChecker := &ElsiProofChecker{
                        defaultChecker: defaults.NewDefaultProofChecker(JWTVerfificationMethodResolver{}),
                        jAdESValidator: jAdESValidator,
                }

                healthCheck.Register(health.Config{
                        Name:      "JAdES-Validator",
                        Timeout:   time.Second * 5,
                        SkipOnErr: false,
                        Check: func(ctx context.Context) error {
                                return jAdESValidator.IsReady()
                        },
                })

                presentationParser = &ConfigurablePresentationParser{PresentationOpts: []verifiable.PresentationOpt{
                        verifiable.WithPresProofChecker(elsiProofChecker),
                        verifiable.WithPresJSONLDDocumentLoader(NewCachingDocumentLoader(ld.NewDefaultDocumentLoader(http.DefaultClient)))}}
        } else {
                presentationParser = &ConfigurablePresentationParser{PresentationOpts: defaultPresentationOptions}
        }
        sdJwtParser = &ConfigurableSdJwtParser{ParserOpts: defaultSdJwtParserOptions}

        return nil
}

func validateConfig(elsiConfig *configModel.Elsi) error {
        if !elsiConfig.Enabled {
                return nil
        }
        if elsiConfig.ValidationEndpoint == nil {
                return ErrorNoValidationEndpoint
        }
        if elsiConfig.ValidationEndpoint.Host == "" {
                return ErrorNoValidationHost
        }
        return nil
}

func buildAddress(host, path string) string {
        return strings.TrimSuffix(host, "/") + "/" + strings.TrimPrefix(path, "/")
}

func (cpp *ConfigurablePresentationParser) ParsePresentation(tokenBytes []byte) (*verifiable.Presentation, error) {
        return verifiable.ParsePresentation(tokenBytes, cpp.PresentationOpts...)
}

func (sjp *ConfigurableSdJwtParser) Parse(tokenString string) (map[string]interface{}, error) {
        return sdv.Parse(tokenString, sjp.ParserOpts...)
}

1	package verifier
2
3	import (
4	"context"
5	"errors"
6	"net/http"
7	"strings"
8	"time"
9
10	configModel "github.com/fiware/VCVerifier/config"
11	"github.com/fiware/VCVerifier/jades"
12	"github.com/fiware/VCVerifier/logging"
13	"github.com/hellofresh/health-go/v5"
14	"github.com/piprate/json-gold/ld"
15	"github.com/trustbloc/vc-go/proof/defaults"
16	sdv "github.com/trustbloc/vc-go/sdjwt/verifier"
17	"github.com/trustbloc/vc-go/verifiable"
18	)
19
20	var ErrorNoValidationEndpoint = errors.New("no_validation_endpoint_configured")
21	var ErrorNoValidationHost = errors.New("no_validation_host_configured")
22
23	var defaultPresentationOptions = []verifiable.PresentationOpt{
24	verifiable.WithPresProofChecker(defaults.NewDefaultProofChecker(JWTVerfificationMethodResolver{})),
25	verifiable.WithPresJSONLDDocumentLoader(NewCachingDocumentLoader(ld.NewDefaultDocumentLoader(http.DefaultClient)))}
26
27	var defaultSdJwtParserOptions = []sdv.ParseOpt{
28	sdv.WithSignatureVerifier(defaults.NewDefaultProofChecker(JWTVerfificationMethodResolver{})),
29	sdv.WithHolderVerificationRequired(false),
30	sdv.WithHolderSigningAlgorithms([]string{"ES256", "PS256"}),
31	sdv.WithIssuerSigningAlgorithms([]string{"ES256", "PS256"}),
32	}
33
34	// allow singleton access to the parser
35	var presentationParser PresentationParser
36
37	// allow singleton access to the parser
38	var sdJwtParser SdJwtParser
39
40	// parser interface
41	type PresentationParser interface {
42	ParsePresentation(tokenBytes []byte) (*verifiable.Presentation, error)
43	}
44
45	type SdJwtParser interface {
46	Parse(tokenString string) (map[string]interface{}, error)
47	}
48
49	type ConfigurablePresentationParser struct {
50	PresentationOpts []verifiable.PresentationOpt
51	}
52
53	type ConfigurableSdJwtParser struct {
54	ParserOpts []sdv.ParseOpt
55	}
56
57	/**
58	* Global singelton access to the parser
59	**/
UNCOV 60	func GetSdJwtParser() SdJwtParser {	×
UNCOV 61	if sdJwtParser == nil {	×
UNCOV 62	logging.Log().Error("SdJwtParser is not initialized.")	×
UNCOV 63	}	×
UNCOV 64	return sdJwtParser	×
65	}
66
67	/**
68	* Global singelton access to the parser
69	**/
70	func GetPresentationParser() PresentationParser {	×
71	if presentationParser == nil {	×
72	logging.Log().Error("PresentationParser is not initialized.")	×
UNCOV 73	}	×
UNCOV 74	return presentationParser	×
75	}
76
77	// init the presentation parser depending on the config, either with or without did:elsi support
78	func InitPresentationParser(config configModel.Configuration, healthCheck health.Health) error {	×
79	elsiConfig := &config.Elsi	×
80	err := validateConfig(elsiConfig)	×
81	if err != nil {	×
82	logging.Log().Warnf("No valid elsi configuration provided. Error: %v", err)	×
UNCOV 83	return err	×
UNCOV 84	}	×
UNCOV 85	if elsiConfig.Enabled {	×
86	jAdESValidator := &jades.ExternalJAdESValidator{	×
87	HttpClient: &http.Client{},	×
88	ValidationAddress: buildAddress(elsiConfig.ValidationEndpoint.Host, elsiConfig.ValidationEndpoint.ValidationPath),	×
89	HealthAddress: buildAddress(elsiConfig.ValidationEndpoint.Host, elsiConfig.ValidationEndpoint.HealthPath)}	×
90		×
91	elsiProofChecker := &ElsiProofChecker{	×
92	defaultChecker: defaults.NewDefaultProofChecker(JWTVerfificationMethodResolver{}),	×
93	jAdESValidator: jAdESValidator,	×
94	}	×
95		×
96	healthCheck.Register(health.Config{	×
97	Name: "JAdES-Validator",	×
98	Timeout: time.Second * 5,	×
99	SkipOnErr: false,	×
100	Check: func(ctx context.Context) error {	×
101	return jAdESValidator.IsReady()	×
102	},	×
103	})
104
105	presentationParser = &ConfigurablePresentationParser{PresentationOpts: []verifiable.PresentationOpt{	×
106	verifiable.WithPresProofChecker(elsiProofChecker),	×
107	verifiable.WithPresJSONLDDocumentLoader(NewCachingDocumentLoader(ld.NewDefaultDocumentLoader(http.DefaultClient)))}}	×
108	} else {	×
109	presentationParser = &ConfigurablePresentationParser{PresentationOpts: defaultPresentationOptions}	×
110	}	×
UNCOV 111	sdJwtParser = &ConfigurableSdJwtParser{ParserOpts: defaultSdJwtParserOptions}	×
UNCOV 112		×
113	return nil	×
114	}
115
116	func validateConfig(elsiConfig *configModel.Elsi) error {	1✔
117	if !elsiConfig.Enabled {	2✔
118	return nil	1✔
119	}	1✔
120	if elsiConfig.ValidationEndpoint == nil {	2✔
121	return ErrorNoValidationEndpoint	1✔
122	}	1✔
123	if elsiConfig.ValidationEndpoint.Host == "" {	2✔
124	return ErrorNoValidationHost	1✔
125	}	1✔
126	return nil	1✔
127	}
128
129	func buildAddress(host, path string) string {	1✔
130	return strings.TrimSuffix(host, "/") + "/" + strings.TrimPrefix(path, "/")	1✔
131	}	1✔
132
UNCOV 133	func (cpp ConfigurablePresentationParser) ParsePresentation(tokenBytes []byte) (verifiable.Presentation, error) {	×
UNCOV 134	return verifiable.ParsePresentation(tokenBytes, cpp.PresentationOpts...)	×
UNCOV 135	}	×
136
UNCOV 137	func (sjp *ConfigurableSdJwtParser) Parse(tokenString string) (map[string]interface{}, error) {	×
UNCOV 138	return sdv.Parse(tokenString, sjp.ParserOpts...)	×
UNCOV 139	}	×

FIWARE / VCVerifier / 17825157645

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous