irmaconfig.go 21.7 KB
Newer Older
1
package irma
2
3
4
5
6
7
8
9
10

import (
	"encoding/base64"
	"encoding/xml"
	"io/ioutil"
	"os"
	"path/filepath"
	"strconv"

11
12
	"crypto/sha256"

13
14
15
16
	"fmt"

	"strings"

17
18
19
20
21
22
23
24
25
26
27
28
	"sort"

	"bytes"

	"encoding/hex"

	"crypto/ecdsa"
	"crypto/x509"
	"encoding/asn1"
	"encoding/pem"
	"math/big"

29
	"github.com/go-errors/errors"
30
	"github.com/mhe/gabi"
31
	"github.com/privacybydesign/irmago/internal/fs"
32
33
)

34
// Configuration keeps track of scheme managers, issuers, credential types and public keys,
35
// dezerializing them from an irma_configuration folder, and downloads and saves new ones on demand.
36
type Configuration struct {
37
38
39
	SchemeManagers  map[SchemeManagerIdentifier]*SchemeManager
	Issuers         map[IssuerIdentifier]*Issuer
	CredentialTypes map[CredentialTypeIdentifier]*CredentialType
40

41
42
43
44
	// 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
	// TODO: what can we say about the consistency of this Configuration if this is not empty?
45

46
	publicKeys    map[IssuerIdentifier]map[int]*gabi.PublicKey
47
	reverseHashes map[string]CredentialTypeIdentifier
48
	initialized   bool
49
50
	path          string
	assets        string
51
52
}

Sietse Ringers's avatar
Sietse Ringers committed
53
54
// ConfigurationFileHash encodes the SHA256 hash of an authenticated
// file under a scheme manager within the configuration folder.
55
56
type ConfigurationFileHash []byte

Sietse Ringers's avatar
Sietse Ringers committed
57
58
// SchemeManagerIndex is a (signed) list of files under a scheme manager
// along with their SHA266 hash
59
60
type SchemeManagerIndex map[string]ConfigurationFileHash

61
62
type SchemeManagerStatus string

63
64
type SchemeManagerError struct {
	Manager SchemeManagerIdentifier
65
	Status  SchemeManagerStatus
66
67
68
	Err     error
}

69
70
71
72
73
74
75
76
77
const (
	SchemeManagerStatusValid               = SchemeManagerStatus("Valid")
	SchemeManagerStatusUnprocessed         = SchemeManagerStatus("Unprocessed")
	SchemeManagerStatusInvalidIndex        = SchemeManagerStatus("InvalidIndex")
	SchemeManagerStatusInvalidSignature    = SchemeManagerStatus("InvalidSignature")
	SchemeManagerStatusParsingError        = SchemeManagerStatus("ParsingError")
	SchemeManagerStatusContentParsingError = SchemeManagerStatus("ContentParsingError")
)

78
79
80
81
func (sme SchemeManagerError) Error() string {
	return fmt.Sprintf("Error parsing scheme manager %s: %s", sme.Manager.Name(), sme.Err.Error())
}

82
// NewConfiguration returns a new configuration. After this
83
// ParseFolder() should be called to parse the specified path.
84
85
func NewConfiguration(path string, assets string) (conf *Configuration, err error) {
	conf = &Configuration{
86
87
		path:   path,
		assets: assets,
88
	}
89

90
	if err = fs.EnsureDirectoryExists(conf.path); err != nil {
91
92
		return nil, err
	}
93
	if conf.assets != "" && fs.Empty(conf.path) {
94
		if err = conf.CopyFromAssets(false); err != nil {
95
96
97
98
			return nil, err
		}
	}

99
100
101
	return
}

