irmaconfig.go 48.3 KB
Newer Older
1
package irma
2
3

import (
4
	"crypto/rsa"
5
6
7
8
9
	"encoding/base64"
	"encoding/xml"
	"io/ioutil"
	"os"
	"path/filepath"
10
	"reflect"
11
	"regexp"
12
	"strconv"
13
	"time"
14

15
16
	"crypto/sha256"

17
18
19
20
	"fmt"

	"strings"

21
22
23
24
25
26
27
28
29
30
	"sort"

	"bytes"

	"encoding/hex"

	"crypto/ecdsa"
	"crypto/x509"
	"encoding/asn1"
	"encoding/pem"
31
	gobig "math/big"
32

33
	"github.com/dgrijalva/jwt-go"
34
	"github.com/go-errors/errors"
Sietse Ringers's avatar
Sietse Ringers committed
35
	"github.com/jasonlvhit/gocron"
36
37
	"github.com/privacybydesign/gabi"
	"github.com/privacybydesign/gabi/big"
38
	"github.com/privacybydesign/irmago/internal/fs"
39
40
)

41
// Configuration keeps track of scheme managers, issuers, credential types and public keys,
42
// dezerializing them from an irma_configuration folder, and downloads and saves new ones on demand.
43
type Configuration struct {
44
45
46
	SchemeManagers  map[SchemeManagerIdentifier]*SchemeManager
	Issuers         map[IssuerIdentifier]*Issuer
	CredentialTypes map[CredentialTypeIdentifier]*CredentialType
47
	AttributeTypes  map[AttributeTypeIdentifier]*AttributeType
48

Sietse Ringers's avatar
Sietse Ringers committed
49
50
51
	// Path to the irma_configuration folder that this instance represents
	Path string

52
53
54
	// DisabledSchemeManagers keeps track of scheme managers that did not parse  succesfully
	// (i.e., invalid signature, parsing error), and the problem that occurred when parsing them
	DisabledSchemeManagers map[SchemeManagerIdentifier]*SchemeManagerError
55

56
57
	Warnings []string

58
	kssPublicKeys map[SchemeManagerIdentifier]map[int]*rsa.PublicKey
59
	publicKeys    map[IssuerIdentifier]map[int]*gabi.PublicKey
60
	privateKeys   map[IssuerIdentifier]*gabi.PrivateKey
61
	reverseHashes map[string]CredentialTypeIdentifier
62
	initialized   bool
63
	assets        string
64
	readOnly      bool
Sietse Ringers's avatar
Sietse Ringers committed
65
	cronchan      chan bool
66
	scheduler     *gocron.Scheduler
67
68
}

Sietse Ringers's avatar
Sietse Ringers committed
69
70
// ConfigurationFileHash encodes the SHA256 hash of an authenticated
// file under a scheme manager within the configuration folder.
71
72
type ConfigurationFileHash []byte

Sietse Ringers's avatar
Sietse Ringers committed
73
74
// SchemeManagerIndex is a (signed) list of files under a scheme manager
// along with their SHA266 hash
75
76
type SchemeManagerIndex map[string]ConfigurationFileHash

77
78
type SchemeManagerStatus string

79
80
type SchemeManagerError struct {
	Manager SchemeManagerIdentifier
81
	Status  SchemeManagerStatus
82
83
84
	Err     error
}

85
86
87
88
89
type UnknownIdentifierError struct {
	ErrorType
	Missing *IrmaIdentifierSet
}

Leon's avatar
Leon committed
90
91
92
93
94
type RequiredAttributeMissingError struct {
	ErrorType
	Missing *IrmaIdentifierSet
}

95
96
97
98
99
100
101
const (
	SchemeManagerStatusValid               = SchemeManagerStatus("Valid")
	SchemeManagerStatusUnprocessed         = SchemeManagerStatus("Unprocessed")
	SchemeManagerStatusInvalidIndex        = SchemeManagerStatus("InvalidIndex")
	SchemeManagerStatusInvalidSignature    = SchemeManagerStatus("InvalidSignature")
	SchemeManagerStatusParsingError        = SchemeManagerStatus("ParsingError")
	SchemeManagerStatusContentParsingError = SchemeManagerStatus("ContentParsingError")
102

103
104
	pubkeyPattern  = "%s/%s/%s/PublicKeys/*.xml"
	privkeyPattern = "%s/%s/%s/PrivateKeys/*.xml"
105
106
)

107
108
109
110
func (sme SchemeManagerError) Error() string {
	return fmt.Sprintf("Error parsing scheme manager %s: %s", sme.Manager.Name(), sme.Err.Error())
}

111
// NewConfiguration returns a new configuration. After this
112
// ParseFolder() should be called to parse the specified path.
113
114
115
116
func NewConfiguration(path string) (*Configuration, error) {
	return newConfiguration(path, "")
}

117
118
// NewConfigurationReadOnly returns a new configuration whose representation on disk
// is never altered. ParseFolder() should be called to parse the specified path.
119
120
121
122
123
124
125
126
127
func NewConfigurationReadOnly(path string) (*Configuration, error) {
	conf, err := newConfiguration(path, "")
	if err != nil {
		return nil, err
	}
	conf.readOnly = true
	return conf, nil
}

