verify.go 9.55 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package irma

import (
	"fmt"
	"github.com/go-errors/errors"
	"github.com/mhe/gabi"
	"math/big"
	"time"
)

// ProofStatus is the status of the complete proof
type ProofStatus string

const (
	VALID              = ProofStatus("VALID")
	EXPIRED            = ProofStatus("EXPIRED")
	INVALID_CRYPTO     = ProofStatus("INVALID_CRYPTO")
	INVALID_SYNTAX     = ProofStatus("INVALID_SYNTAX")
	MISSING_ATTRIBUTES = ProofStatus("MISSING_ATTRIBUTES")
)

// ProofResult is a result of a complete proof, containing all the disclosed attributes and corresponding request
type ProofResult struct {
	disjunctions []*DisclosedAttributeDisjunction
	ProofStatus  ProofStatus
}

type SignatureProofResult struct {
29
	*ProofResult
30
31
32
33
34
35
36
37
38
	message string
}

// DisclosedCredential contains raw disclosed credentials, without any extra parsing information
type DisclosedCredential struct {
	metadataAttribute *MetadataAttribute
	Attributes        map[AttributeTypeIdentifier]*big.Int
}

39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
type DisclosedCredentialList []*DisclosedCredential

// Helper function to check if an attribute is satisfied against a list of disclosed attributes
// This is the case if:
// attribute is contained in disclosed AND if a value is present: equal to that value
// al can be nil if you don't want to include attribute status for proof
func (disclosed DisclosedCredentialList) isAttributeSatisfied(attributeId AttributeTypeIdentifier, requestedValue string) (bool, *AttributeResult) {
	ar := AttributeResult{
		AttributeId: attributeId,
	}

	for _, cred := range disclosed {
		disclosedAttributeValue := cred.GetAttributeValue(attributeId)

		// Continue to next credential if requested attribute isn't disclosed in this credential
		if disclosedAttributeValue == "" {
			continue
		}

		// If this is the disclosed attribute, check if value matches
		// Attribute is satisfied if:
		// - Attribute is disclosed (i.e. not nil)
		// - Value is empty OR value equal to disclosedValue
		ar.AttributeValue = disclosedAttributeValue

		if requestedValue == "" || disclosedAttributeValue == requestedValue {
			ar.AttributeProofStatus = PRESENT
			return true, &ar
		} else {
			// If attribute is disclosed and present, but not equal to required value, mark it as invalid_value
			// We won't return true and continue searching in other disclosed attributes
			ar.AttributeProofStatus = INVALID_VALUE
		}
	}

	// If there is never a value assigned, then this attribute isn't disclosed, and thus missing
	if ar.AttributeValue == "" {
		ar.AttributeProofStatus = MISSING
	}
	return false, &ar
}

// Create a signature proof result and check disclosed credentials against a signature request
func (disclosed DisclosedCredentialList) createAndCheckSignatureProofResult(configuration *Configuration, sigRequest *SignatureRequest) *SignatureProofResult {
	signatureProofResult := SignatureProofResult{
		ProofResult: &ProofResult{},
		message:     sigRequest.Message,
	}
	for _, content := range sigRequest.Content {
		isSatisfied, disjunction := content.SatisfyDisclosed(disclosed, configuration)
		signatureProofResult.disjunctions = append(signatureProofResult.disjunctions, disjunction)

		// If satisfied, continue to next one
		if isSatisfied {
			continue
		}

		// Else, set proof status to missing_attributes, but check other as well to add other disjunctions to result
		// (so user also knows attribute status of other disjunctions)
		signatureProofResult.ProofStatus = MISSING_ATTRIBUTES
	}

	signatureProofResult.disjunctions = addExtraAttributes(disclosed, signatureProofResult.ProofResult)
	return &signatureProofResult
}

// Returns true if one of the disclosed credentials is expired
func (disclosed DisclosedCredentialList) IsExpired() bool {
	for _, cred := range disclosed {
		if cred.IsExpired() {
			return true
		}
	}
	return false
}

115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
func (proofResult *ProofResult) ToAttributeResultList() *AttributeResultList {
	var resultList AttributeResultList

	for _, v := range proofResult.disjunctions {
		result := AttributeResult{
			AttributeValue:       v.DisclosedValue,
			AttributeId:          v.DisclosedId,
			AttributeProofStatus: v.ProofStatus,
		}

		resultList.Append(&result)
	}
	return &resultList
}

// Returns true if this attrId is present in one of the disjunctions
func (proofResult *ProofResult) ContainsAttribute(attrId AttributeTypeIdentifier) bool {
	for _, disj := range proofResult.disjunctions {
		for _, attr := range disj.Attributes {
			if attr == attrId {
				return true
			}
		}
	}

	return false
}

// Get string value of disclosed attribute, or nil if request attribute isn't disclosed in this credential
func (cred *DisclosedCredential) GetAttributeValue(id AttributeTypeIdentifier) string {
	attr := cred.Attributes[id]
	if attr != nil {
		return string(attr.Bytes())
	}

	return ""
}

func (cred *DisclosedCredential) IsExpired() bool {
	return cred.metadataAttribute.Expiry().Before(time.Now())
}