102
// ParseFolder populates the current Configuration by parsing the storage path,
103
// listing the containing scheme managers, issuers and credential types.
104
func (conf *Configuration) ParseFolder() (err error) {
105
	// Init all maps
106
107
108
	conf.SchemeManagers = make(map[SchemeManagerIdentifier]*SchemeManager)
	conf.Issuers = make(map[IssuerIdentifier]*Issuer)
	conf.CredentialTypes = make(map[CredentialTypeIdentifier]*CredentialType)
109
	conf.DisabledSchemeManagers = make(map[SchemeManagerIdentifier]*SchemeManagerError)
110
	conf.publicKeys = make(map[IssuerIdentifier]map[int]*gabi.PublicKey)
111
	conf.reverseHashes = make(map[string]CredentialTypeIdentifier)
112

113
	var mgrerr *SchemeManagerError
114
	err = iterateSubfolders(conf.path, func(dir string) error {
115
116
		manager := &SchemeManager{ID: filepath.Base(dir), Status: SchemeManagerStatusUnprocessed, Valid: false}
		err := conf.parseSchemeManagerFolder(dir, manager)
117
118
		if err == nil {
			return nil // OK, do next scheme manager folder
119
		}
120
121
122
123
		// 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 {
124
			conf.DisabledSchemeManagers[manager.Identifier()] = mgrerr
125
			return nil
126
		}
127
		return err // Not a SchemeManagerError? return it & halt parsing now
128
129
	})
	if err != nil {
130
		return
131
	}
132
	conf.initialized = true
133
134
135
	if mgrerr != nil {
		return mgrerr
	}
136
	return
137
138
}

139
140
// parseSchemeManagerFolder parses the entire tree of the specified scheme manager
// If err != nil then a problem occured
141
func (conf *Configuration) parseSchemeManagerFolder(dir string, manager *SchemeManager) (err error) {
142
143
144
145
146
147
148
	// 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
149
150
	defer func() {
		if err != nil {
151
152
153
154
155
			err = &SchemeManagerError{
				Manager: manager.Identifier(),
				Err:     err,
				Status:  manager.Status,
			}
156
157
158
		}
	}()

159
160
161
162
163
	err = fs.AssertPathExists(dir + "/description.xml")
	if err != nil {
		return
	}

164
	if err = conf.parseIndex(filepath.Base(dir), manager); err != nil {
165
166
		manager.Status = SchemeManagerStatusInvalidIndex
		return
167
	}
168

169
	err = conf.VerifySchemeManager(manager)
170
171
172
173
174
	if err != nil {
		manager.Status = SchemeManagerStatusInvalidSignature
		return
	}

175
	_, err = conf.pathToDescription(manager, dir+"/description.xml", manager)
176
177
178
	if err != nil {
		manager.Status = SchemeManagerStatusParsingError
		return
179
180
181
	}

	if manager.XMLVersion < 7 {
182
		manager.Status = SchemeManagerStatusParsingError
183
		return errors.New("Unsupported scheme manager description")
184
	}
185

186
	err = conf.parseIssuerFolders(manager, dir)
187
188
189
190
191
192
	if err != nil {
		manager.Status = SchemeManagerStatusContentParsingError
		return
	}
	manager.Status = SchemeManagerStatusValid
	manager.Valid = true
193
194
195
	return
}

196
197
198
199
func relativePath(absolute string, relative string) string {
	return relative[len(absolute)+1:]
}

200
201
202
203
// 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) {
	if _, contains := conf.publicKeys[id]; !contains {
		conf.publicKeys[id] = map[int]*gabi.PublicKey{}
204
		if err := conf.parseKeysFolder(conf.SchemeManagers[id.SchemeManagerIdentifier()], id); err != nil {
205
			return nil, err
206
207
		}
	}
208
	return conf.publicKeys[id][counter], nil
209
210
}

211
func (conf *Configuration) addReverseHash(credid CredentialTypeIdentifier) {
212
	hash := sha256.Sum256([]byte(credid.String()))
213
	conf.reverseHashes[base64.StdEncoding.EncodeToString(hash[:16])] = credid
214
215
}

216
217
218
func (conf *Configuration) hashToCredentialType(hash []byte) *CredentialType {
	if str, exists := conf.reverseHashes[base64.StdEncoding.EncodeToString(hash)]; exists {
		return conf.CredentialTypes[str]
219
220
221
222
	}
	return nil
}

223
// IsInitialized indicates whether this instance has successfully been initialized.
224
225
func (conf *Configuration) IsInitialized() bool {
	return conf.initialized
226
227
}

228
229
230
231
232
233
234
235
236
// 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
		}
	}
}

237
func (conf *Configuration) parseIssuerFolders(manager *SchemeManager, path string) error {
238
239
	return iterateSubfolders(path, func(dir string) error {
		issuer := &Issuer{}
240
		exists, err := conf.pathToDescription(manager, dir+"/description.xml", issuer)
241
242
243
		if err != nil {
			return err
		}
244
245
		if !exists {
			return nil
246
		}
247
248
249
250
		if issuer.XMLVersion < 4 {
			return errors.New("Unsupported issuer description")
		}
		conf.Issuers[issuer.Identifier()] = issuer
251
		issuer.Valid = conf.SchemeManagers[issuer.SchemeManagerIdentifier()].Valid
252
		return conf.parseCredentialsFolder(manager, dir+"/Issues/")
253
254
255
	})
}