128
129
// NewConfigurationFromAssets returns a new configuration, copying the schemes out of the assets folder to path.
// ParseFolder() should be called to parse the specified path.
130
131
132
133
134
func NewConfigurationFromAssets(path, assets string) (*Configuration, error) {
	return newConfiguration(path, assets)
}

func newConfiguration(path string, assets string) (conf *Configuration, err error) {
135
	conf = &Configuration{
Sietse Ringers's avatar
Sietse Ringers committed
136
		Path:   path,
137
		assets: assets,
138
	}
139

140
141
142
143
	if conf.assets != "" { // If an assets folder is specified, then it must exist
		if err = fs.AssertPathExists(conf.assets); err != nil {
			return nil, errors.WrapPrefix(err, "Nonexistent assets folder specified", 0)
		}
144
	}
145
	if err = fs.EnsureDirectoryExists(conf.Path); err != nil {
146
147
		return nil, err
	}
148

149
150
151
	// Init all maps
	conf.clear()

152
153
154
	return
}

155
func (conf *Configuration) clear() {
156
157
158
	conf.SchemeManagers = make(map[SchemeManagerIdentifier]*SchemeManager)
	conf.Issuers = make(map[IssuerIdentifier]*Issuer)
	conf.CredentialTypes = make(map[CredentialTypeIdentifier]*CredentialType)
159
	conf.AttributeTypes = make(map[AttributeTypeIdentifier]*AttributeType)
160
	conf.DisabledSchemeManagers = make(map[SchemeManagerIdentifier]*SchemeManagerError)
161
	conf.kssPublicKeys = make(map[SchemeManagerIdentifier]map[int]*rsa.PublicKey)
162
	conf.publicKeys = make(map[IssuerIdentifier]map[int]*gabi.PublicKey)
163
	conf.privateKeys = make(map[IssuerIdentifier]*gabi.PrivateKey)
164
	conf.reverseHashes = make(map[string]CredentialTypeIdentifier)
165
166
167
168
169
170
171
}

// ParseFolder populates the current Configuration by parsing the storage path,
// listing the containing scheme managers, issuers and credential types.
func (conf *Configuration) ParseFolder() (err error) {
	// Init all maps
	conf.clear()
172

173
174
	// Copy any new or updated scheme managers out of the assets into storage
	if conf.assets != "" {
175
		err = iterateSubfolders(conf.assets, func(dir string, _ os.FileInfo) error {
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
			scheme := NewSchemeManagerIdentifier(filepath.Base(dir))
			uptodate, err := conf.isUpToDate(scheme)
			if err != nil {
				return err
			}
			if !uptodate {
				_, err = conf.CopyManagerFromAssets(scheme)
			}
			return err
		})
		if err != nil {
			return err
		}
	}

	// Parse scheme managers in storage
192
	var mgrerr *SchemeManagerError
193
	err = iterateSubfolders(conf.Path, func(dir string, _ os.FileInfo) error {
194
195
		manager := NewSchemeManager(filepath.Base(dir))
		err := conf.ParseSchemeManagerFolder(dir, manager)
196
197
		if err == nil {
			return nil // OK, do next scheme manager folder
198
		}
199
200
201
202
		// If there is an error, and it is of type SchemeManagerError, return nil
		// so as to continue parsing other managers.
		var ok bool
		if mgrerr, ok = err.(*SchemeManagerError); ok {
203
			conf.DisabledSchemeManagers[manager.Identifier()] = mgrerr
204
			return nil
205
		}
206
		return err // Not a SchemeManagerError? return it & halt parsing now
207
208
	})
	if err != nil {
209
		return
210
	}
211
	conf.initialized = true
212
213
214
	if mgrerr != nil {
		return mgrerr
	}
215
	return
216
217
}

218
219
220
221
222
223
224
// ParseOrRestoreFolder parses the irma_configuration folder, and when possible attempts to restore
// any broken scheme managers from their remote.
// Any error encountered during parsing is considered recoverable only if it is of type *SchemeManagerError;
// In this case the scheme in which it occured is downloaded from its remote and re-parsed.
// If any other error is encountered at any time, it is returned immediately.
// If no error is returned, parsing and possibly restoring has been succesfull, and there should be no
// disabled scheme managers.
225
226
func (conf *Configuration) ParseOrRestoreFolder() error {
	err := conf.ParseFolder()
227
228
229
	// Only in case of a *SchemeManagerError might we be able to recover
	if _, isSchemeMgrErr := err.(*SchemeManagerError); !isSchemeMgrErr {
		return err
230
	}
231
232
233
	if err != nil && (conf.assets == "" || conf.readOnly) {
		return err
	}
234
235

	for id := range conf.DisabledSchemeManagers {
236
237
238
239
240
241
242
243
244
		if err = conf.ReinstallSchemeManager(conf.SchemeManagers[id]); err == nil {
			continue
		}
		if _, err = conf.CopyManagerFromAssets(id); err != nil {
			return err // File system error, too serious, bail out now
		}
		name := id.String()
		if err = conf.ParseSchemeManagerFolder(filepath.Join(conf.Path, name), NewSchemeManager(name)); err == nil {
			delete(conf.DisabledSchemeManagers, id)
245
		}
246
	}
247

248
249
250
	return err
}

