Fix verification bug with JWT credentials

credential/exchange/verification.go

@@ -2,6 +2,7 @@ package exchange
 
 import (
 	"fmt"
+	credutil "github.com/TBD54566975/ssi-sdk/credential/util"
 	"strings"
 
 	"github.com/TBD54566975/ssi-sdk/crypto"
@@ -115,13 +116,19 @@ func VerifyPresentationSubmissionVP(def PresentationDefinition, vp credential.Ve
 		}
 
 		// resolve the claim from the JSON path expression in the submission descriptor
-		submittedClaim, err := jsonpath.JsonPathLookup(vpJSON, submissionDescriptor.Path)
+		claim, err := jsonpath.JsonPathLookup(vpJSON, submissionDescriptor.Path)
 		if err != nil {
 			err := errors.Wrapf(err, "could not resolve claim from submission descriptor<%s> with path: %s",
 				submissionDescriptor.ID, submissionDescriptor.Path)
 			logrus.WithError(err).Error()
 			return err
 		}
+		submittedClaim, err := credutil.ClaimAsJSON(claim)
+		if err != nil {
+			err := errors.Wrapf(err, "getting claim as go-json: <%s>", claim)
+			logrus.WithError(err).Error()
+			return err
+		}
 
 		// verify the submitted claim complies with the input descriptor
 

credential/exchange/verification_test.go

@@ -249,4 +249,48 @@ func TestVerifyPresentationSubmissionVP(t *testing.T) {
 		assert.Error(tt, err)
 		assert.Contains(tt, err.Error(), "matching path for claim could not be found")
 	})
+
+	t.Run("Verification with JWT credential", func(t *testing.T) {
+		def := PresentationDefinition{
+			ID: "test-id",
+			InputDescriptors: []InputDescriptor{
+				{
+					ID: "id-1",
+					Constraints: &Constraints{
+						Fields: []Field{
+							{
+								Path:    []string{"$.vc.credentialSubject.company", "$.credentialSubject.company"},
+								ID:      "works-for-block",
+								Purpose: "need to check the company of the subject",
+							},
+						},
+					},
+				},
+			},
+		}
+		signer, _ := getJWKSignerVerifier(t)
+		testVC := getTestVerifiableCredential()
+		vcData, err := signing.SignVerifiableCredentialJWT(*signer, testVC)
+		assert.NoError(t, err)
+		b := NewPresentationSubmissionBuilder(def.ID)
+		assert.NoError(t, b.SetDescriptorMap([]SubmissionDescriptor{
+			{
+				ID:         "id-1",
+				Format:     string(JWTVPTarget),
+				Path:       "$.verifiableCredential[0]",
+				PathNested: nil,
+			},
+		}))
+		ps, err := b.Build()
+		assert.NoError(t, err)
+
+		vpBuilder := credential.NewVerifiablePresentationBuilder()
+		assert.NoError(t, vpBuilder.SetPresentationSubmission(ps))
+		assert.NoError(t, vpBuilder.AddVerifiableCredentials([]interface{}{string(vcData)}...))
+		vp2, err := vpBuilder.Build()
+		assert.NoError(t, err)
+		vp := *vp2
+
+		assert.NoError(t, VerifyPresentationSubmissionVP(def, vp))
+	})
 }

credential/util/util.go

@@ -39,3 +39,27 @@ func CredentialsFromInterface(genericCred interface{}) (*credential.VerifiableCr
 		return nil, fmt.Errorf("invalid credential type: %s", reflect.TypeOf(genericCred).Kind().String())
 	}
 }
+
+// ClaimAsJSON converts a claim with an unknown interface{} into the go-json representation of that credential.
+// claim can only be of type {string, map[string]interface, VerifiableCredential}.
+func ClaimAsJSON(claim interface{}) (map[string]interface{}, error) {
+	switch c := claim.(type) {
+	case map[string]interface{}:
+		return c, nil
+	default:
+	}
+
+	vc, err := CredentialsFromInterface(claim)
+	if err != nil {
+		return nil, errors.Wrap(err, "credential from interface")
+	}
+	vcData, err := json.Marshal(vc)
+	if err != nil {
+		return nil, errors.Wrap(err, "marshalling credential")
+	}
+	var submittedClaim map[string]interface{}
+	if err := json.Unmarshal(vcData, &submittedClaim); err != nil {
+		return nil, errors.Wrap(err, "unmarshalling credential")
+	}
+	return submittedClaim, nil
+}