256
// parse $schememanager/$issuer/PublicKeys/$i.xml for $i = 1, ...
257
func (conf *Configuration) parseKeysFolder(manager *SchemeManager, issuerid IssuerIdentifier) error {
258
	path := fmt.Sprintf("%s/%s/%s/PublicKeys/*.xml", conf.path, issuerid.SchemeManagerIdentifier().Name(), issuerid.Name())
259
260
261
262
263
264
265
266
267
268
269
	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 {
			continue
270
		}
271
272
273
274
275
		bts, err := conf.ReadAuthenticatedFile(manager, relativePath(conf.path, file))
		if err != nil {
			return err
		}
		pk, err := gabi.NewPublicKeyFromBytes(bts)
276
277
278
		if err != nil {
			return err
		}
279
		pk.Issuer = issuerid.String()
280
		conf.publicKeys[issuerid][i] = pk
281
	}
282

283
284
285
	return nil
}

286
// parse $schememanager/$issuer/Issues/*/description.xml
287
func (conf *Configuration) parseCredentialsFolder(manager *SchemeManager, path string) error {
288
289
	return iterateSubfolders(path, func(dir string) error {
		cred := &CredentialType{}
290
		exists, err := conf.pathToDescription(manager, dir+"/description.xml", cred)
291
292
293
		if err != nil {
			return err
		}
294
295
296
297
298
		if !exists {
			return nil
		}
		if cred.XMLVersion < 4 {
			return errors.New("Unsupported credential type description")
299
		}
300
		cred.Valid = conf.SchemeManagers[cred.SchemeManagerIdentifier()].Valid
301
302
303
		credid := cred.Identifier()
		conf.CredentialTypes[credid] = cred
		conf.addReverseHash(credid)
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
		return nil
	})
}

// 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.
func iterateSubfolders(path string, handler func(string) error) error {
	dirs, err := filepath.Glob(path + "/*")
	if err != nil {
		return err
	}

	for _, dir := range dirs {
		stat, err := os.Stat(dir)
		if err != nil {
			return err
		}
		if !stat.IsDir() {
			continue
		}
325
326
327
		if strings.HasSuffix(dir, "/.git") {
			continue
		}
328
329
330
331
332
333
334
335
336
		err = handler(dir)
		if err != nil {
			return err
		}
	}

	return nil
}

337
func (conf *Configuration) pathToDescription(manager *SchemeManager, path string, description interface{}) (bool, error) {
338
339
340
341
	if _, err := os.Stat(path); err != nil {
		return false, nil
	}

342
	bts, err := conf.ReadAuthenticatedFile(manager, relativePath(conf.path, path))
343
344
345
346
	if err != nil {
		return true, err
	}

347
	err = xml.Unmarshal(bts, description)
348
349
350
351
352
353
	if err != nil {
		return true, err
	}

	return true, nil
}
354

355
356
357
358
359
// Contains checks if the configuration contains the specified credential type.
func (conf *Configuration) Contains(cred CredentialTypeIdentifier) bool {
	return conf.SchemeManagers[cred.IssuerIdentifier().SchemeManagerIdentifier()] != nil &&
		conf.Issuers[cred.IssuerIdentifier()] != nil &&
		conf.CredentialTypes[cred] != nil
360
}
361

362
363
364
// CopyFromAssets recursively copies the directory tree from the assets folder
// into the directory of this Configuration.
func (conf *Configuration) CopyFromAssets(parse bool) error {
365
	if err := fs.CopyDirectory(conf.assets, conf.path); err != nil {
366
367
368
		return err
	}
	if parse {
369
		return conf.ParseFolder()
370
371
	}
	return nil
372
}
373

374
375
// DownloadSchemeManager downloads and returns a scheme manager description.xml file
// from the specified URL.
376
func (conf *Configuration) DownloadSchemeManager(url string) (*SchemeManager, error) {
377
378
379
380
381
382
383
384
385
	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")]
	}
386
	b, err := NewHTTPTransport(url).GetBytes("description.xml")