251
// ParseSchemeManagerFolder parses the entire tree of the specified scheme manager
252
// If err != nil then a problem occured
253
func (conf *Configuration) ParseSchemeManagerFolder(dir string, manager *SchemeManager) (err error) {
254
255
256
257
258
259
260
	// From this point, keep it in our map even if it has an error. The user must check either:
	// - manager.Status == SchemeManagerStatusValid, aka "VALID"
	// - or equivalently, manager.Valid == true
	// before using any scheme manager for anything, and handle accordingly
	conf.SchemeManagers[manager.Identifier()] = manager

	// Ensure we return a SchemeManagerError when any error occurs
261
262
	defer func() {
		if err != nil {
263
264
265
266
267
			err = &SchemeManagerError{
				Manager: manager.Identifier(),
				Err:     err,
				Status:  manager.Status,
			}
268
269
270
		}
	}()

271
272
	// Verify signature and read scheme manager description
	if err = conf.VerifySignature(manager.Identifier()); err != nil {
273
274
		return
	}
275
	if manager.index, err = conf.parseIndex(filepath.Base(dir), manager); err != nil {
276
277
		manager.Status = SchemeManagerStatusInvalidIndex
		return
278
	}
279
	exists, err := conf.pathToDescription(manager, dir+"/description.xml", manager)
280
281
282
	if err != nil {
		manager.Status = SchemeManagerStatusParsingError
		return
283
	}
284
285
286
287
	if !exists {
		manager.Status = SchemeManagerStatusParsingError
		return errors.New("Scheme manager description not found")
	}
288
	if err = conf.validateScheme(manager, dir); err != nil {
289
		return
290
	}
291
292
293
294
295
296
297

	// Verify that all other files are validly signed
	err = conf.VerifySchemeManager(manager)
	if err != nil {
		manager.Status = SchemeManagerStatusInvalidSignature
		return
	}
298

299
	// Read timestamp indicating time of last modification
300
301
302
	ts, exists, err := readTimestamp(dir + "/timestamp")
	if err != nil || !exists {
		return errors.WrapPrefix(err, "Could not read scheme manager timestamp", 0)
303
	}
304
	manager.Timestamp = *ts
305

306
	// Parse contained issuers and credential types
307
	err = conf.parseIssuerFolders(manager, dir)
308
309
310
311
312
313
	if err != nil {
		manager.Status = SchemeManagerStatusContentParsingError
		return
	}
	manager.Status = SchemeManagerStatusValid
	manager.Valid = true
314
315
316
	return
}

317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
// PrivateKey returns the specified private key, or nil if not present in the Configuration.
func (conf *Configuration) PrivateKey(id IssuerIdentifier) (*gabi.PrivateKey, error) {
	if sk := conf.privateKeys[id]; sk != nil {
		return sk, nil
	}

	path := fmt.Sprintf(privkeyPattern, conf.Path, id.SchemeManagerIdentifier().Name(), id.Name())
	files, err := filepath.Glob(path)
	if err != nil {
		return nil, err
	}
	if len(files) == 0 {
		return nil, nil
	}

	// List private keys and get highest counter
	counters := make([]int, 0, len(files))
	for _, file := range files {
		filename := filepath.Base(file)
		count := filename[:len(filename)-4]
		i, err := strconv.Atoi(count)
		if err != nil {
			return nil, err
		}
		counters = append(counters, i)
	}
	sort.Ints(counters)
	counter := counters[len(counters)-1]

	// Read private key
	file := strings.Replace(path, "*", strconv.Itoa(counter), 1)
	sk, err := gabi.NewPrivateKeyFromFile(file)
	if err != nil {
		return nil, err
	}
	if int(sk.Counter) != counter {
		return nil, errors.Errorf("Private key %s of issuer %s has wrong <Counter>", file, id.String())
	}
	conf.privateKeys[id] = sk

	return sk, nil
}

360
361
// PublicKey returns the specified public key, or nil if not present in the Configuration.
func (conf *Configuration) PublicKey(id IssuerIdentifier, counter int) (*gabi.PublicKey, error) {
362
363
364
365
366
367
368
369
370
371
372
	var haveIssuer, haveKey bool
	var err error
	_, haveIssuer = conf.publicKeys[id]
	if haveIssuer {
		_, haveKey = conf.publicKeys[id][counter]
	}

	// If we have not seen this issuer or key before in conf.publicKeys,
	// try to parse the public key folder; new keys might have been put there since we last parsed it
	if !haveIssuer || !haveKey {
		if err = conf.parseKeysFolder(id); err != nil {
373
			return nil, err
374
375
		}
	}
376
	return conf.publicKeys[id][counter], nil
377
378
}