func NewDisclosedCredentialFromADisclosed(aDisclosed map[int]*big.Int, configuration *Configuration) *DisclosedCredential {
	attributes := make(map[AttributeTypeIdentifier]*big.Int)

	metadata := MetadataFromInt(aDisclosed[1], configuration) // index 1 is metadata attribute
	cred := metadata.CredentialType()

	for k, v := range aDisclosed {
		if k < 2 {
			continue
		}

		description := cred.Attributes[k-2]
		attributes[description.GetAttributeTypeIdentifier(cred.Identifier())] = v
	}

	return &DisclosedCredential{
		metadataAttribute: metadata,
		Attributes:        attributes,
	}
}

178
179
func extractPublicKeys(configuration *Configuration, proofList gabi.ProofList) ([]*gabi.PublicKey, error) {
	var publicKeys = make([]*gabi.PublicKey, 0, len(proofList))
180

181
	for _, v := range proofList {
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
		switch v.(type) {
		case *gabi.ProofD:
			proof := v.(*gabi.ProofD)
			metadata := MetadataFromInt(proof.ADisclosed[1], configuration) // index 1 is metadata attribute
			publicKey, err := metadata.PublicKey()
			if err != nil {
				return nil, err
			}
			publicKeys = append(publicKeys, publicKey)
		default:
			return nil, errors.New("Cannot extract public key, not a disclosure proofD!")
		}
	}
	return publicKeys, nil
}

198
199
func extractDisclosedCredentials(conf *Configuration, proofList gabi.ProofList) (DisclosedCredentialList, error) {
	var credentials = make(DisclosedCredentialList, 0, len(proofList))
200

201
	for _, v := range proofList {
202
203
204
205
206
207
208
209
210
211
212
213
214
215
		switch v.(type) {
		case *gabi.ProofD:
			proof := v.(*gabi.ProofD)
			cred := NewDisclosedCredentialFromADisclosed(proof.ADisclosed, conf)
			credentials = append(credentials, cred)
		default:
			return nil, errors.New("Cannot extract credentials from proof, not a disclosure proofD!")
		}
	}

	return credentials, nil
}

// Add extra disclosed attributes to an existing and checked ProofResult in 'dummy disjunctions'
216
217
218
func addExtraAttributes(disclosed DisclosedCredentialList, proofResult *ProofResult) []*DisclosedAttributeDisjunction {
	returnDisjunctions := make([]*DisclosedAttributeDisjunction, len(proofResult.disjunctions))
	copy(returnDisjunctions, proofResult.disjunctions)
219

220
	for _, cred := range disclosed {
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
		for attrId := range cred.Attributes {
			if proofResult.ContainsAttribute(attrId) {
				continue
			}

			dummyDisj := DisclosedAttributeDisjunction{
				DisclosedValue: cred.GetAttributeValue(attrId),
				DisclosedId:    attrId,
				ProofStatus:    EXTRA,
			}
			returnDisjunctions = append(returnDisjunctions, &dummyDisj)
		}
	}

	return returnDisjunctions
}

// Check an gabi prooflist against a signature proofrequest
239
240
func checkProofWithRequest(configuration *Configuration, proofList gabi.ProofList, sigRequest *SignatureRequest) *SignatureProofResult {
	disclosed, err := extractDisclosedCredentials(configuration, proofList)
241
242
243
244

	if err != nil {
		fmt.Println(err)
		return &SignatureProofResult{
245
			ProofResult: &ProofResult{
246
247
248
249
250
				ProofStatus: INVALID_CRYPTO,
			},
		}
	}

251
	signatureProofResult := disclosed.createAndCheckSignatureProofResult(configuration, sigRequest)
252
253
254
255
256
257
258
259

	// Return MISSING_ATTRIBUTES as proofstatus if one attribute is missing
	// This status takes priority over 'EXPIRED'
	if signatureProofResult.ProofStatus == MISSING_ATTRIBUTES {
		return signatureProofResult
	}

	// If all disjunctions are satisfied, check if a credential is expired
260
261
262
	if disclosed.IsExpired() {
		signatureProofResult.ProofStatus = EXPIRED
		return signatureProofResult
263
264
265
266
267
268
269
270
	}

	// All disjunctions satisfied and nothing expired, proof is valid!
	signatureProofResult.ProofStatus = VALID
	return signatureProofResult
}

// Verify an IRMA proof cryptographically
271
func verify(configuration *Configuration, proofList gabi.ProofList, context *big.Int, nonce *big.Int, isSig bool) bool {
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
	// Extract public keys
	pks, err := extractPublicKeys(configuration, proofList)
	if err != nil {
		return false
	}

	return proofList.Verify(pks, context, nonce, true, isSig)
}

// Verify a signature proof and check if the attributes match the attributes in the original request
func VerifySig(configuration *Configuration, proofString string, sigRequest *SignatureRequest) *SignatureProofResult {

	// First, unmarshal proof and check if all the attributes in the proofstring match the signature request
	var proofList gabi.ProofList
	proofBytes := []byte(proofString)

	err := proofList.UnmarshalJSON(proofBytes)
	if err != nil {
		return &SignatureProofResult{
291
			ProofResult: &ProofResult{
292
293
294
295
296
297
				ProofStatus: INVALID_SYNTAX,
			},
		}
	}

	// Now, cryptographically verify the signature
298
	if !verify(configuration, proofList, sigRequest.GetContext(), sigRequest.GetNonce(), true) {
299
		return &SignatureProofResult{
300
			ProofResult: &ProofResult{
301
302
303
304
305
306
				ProofStatus: INVALID_CRYPTO,
			},
		}
	}

	// Finally, check whether attribute values in proof satisfy the original signature request
307
	return checkProofWithRequest(configuration, proofList, sigRequest)
308
}