387
388
389
	if err != nil {
		return nil, err
	}
390
	manager := &SchemeManager{Status: SchemeManagerStatusUnprocessed, Valid: false}
391
392
393
394
395
396
397
398
	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
399
400
// RemoveSchemeManager removes the specified scheme manager and all associated issuers,
// public keys and credential types from this Configuration.
401
func (conf *Configuration) RemoveSchemeManager(id SchemeManagerIdentifier, fromStorage bool) error {
402
	// Remove everything falling under the manager's responsibility
403
	for credid := range conf.CredentialTypes {
404
		if credid.IssuerIdentifier().SchemeManagerIdentifier() == id {
405
			delete(conf.CredentialTypes, credid)
406
407
		}
	}
408
	for issid := range conf.Issuers {
409
		if issid.SchemeManagerIdentifier() == id {
410
			delete(conf.Issuers, issid)
411
412
		}
	}
413
	for issid := range conf.publicKeys {
414
		if issid.SchemeManagerIdentifier() == id {
415
			delete(conf.publicKeys, issid)
416
417
		}
	}
418
	delete(conf.SchemeManagers, id)
419
420
421
422
423

	if fromStorage {
		return os.RemoveAll(fmt.Sprintf("%s/%s", conf.path, id.String()))
	}
	return nil
424
425
}

Sietse Ringers's avatar
Sietse Ringers committed
426
427
// AddSchemeManager adds the specified scheme manager to this Configuration,
// provided its signature is valid.
428
func (conf *Configuration) AddSchemeManager(manager *SchemeManager) error {
429
	name := manager.ID
430
	if err := fs.EnsureDirectoryExists(fmt.Sprintf("%s/%s", conf.path, name)); err != nil {
431
432
		return err
	}
433
434
435
436
437
438

	t := NewHTTPTransport(manager.URL)
	path := fmt.Sprintf("%s/%s", conf.path, name)
	if err := t.GetFile("description.xml", path+"/description.xml"); err != nil {
		return err
	}
439
	if err := t.GetFile("pk.pem", path+"/pk.pem"); err != nil {
440
441
		return err
	}
442
	if err := conf.DownloadSchemeManagerSignature(manager); err != nil {
443
444
		return err
	}
445

446
	return conf.parseSchemeManagerFolder(filepath.Join(conf.path, name), manager)
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
}

// 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) {
	t := NewHTTPTransport(manager.URL)
	path := fmt.Sprintf("%s/%s", conf.path, manager.ID)
	index := filepath.Join(path, "index")
	sig := filepath.Join(path, "index.sig")

	// Backup so we can restore last valid signature if the new signature is invalid
	if err := conf.backupManagerSignature(index, sig); err != nil {
		return err
	}

462
463
464
465
466
467
	defer func() {
		if err != nil {
			_ = conf.restoreManagerSignature(index, sig)
		}
	}()

468
	if err = t.GetFile("index", index); err != nil {
469
		return
470
471
	}
	if err = t.GetFile("index.sig", sig); err != nil {
472
		return
473
	}
Sietse Ringers's avatar
Sietse Ringers committed
474
475
	valid, err := conf.VerifySignature(manager.Identifier())
	if err != nil {
476
		return
Sietse Ringers's avatar
Sietse Ringers committed
477
478
	}
	if !valid {
479
		err = errors.New("Scheme manager signature invalid")
Sietse Ringers's avatar
Sietse Ringers committed
480
	}
481
	return
482
}
483

484
485
486
487
488
489
490
491
492
func (conf *Configuration) backupManagerSignature(index, sig string) error {
	if err := fs.Copy(index, index+".backup"); err != nil {
		return err
	}
	if err := fs.Copy(sig, sig+".backup"); err != nil {
		return err
	}
	return nil
}
493

494
495
func (conf *Configuration) restoreManagerSignature(index, sig string) error {
	if err := fs.Copy(index+".backup", index); err != nil {
496
497
		return err
	}
498
	if err := fs.Copy(sig+".backup", sig); err != nil {
499
500
501
502
503
		return err
	}
	return nil
}