379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
// KeyshareServerKeyFunc returns a function that returns the public key with which to verify a keyshare server JWT,
// suitable for passing to jwt.Parse() and jwt.ParseWithClaims().
func (conf *Configuration) KeyshareServerKeyFunc(scheme SchemeManagerIdentifier) func(t *jwt.Token) (interface{}, error) {
	return func(t *jwt.Token) (i interface{}, e error) {
		var kid int
		if kidstr, ok := t.Header["kid"].(string); ok {
			var err error
			if kid, err = strconv.Atoi(kidstr); err != nil {
				return nil, err
			}
		}
		return conf.KeyshareServerPublicKey(scheme, kid)
	}
}

// KeyshareServerPublicKey returns the i'th public key of the specified scheme.
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
func (conf *Configuration) KeyshareServerPublicKey(scheme SchemeManagerIdentifier, i int) (*rsa.PublicKey, error) {
	if _, contains := conf.kssPublicKeys[scheme]; !contains {
		conf.kssPublicKeys[scheme] = make(map[int]*rsa.PublicKey)
	}
	if _, contains := conf.kssPublicKeys[scheme][i]; !contains {
		pkbts, err := ioutil.ReadFile(filepath.Join(conf.Path, scheme.Name(), fmt.Sprintf("kss-%d.pem", i)))
		if err != nil {
			return nil, err
		}
		pkblk, _ := pem.Decode(pkbts)
		genericPk, err := x509.ParsePKIXPublicKey(pkblk.Bytes)
		if err != nil {
			return nil, err
		}
		pk, ok := genericPk.(*rsa.PublicKey)
		if !ok {
			return nil, errors.New("Invalid keyshare server public key")
		}
		conf.kssPublicKeys[scheme][i] = pk
	}
	return conf.kssPublicKeys[scheme][i], nil
}

418
func (conf *Configuration) addReverseHash(credid CredentialTypeIdentifier) {
419
	hash := sha256.Sum256([]byte(credid.String()))
420
	conf.reverseHashes[base64.StdEncoding.EncodeToString(hash[:16])] = credid
421
422
}

423
424
425
func (conf *Configuration) hashToCredentialType(hash []byte) *CredentialType {
	if str, exists := conf.reverseHashes[base64.StdEncoding.EncodeToString(hash)]; exists {
		return conf.CredentialTypes[str]
426
427
428
429
	}
	return nil
}

430
// IsInitialized indicates whether this instance has successfully been initialized.
431
432
func (conf *Configuration) IsInitialized() bool {
	return conf.initialized
433
434
}

435
436
437
438
439
440
441
442
443
// Prune removes any invalid scheme managers and everything they own from this Configuration
func (conf *Configuration) Prune() {
	for _, manager := range conf.SchemeManagers {
		if !manager.Valid {
			_ = conf.RemoveSchemeManager(manager.Identifier(), false) // does not return errors
		}
	}
}

444
func (conf *Configuration) parseIssuerFolders(manager *SchemeManager, path string) error {
445
	return iterateSubfolders(path, func(dir string, _ os.FileInfo) error {
446
		issuer := &Issuer{}
447
		exists, err := conf.pathToDescription(manager, dir+"/description.xml", issuer)
448
449
450
		if err != nil {
			return err
		}
451
452
		if !exists {
			return nil
453
		}
454
455
456
		if issuer.XMLVersion < 4 {
			return errors.New("Unsupported issuer description")
		}
457

458
		if err = conf.validateIssuer(manager, issuer, dir); err != nil {
459
460
461
			return err
		}

462
		conf.Issuers[issuer.Identifier()] = issuer
463
		issuer.Valid = conf.SchemeManagers[issuer.SchemeManagerIdentifier()].Valid
464
		return conf.parseCredentialsFolder(manager, issuer, dir+"/Issues/")
465
466
467
	})
}

468
469
470
func (conf *Configuration) DeleteSchemeManager(id SchemeManagerIdentifier) error {
	delete(conf.SchemeManagers, id)
	delete(conf.DisabledSchemeManagers, id)
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
	name := id.String()
	for iss := range conf.Issuers {
		if iss.Root() == name {
			delete(conf.Issuers, iss)
		}
	}
	for iss := range conf.publicKeys {
		if iss.Root() == name {
			delete(conf.publicKeys, iss)
		}
	}
	for cred := range conf.CredentialTypes {
		if cred.Root() == name {
			delete(conf.CredentialTypes, cred)
		}
	}
487
488
489
490
	if !conf.readOnly {
		return os.RemoveAll(filepath.Join(conf.Path, id.Name()))
	}
	return nil
491
492
}

493
// parse $schememanager/$issuer/PublicKeys/$i.xml for $i = 1, ...
494
495
func (conf *Configuration) parseKeysFolder(issuerid IssuerIdentifier) error {
	manager := conf.SchemeManagers[issuerid.SchemeManagerIdentifier()]
496
	conf.publicKeys[issuerid] = map[int]*gabi.PublicKey{}
497
	path := fmt.Sprintf(pubkeyPattern, conf.Path, issuerid.SchemeManagerIdentifier().Name(), issuerid.Name())
498
499
500
501
502
503
504
505
506
507
	files, err := filepath.Glob(path)
	if err != nil {
		return err
	}

	for _, file := range files {
		filename := filepath.Base(file)
		count := filename[:len(filename)-4]
		i, err := strconv.Atoi(count)
		if err != nil {
508
			return err
509
		}
510
		relativepath, err := filepath.Rel(conf.Path, file)
511
512
513
514
		if err != nil {
			return err
		}
		bts, found, err := conf.ReadAuthenticatedFile(manager, relativepath)
515
		if err != nil || !found {
516
517
518
			return err
		}
		pk, err := gabi.NewPublicKeyFromBytes(bts)
519
520
521
		if err != nil {
			return err
		}
522
523
524
		if int(pk.Counter) != i {
			return errors.Errorf("Public key %s of issuer %s has wrong <Counter>", file, issuerid.String())
		}
525
		pk.Issuer = issuerid.String()
526
		conf.publicKeys[issuerid][i] = pk
527
	}
528

529
530
531
	return nil
}

532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
func (conf *Configuration) PublicKeyIndices(issuerid IssuerIdentifier) (i []int, err error) {
	return conf.matchKeyPattern(issuerid, pubkeyPattern)
}

func (conf *Configuration) matchKeyPattern(issuerid IssuerIdentifier, pattern string) (i []int, err error) {
	pkpath := fmt.Sprintf(pattern, conf.Path, issuerid.SchemeManagerIdentifier().Name(), issuerid.Name())
	files, err := filepath.Glob(pkpath)
	if err != nil {
		return
	}
	for _, file := range files {
		var count int
		base := filepath.Base(file)
		if count, err = strconv.Atoi(base[:len(base)-4]); err != nil {
			return
		}
		i = append(i, count)
	}
	sort.Ints(i)
	return
}

554
// parse $schememanager/$issuer/Issues/*/description.xml
555
556
func (conf *Configuration) parseCredentialsFolder(manager *SchemeManager, issuer *Issuer, path string) error {
	var foundcred bool
557
	err := iterateSubfolders(path, func(dir string, _ os.FileInfo) error {
558
		cred := &CredentialType{}
559
		exists, err := conf.pathToDescription(manager, dir+"/description.xml", cred)
560
561
562
		if err != nil {
			return err
		}
563
564
565
		if !exists {
			return nil
		}
566
		if err = conf.validateCredentialType(manager, issuer, cred, dir); err != nil {
567
568
569
570
			return err
		}
		foundcred = true
		cred.Valid = conf.SchemeManagers[cred.SchemeManagerIdentifier()].Valid
571
		credid := cred.Identifier()
572
573
		conf.CredentialTypes[credid] = cred
		conf.addReverseHash(credid)
574
		for index, attr := range cred.AttributeTypes {
575
576
577
578
			attr.Index = index
			attr.SchemeManagerID = cred.SchemeManagerID
			attr.IssuerID = cred.IssuerID
			attr.CredentialTypeID = cred.ID
579
			conf.AttributeTypes[attr.GetAttributeTypeIdentifier()] = attr
580
		}
581
582
		return nil
	})
583
584
585
586
587
588
	if !foundcred {
		conf.Warnings = append(conf.Warnings, fmt.Sprintf("Issuer %s has no credential types", issuer.Identifier().String()))
	}
	return err
}

589
590
591
// iterateSubfolders iterates over the subfolders of the specified path,
// calling the specified handler each time. If anything goes wrong, or
// if the caller returns a non-nil error, an error is immediately returned.
592
593
594
595
596
597
func iterateSubfolders(path string, handler func(string, os.FileInfo) error) error {
	return iterateFiles(path, true, handler)
}

func iterateFiles(path string, onlyDirs bool, handler func(string, os.FileInfo) error) error {
	files, err := filepath.Glob(filepath.Join(path, "*"))
598
599
600
601
	if err != nil {
		return err
	}

602
603
	for _, file := range files {
		stat, err := os.Stat(file)
604
605
606
		if err != nil {
			return err
		}
607
		if onlyDirs && !stat.IsDir() {
608
609
			continue
		}
610
		if filepath.Base(file) == ".git" {
611
612
			continue
		}
613
		err = handler(file, stat)
614
615
616
617
618
619
620
621
		if err != nil {
			return err
		}
	}

	return nil
}

622
623
624
625
626
627
628
629
630
631
632
633
634
635
// walkDir recursively walks the file tree rooted at path, following symlinks (unlike filepath.Walk).
// Avoiding loops is the responsibility of the caller.
func walkDir(path string, handler func(string, os.FileInfo) error) error {
	return iterateFiles(path, false, func(p string, info os.FileInfo) error {
		if info.IsDir() {
			if err := handler(p, info); err != nil {
				return err
			}
			return walkDir(p, handler)
		}
		return handler(p, info)
	})
}

636
func (conf *Configuration) pathToDescription(manager *SchemeManager, path string, description interface{}) (bool, error) {
637
638
639
640
	if _, err := os.Stat(path); err != nil {
		return false, nil
	}

641
	relativepath, err := filepath.Rel(conf.Path, path)
642
643
644
645
	if err != nil {
		return false, err
	}
	bts, found, err := conf.ReadAuthenticatedFile(manager, relativepath)
646
	if !found {
647
648
		if manager.index.Scheme() != manager.Identifier() {
			return false, errors.Errorf("Folder must be called %s, not %s", manager.index.Scheme(), manager.ID)
649
		}
650
		return false, errors.Errorf("File %s not present in scheme index", relativepath)
651
	}
652
653
654
655
	if err != nil {
		return true, err
	}

656
	err = xml.Unmarshal(bts, description)
657
658
659
660
661
662
	if err != nil {
		return true, err
	}

	return true, nil
}
663