Sietse Ringers's avatar
Sietse Ringers committed
504
505
506
// Download downloads the issuers, credential types and public keys specified in set
// if the current Configuration does not already have them,  and checks their authenticity
// using the scheme manager index.
507
func (conf *Configuration) Download(set *IrmaIdentifierSet) (*IrmaIdentifierSet, error) {
508
	var contains bool
509
510
511
512
513
514
	var err error
	downloaded := &IrmaIdentifierSet{
		SchemeManagers:  map[SchemeManagerIdentifier]struct{}{},
		Issuers:         map[IssuerIdentifier]struct{}{},
		CredentialTypes: map[CredentialTypeIdentifier]struct{}{},
	}
515
	updatedManagers := make(map[SchemeManagerIdentifier]struct{})
516

517
	for manid := range set.SchemeManagers {
518
		if _, contains = conf.SchemeManagers[manid]; !contains {
519
			return nil, errors.Errorf("Unknown scheme manager: %s", manid)
520
521
522
523
524
		}
	}

	transport := NewHTTPTransport("")
	for issid := range set.Issuers {
525
		if _, contains = conf.Issuers[issid]; !contains {
526
527
528
			manager := issid.SchemeManagerIdentifier()
			url := conf.SchemeManagers[manager].URL + "/" + issid.Name()
			path := fmt.Sprintf("%s/%s/%s", conf.path, manager.String(), issid.Name())
529
530
531
			if err = transport.GetFile(url+"/description.xml", path+"/description.xml"); err != nil {
				return nil, err
			}
532
			if err = transport.GetFile(url+"/logo.png", path+"/logo.png"); err != nil {
533
534
				return nil, err
			}
535
			updatedManagers[manager] = struct{}{}
536
			downloaded.Issuers[issid] = struct{}{}
537
		}
Sietse Ringers's avatar
Sietse Ringers committed
538
539
540
	}
	for issid, list := range set.PublicKeys {
		for _, count := range list {
541
			pk, err := conf.PublicKey(issid, count)
Sietse Ringers's avatar
Sietse Ringers committed
542
543
544
545
546
547
			if err != nil {
				return nil, err
			}
			if pk == nil {
				manager := issid.SchemeManagerIdentifier()
				suffix := fmt.Sprintf("/%s/PublicKeys/%d.xml", issid.Name(), count)
548
				path := fmt.Sprintf("%s/%s/%s", conf.path, manager.String(), suffix)
549
				if err = transport.GetFile(conf.SchemeManagers[manager].URL+suffix, path); err != nil {
550
					return nil, err
551
				}
552
				updatedManagers[manager] = struct{}{}
553
554
555
556
			}
		}
	}
	for credid := range set.CredentialTypes {
557
		if _, contains := conf.CredentialTypes[credid]; !contains {
558
559
			issuer := credid.IssuerIdentifier()
			manager := issuer.SchemeManagerIdentifier()
560
			local := fmt.Sprintf("%s/%s/%s/Issues", conf.path, manager.Name(), issuer.Name())
561
			if err := fs.EnsureDirectoryExists(local); err != nil {
562
				return nil, err
563
			}
564
565
			if err = transport.GetFile(
				fmt.Sprintf("%s/%s/Issues/%s/description.xml", conf.SchemeManagers[manager].URL, issuer.Name(), credid.Name()),
566
				fmt.Sprintf("%s/%s/description.xml", local, credid.Name()),
567
568
569
			); err != nil {
				return nil, err
			}
570
571
572
573
			_ = transport.GetFile( // Get logo but ignore errors, it is optional
				fmt.Sprintf("%s/%s/Issues/%s/logo.png", conf.SchemeManagers[manager].URL, issuer.Name(), credid.Name()),
				fmt.Sprintf("%s/%s/logo.png", local, credid.Name()),
			)
574
			updatedManagers[manager] = struct{}{}
575
			downloaded.CredentialTypes[credid] = struct{}{}
576
577
578
		}
	}

579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
	for manager := range updatedManagers {
		if err := conf.DownloadSchemeManagerSignature(conf.SchemeManagers[manager]); err != nil {
			return nil, err
		}
	}
	if !downloaded.Empty() {
		return downloaded, conf.ParseFolder()
	}
	return downloaded, nil
}

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
609
// FromString populates this index by parsing the specified string.
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
func (i SchemeManagerIndex) FromString(s string) error {
	for j, line := range strings.Split(s, "\n") {
		if len(line) == 0 {
			continue
		}
		parts := strings.Split(line, " ")
		if len(parts) != 2 {
			return errors.Errorf("Scheme manager index line %d has incorrect amount of parts", j)
		}
		hash, err := hex.DecodeString(parts[0])
		if err != nil {
			return err
		}
		i[parts[1]] = hash
	}

	return nil
}