664
665
// ContainsCredentialType checks if the configuration contains the specified credential type.
func (conf *Configuration) ContainsCredentialType(cred CredentialTypeIdentifier) bool {
666
667
668
	return conf.SchemeManagers[cred.IssuerIdentifier().SchemeManagerIdentifier()] != nil &&
		conf.Issuers[cred.IssuerIdentifier()] != nil &&
		conf.CredentialTypes[cred] != nil
669
}
670

671
672
673
674
675
func (conf *Configuration) ContainsAttributeType(attr AttributeTypeIdentifier) bool {
	_, contains := conf.AttributeTypes[attr]
	return contains && conf.ContainsCredentialType(attr.CredentialTypeIdentifier())
}

676
func (conf *Configuration) isUpToDate(scheme SchemeManagerIdentifier) (bool, error) {
677
	if conf.assets == "" || conf.readOnly {
678
679
		return true, nil
	}
680
681
682
683
	name := scheme.String()
	newTime, exists, err := readTimestamp(filepath.Join(conf.assets, name, "timestamp"))
	if err != nil || !exists {
		return true, errors.WrapPrefix(err, "Could not read asset timestamp of scheme "+name, 0)
684
	}
685
686
687
688
	// The storage version of the manager does not need to have a timestamp. If it does not, it is outdated.
	oldTime, exists, err := readTimestamp(filepath.Join(conf.Path, name, "timestamp"))
	if err != nil {
		return true, err
689
	}
690
	return exists && !newTime.After(*oldTime), nil
691
692
}

693
func (conf *Configuration) CopyManagerFromAssets(scheme SchemeManagerIdentifier) (bool, error) {
694
	if conf.assets == "" || conf.readOnly {
695
		return false, nil
696
	}
697
698
699
700
701
	// Remove old version; we want an exact copy of the assets version
	// not a merge of the assets version and the storage version
	name := scheme.String()
	if err := os.RemoveAll(filepath.Join(conf.Path, name)); err != nil {
		return false, err
702
	}
703
704
705
	return true, fs.CopyDirectory(
		filepath.Join(conf.assets, name),
		filepath.Join(conf.Path, name),
706
707
708
	)
}

709
710
// DownloadSchemeManager downloads and returns a scheme manager description.xml file
// from the specified URL.
711
func DownloadSchemeManager(url string) (*SchemeManager, error) {
712
713
714
715
716
717
718
719
720
	if !strings.HasPrefix(url, "http://") && !strings.HasPrefix(url, "https://") {
		url = "https://" + url
	}
	if url[len(url)-1] == '/' {
		url = url[:len(url)-1]
	}
	if strings.HasSuffix(url, "/description.xml") {
		url = url[:len(url)-len("/description.xml")]
	}
721
	b, err := NewHTTPTransport(url).GetBytes("description.xml")
722
723
724
	if err != nil {
		return nil, err
	}
725
	manager := NewSchemeManager("")
726
727
728
729
730
731
732
733
	if err = xml.Unmarshal(b, manager); err != nil {
		return nil, err
	}

	manager.URL = url // TODO?
	return manager, nil
}

Sietse Ringers's avatar
Sietse Ringers committed
734
735
// RemoveSchemeManager removes the specified scheme manager and all associated issuers,
// public keys and credential types from this Configuration.
736
func (conf *Configuration) RemoveSchemeManager(id SchemeManagerIdentifier, fromStorage bool) error {
737
	// Remove everything falling under the manager's responsibility
738
	for credid := range conf.CredentialTypes {
739
		if credid.IssuerIdentifier().SchemeManagerIdentifier() == id {
740
			delete(conf.CredentialTypes, credid)
741
742
		}
	}
743
	for issid := range conf.Issuers {
744
		if issid.SchemeManagerIdentifier() == id {
745
			delete(conf.Issuers, issid)
746
747
		}
	}
748
	for issid := range conf.publicKeys {
749
		if issid.SchemeManagerIdentifier() == id {
750
			delete(conf.publicKeys, issid)
751
752
		}
	}
753
	delete(conf.SchemeManagers, id)
754

755
	if fromStorage || !conf.readOnly {
Sietse Ringers's avatar
Sietse Ringers committed
756
		return os.RemoveAll(fmt.Sprintf("%s/%s", conf.Path, id.String()))
757
758
	}
	return nil
759
760
}

761
func (conf *Configuration) ReinstallSchemeManager(manager *SchemeManager) (err error) {
762
763
764
765
	if conf.readOnly {
		return errors.New("cannot install scheme into a read-only configuration")
	}

766
767
768
769
770
771
772
773
774
	// Check if downloading stuff from the remote works before we uninstall the specified manager:
	// If we can't download anything we should keep the broken version
	manager, err = DownloadSchemeManager(manager.URL)
	if err != nil {
		return
	}
	if err = conf.DeleteSchemeManager(manager.Identifier()); err != nil {
		return
	}
775
	err = conf.InstallSchemeManager(manager, nil)
776
777
778
	return
}

779
// InstallSchemeManager downloads and adds the specified scheme manager to this Configuration,
Sietse Ringers's avatar
Sietse Ringers committed
780
// provided its signature is valid.
781
func (conf *Configuration) InstallSchemeManager(manager *SchemeManager, publickey []byte) error {
782
783
784
785
	if conf.readOnly {
		return errors.New("cannot install scheme into a read-only configuration")
	}

786
	name := manager.ID
787
	if err := fs.EnsureDirectoryExists(filepath.Join(conf.Path, name)); err != nil {
788
789
		return err
	}
790
791

	t := NewHTTPTransport(manager.URL)
Sietse Ringers's avatar
Sietse Ringers committed
792
	path := fmt.Sprintf("%s/%s", conf.Path, name)
793
794
795
	if err := t.GetFile("description.xml", path+"/description.xml"); err != nil {
		return err
	}
796
797
798
799
800
801
802
803
	if publickey != nil {
		if err := fs.SaveFile(path+"/pk.pem", publickey); err != nil {
			return err
		}
	} else {
		if err := t.GetFile("pk.pem", path+"/pk.pem"); err != nil {
			return err
		}
804
	}
805
	if err := conf.DownloadSchemeManagerSignature(manager); err != nil {
806
807
		return err
	}
808
809
810
811
	conf.SchemeManagers[manager.Identifier()] = manager
	if err := conf.UpdateSchemeManager(manager.Identifier(), nil); err != nil {
		return err
	}
812

813
	return conf.ParseSchemeManagerFolder(filepath.Join(conf.Path, name), manager)
814
815
816
817
818
}

// DownloadSchemeManagerSignature downloads, stores and verifies the latest version
// of the index file and signature of the specified manager.
func (conf *Configuration) DownloadSchemeManagerSignature(manager *SchemeManager) (err error) {
819
820
821
822
	if conf.readOnly {
		return errors.New("cannot download into a read-only configuration")
	}

823
	t := NewHTTPTransport(manager.URL)
Sietse Ringers's avatar
Sietse Ringers committed
824
	path := fmt.Sprintf("%s/%s", conf.Path, manager.ID)
825
826
827
828
	index := filepath.Join(path, "index")
	sig := filepath.Join(path, "index.sig")

	if err = t.GetFile("index", index); err != nil {
829
		return
830
831
	}
	if err = t.GetFile("index.sig", sig); err != nil {
832
		return
833
	}
834
	err = conf.VerifySignature(manager.Identifier())
835
	return
836
}
837

838
func (e *UnknownIdentifierError) Error() string {
Leon's avatar
Leon committed
839
840
841
842
843
	return "Unknown identifiers: " + e.Missing.String()
}

func (e *RequiredAttributeMissingError) Error() string {
	return "Required attributes are missing: " + e.Missing.String()
844
845
}

Sietse Ringers's avatar
Sietse Ringers committed
846
// Download downloads the issuers, credential types and public keys specified in set
Leon's avatar
Leon committed
847
// if the current Configuration does not already have them, and checks their authenticity
Sietse Ringers's avatar
Sietse Ringers committed
848
// using the scheme manager index.
849
func (conf *Configuration) Download(session SessionRequest) (downloaded *IrmaIdentifierSet, err error) {
850
	if conf.readOnly {
Leon's avatar
Leon committed
851
		return nil, errors.New("Cannot download into a read-only configuration")
852
	}
853

Leon's avatar
Leon committed
854
	missing, requiredMissing, err := conf.checkIdentifiers(session)
855
856
	if err != nil {
		return nil, err
857
	}
858
859
	if len(missing.SchemeManagers) > 0 {
		return nil, &UnknownIdentifierError{ErrorUnknownSchemeManager, missing}
860
861
	}

Leon's avatar
Leon committed
862
	// Update the scheme found above and parse, if necessary
863
	downloaded = newIrmaIdentifierSet()
Leon's avatar
Leon committed
864
865
866
867
868
869
870
871
872
873

	// Combine to find all identifiers that possibly require updating, i.e.,
	// ones that are not found in the configuration or,
	// ones that were tagged non-optional, but were tagged optional in a more recent configuration
	allMissing := newIrmaIdentifierSet()
	allMissing.join(missing)
	allMissing.join(requiredMissing)

	// Try updating them
	for id := range allMissing.allSchemes() {
874
		if err = conf.UpdateSchemeManager(id, downloaded); err != nil {
875
876
877
878
			return
		}
	}
	if !downloaded.Empty() {
879
880
881
		if err = conf.ParseFolder(); err != nil {
			return nil, err
		}
882
	}
883

Leon's avatar
Leon committed
884
885
886
	// Check again if all session identifiers are known now and required attributes are present
	missing, requiredMissing, err = conf.checkIdentifiers(session)
	if err != nil {
887
888
		return nil, err
	}
Leon's avatar
Leon committed
889
890

	// Required in the request, but not found in the configuration
891
892
893
894
	if !missing.Empty() {
		return nil, &UnknownIdentifierError{ErrorUnknownIdentifier, missing}
	}

Leon's avatar
Leon committed
895
896
897
898
899
	// (Still) required in the configuration, but not in the request
	if !requiredMissing.Empty() {
		return nil, &RequiredAttributeMissingError{ErrorRequiredAttributeMissing, requiredMissing}
	}

900
901
902
	return
}