629
630
631
// parseIndex parses the index file of the specified manager.
func (conf *Configuration) parseIndex(name string, manager *SchemeManager) error {
	path := filepath.Join(conf.path, name, "index")
Sietse Ringers's avatar
Sietse Ringers committed
632
	if err := fs.AssertPathExists(path); err != nil {
633
		return fmt.Errorf("Missing scheme manager index file; tried %s", path)
634
	}
Sietse Ringers's avatar
Sietse Ringers committed
635
	indexbts, err := ioutil.ReadFile(path)
636
637
638
	if err != nil {
		return err
	}
639
640
	manager.Index = make(map[string]ConfigurationFileHash)
	return manager.Index.FromString(string(indexbts))
641
642
}

643
func (conf *Configuration) VerifySchemeManager(manager *SchemeManager) error {
644
	for file := range manager.Index {
645
646
647
648
649
650
651
		exists, err := fs.PathExists(filepath.Join(conf.path, file))
		if err != nil {
			return err
		}
		if !exists {
			continue
		}
652
653
654
655
656
657
658
659
660
		// Don't care about the actual bytes
		if _, err := conf.ReadAuthenticatedFile(manager, file); err != nil {
			return err
		}
	}

	return nil
}

661
662
663
664
// ReadAuthenticatedFile reads the file at the specified path
// and verifies its authenticity by checking that the file hash
// is present in the (signed) scheme manager index file.
func (conf *Configuration) ReadAuthenticatedFile(manager *SchemeManager, path string) ([]byte, error) {
665
	signedHash, ok := manager.Index[path]
666
	if !ok {
667
		return nil, errors.Errorf("File %s not present in scheme manager index", path)
668
669
670
671
672
673
674
675
676
	}

	bts, err := ioutil.ReadFile(filepath.Join(conf.path, path))
	if err != nil {
		return nil, err
	}
	computedHash := sha256.Sum256(bts)

	if !bytes.Equal(computedHash[:], signedHash) {
677
		return nil, errors.Errorf("Hash of %s does not match scheme manager index", path)
678
679
680
681
682
683
684
	}
	return bts, nil
}

// VerifySignature verifies the signature on the scheme manager index file
// (which contains the SHA256 hashes of all files under this scheme manager,
// which are used for verifying file authenticity).
685
686
687
688
689
690
691
692
693
694
695
696
func (conf *Configuration) VerifySignature(id SchemeManagerIdentifier) (valid bool, err error) {
	defer func() {
		if r := recover(); r != nil {
			valid = false
			if e, ok := r.(error); ok {
				err = errors.Errorf("Scheme manager index signature failed to verify: %s", e.Error())
			} else {
				err = errors.New("Scheme manager index signature failed to verify")
			}
		}
	}()

697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
	dir := filepath.Join(conf.path, id.String())
	if err := fs.AssertPathExists(dir+"/index", dir+"/index.sig", dir+"/pk.pem"); err != nil {
		return false, errors.New("Missing scheme manager index file, signature, or public key")
	}

	// Read and hash index file
	indexbts, err := ioutil.ReadFile(dir + "/index")
	if err != nil {
		return false, err
	}
	indexhash := sha256.Sum256(indexbts)

	// Read and parse scheme manager public key
	pkbts, err := ioutil.ReadFile(dir + "/pk.pem")
	if err != nil {
		return false, err
	}
	pkblk, _ := pem.Decode(pkbts)
	genericPk, err := x509.ParsePKIXPublicKey(pkblk.Bytes)
	if err != nil {
		return false, err
	}
	pk, ok := genericPk.(*ecdsa.PublicKey)
	if !ok {
		return false, errors.New("Invalid scheme manager public key")
	}

	// Read and parse signature
	sig, err := ioutil.ReadFile(dir + "/index.sig")
	if err != nil {
		return false, err
	}
	ints := make([]*big.Int, 0, 2)
	_, err = asn1.Unmarshal(sig, &ints)

	// Verify signature
	return ecdsa.Verify(pk, indexhash[:], ints[0], ints[1]), nil
734
}
735
736
737
738

func (hash ConfigurationFileHash) String() string {
	return hex.EncodeToString(hash)
}