Leon's avatar
Leon committed
903
func (conf *Configuration) checkCredentialTypes(session SessionRequest, missing *IrmaIdentifierSet, requiredMissing *IrmaIdentifierSet) {
904
905
906
907
908
909
	var typ *CredentialType
	var contains bool

	switch s := session.(type) {
	case *IssuanceRequest:
		for _, credreq := range s.Credentials {
Leon's avatar
Leon committed
910

911
			// First check if we have this credential type
912
			typ, contains = conf.CredentialTypes[credreq.CredentialTypeID]
913
			if !contains {
914
				missing.CredentialTypes[credreq.CredentialTypeID] = struct{}{}
915
916
				continue
			}
Leon's avatar
Leon committed
917
918
919
920
921
922

			// Check for attributes in the request that are not in the credential configuration
			for reqAttr, _ := range credreq.Attributes {
				attrID := NewAttributeTypeIdentifier(credreq.CredentialTypeID.String() + "." + reqAttr)
				if !typ.ContainsAttribute(attrID) {
					missing.AttributeTypes[attrID] = struct{}{}
923
924
				}
			}
Leon's avatar
Leon committed
925
926
927
928
929
930
931

			// Check if all attributes from the configuration are present, unless they are marked as optional
			for _, attrtype := range typ.AttributeTypes {
				_, present := credreq.Attributes[attrtype.ID]
				if !present && !attrtype.IsOptional() {
					requiredMissing.AttributeTypes[attrtype.GetAttributeTypeIdentifier()] = struct{}{}
				}
932
933
934
935
			}
		}
	}

936
937
938
	_ = session.Disclosure().Disclose.Iterate(func(attr *AttributeRequest) error {
		credid := attr.Type.CredentialTypeIdentifier()
		if typ, contains = conf.CredentialTypes[credid]; !contains {
939
			missing.CredentialTypes[credid] = struct{}{}
940
			return nil
941
		}
942
		if !attr.Type.IsCredential() && !typ.ContainsAttribute(attr.Type) {
Leon's avatar
Leon committed
943
			missing.AttributeTypes[attr.Type] = struct{}{}
944
945
946
		}
		return nil
	})
947

948
949
950
	return
}

Leon's avatar
Leon committed
951
func (conf *Configuration) checkIdentifiers(session SessionRequest) (*IrmaIdentifierSet, *IrmaIdentifierSet, error) {
952
	missing := newIrmaIdentifierSet()
Leon's avatar
Leon committed
953
	requiredMissing := newIrmaIdentifierSet()
954
955
	conf.checkSchemes(session, missing)
	if err := conf.checkIssuers(session.Identifiers(), missing); err != nil {
Leon's avatar
Leon committed
956
		return nil, nil, err
957
	}
Leon's avatar
Leon committed
958
959
	conf.checkCredentialTypes(session, missing, requiredMissing)
	return missing, requiredMissing, nil
960
961
962
963
964
965
966
967
968
969
970
}

// CheckSchemes verifies that all schemes occuring in the specified session request occur in this
// instance.
func (conf *Configuration) checkSchemes(session SessionRequest, missing *IrmaIdentifierSet) {
	for id := range session.Identifiers().SchemeManagers {
		scheme, contains := conf.SchemeManagers[id]
		if !contains || !scheme.Valid {
			missing.SchemeManagers[id] = struct{}{}
		}
	}
971
972
}

973
func (conf *Configuration) checkIssuers(set *IrmaIdentifierSet, missing *IrmaIdentifierSet) error {
974
	for issid := range set.Issuers {
975
		if _, contains := conf.Issuers[issid]; !contains {
976
			missing.Issuers[issid] = struct{}{}
977
		}
Sietse Ringers's avatar
Sietse Ringers committed
978
	}
979
980
981
	for issid, keyids := range set.PublicKeys {
		for _, keyid := range keyids {
			pk, err := conf.PublicKey(issid, keyid)
Sietse Ringers's avatar
Sietse Ringers committed
982
			if err != nil {
983
				return err
Sietse Ringers's avatar
Sietse Ringers committed
984
985
			}
			if pk == nil {
986
				missing.PublicKeys[issid] = append(missing.PublicKeys[issid], keyid)
987
988
989
			}
		}
	}
990
	return nil
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
}

func (i SchemeManagerIndex) String() string {
	var paths []string
	var b bytes.Buffer

	for path := range i {
		paths = append(paths, path)
	}
	sort.Strings(paths)

	for _, path := range paths {
		b.WriteString(hex.EncodeToString(i[path]))
		b.WriteString(" ")
		b.WriteString(path)
		b.WriteString("\n")
	}

	return b.String()
}

Sietse Ringers's avatar
Sietse Ringers committed
1012
// FromString populates this index by parsing the specified string.
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
func (i SchemeManagerIndex)