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

138
139
140
// parseSchemeManagerFolder parses the entire tree of the specified scheme manager
// If err != nil then a problem occured
func (conf *Configuration) parseSchemeManagerFolder(dir string) (err error, manager *SchemeManager) {
141
	// Put the directory name in the ID field in case we return early due to errors
142
143
144
145
146
147
148
149
	manager = &SchemeManager{ID: filepath.Base(dir), Status: SchemeManagerStatusUnprocessed, Valid: false}
	// 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
150
151
	defer func() {
		if err != nil {
152
153
154
155
156
			err = &SchemeManagerError{
				Manager: manager.Identifier(),
				Err:     err,
				Status:  manager.Status,
			}
157
158
159
		}
	}()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

284
285
286
	return nil
}

287
// parse $schememanager/$issuer/Issues/*/description.xml
288
func (conf *Configuration) parseCredentialsFolder(manager *SchemeManager, path string) error {
289
290
	return iterateSubfolders(path, func(dir string) error {
		cred := &CredentialType{}
291
		exists, err := conf.pathToDescription(manager, dir+"/description.xml", cred)
292
293
294
		if err != nil {
			return err
		}
295
296
297
298
299
		if !exists {
			return nil
		}
		if cred.XMLVersion < 4 {
			return errors.New("Unsupported credential type description")
300
		}
301
		cred.Valid = conf.SchemeManagers[cred.SchemeManagerIdentifier()].Valid
302
303
304
		credid := cred.Identifier()
		conf.CredentialTypes[credid] = cred
		conf.addReverseHash(credid)
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
		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
		}
326
327
328
		if strings.HasSuffix(dir, "/.git") {
			continue
		}
329
330
331
332
333
334
335
336
337
		err = handler(dir)
		if err != nil {
			return err
		}
	}

	return nil
}

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

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

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

	return true, nil
}
355

356
357
358
359
360
// 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
361
}
362

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

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

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

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

	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
	}
440
	if err := t.GetFile("pk.pem", path+"/pk.pem"); err != nil {
441
442
		return err
	}
443
	if err := conf.DownloadSchemeManagerSignature(manager); err != nil {
444
445
		return err
	}
446

447
448
449
450
451
452
453
454
	if err := conf.VerifySchemeManager(manager); err != nil {
		manager.Status = SchemeManagerStatusInvalidSignature
		manager.Valid = false
	} else {
		manager.Status = SchemeManagerStatusValid
		manager.Valid = true
	}

455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
	conf.SchemeManagers[NewSchemeManagerIdentifier(name)] = manager
	return nil
}

// 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
	}

	if err = t.GetFile("index", index); err != nil {
		return err
	}
	if err = t.GetFile("index.sig", sig); err != nil {
		return err
	}
Sietse Ringers's avatar
Sietse Ringers committed
478
479
	valid, err := conf.VerifySignature(manager.Identifier())
	if err != nil {
480
		_ = conf.restoreManagerSignature(index, sig)
Sietse Ringers's avatar
Sietse Ringers committed
481
482
483
		return err
	}
	if !valid {
484
		_ = conf.restoreManagerSignature(index, sig)
Sietse Ringers's avatar
Sietse Ringers committed
485
486
		return errors.New("Scheme manager signature invalid")
	}
487

488
489
	return nil
}
490

491
492
493
494
495
496
497
498
499
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
}
500

501
502
func (conf *Configuration) restoreManagerSignature(index, sig string) error {
	if err := fs.Copy(index+".backup", index); err != nil {
503
504
		return err
	}
505
	if err := fs.Copy(sig+".backup", sig); err != nil {
506
507
508
509
510
		return err
	}
	return nil
}

Sietse Ringers's avatar
Sietse Ringers committed
511
512
513
// 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.
514
func (conf *Configuration) Download(set *IrmaIdentifierSet) (*IrmaIdentifierSet, error) {
515
	var contains bool
516
517
518
519
520
521
	var err error
	downloaded := &IrmaIdentifierSet{
		SchemeManagers:  map[SchemeManagerIdentifier]struct{}{},
		Issuers:         map[IssuerIdentifier]struct{}{},
		CredentialTypes: map[CredentialTypeIdentifier]struct{}{},
	}
522
	updatedManagers := make(map[SchemeManagerIdentifier]struct{})
523

524
	for manid := range set.SchemeManagers {
525
		if _, contains = conf.SchemeManagers[manid]; !contains {
526
			return nil, errors.Errorf("Unknown scheme manager: %s", manid)
527
528
529
530
531
		}
	}

	transport := NewHTTPTransport("")
	for issid := range set.Issuers {
532
		if _, contains = conf.Issuers[issid]; !contains {
533
534
535
			manager := issid.SchemeManagerIdentifier()
			url := conf.SchemeManagers[manager].URL + "/" + issid.Name()
			path := fmt.Sprintf("%s/%s/%s", conf.path, manager.String(), issid.Name())
536
537
538
			if err = transport.GetFile(url+"/description.xml", path+"/description.xml"); err != nil {
				return nil, err
			}
539
			if err = transport.GetFile(url+"/logo.png", path+"/logo.png"); err != nil {
540
541
				return nil, err
			}
542
			updatedManagers[manager] = struct{}{}
543
			downloaded.Issuers[issid] = struct{}{}
544
		}
Sietse Ringers's avatar
Sietse Ringers committed
545
546
547
	}
	for issid, list := range set.PublicKeys {
		for _, count := range list {
548
			pk, err := conf.PublicKey(issid, count)
Sietse Ringers's avatar
Sietse Ringers committed
549
550
551
552
553
554
			if err != nil {
				return nil, err
			}
			if pk == nil {
				manager := issid.SchemeManagerIdentifier()
				suffix := fmt.Sprintf("/%s/PublicKeys/%d.xml", issid.Name(), count)
555
				path := fmt.Sprintf("%s/%s/%s", conf.path, manager.String(), suffix)
556
				if err = transport.GetFile(conf.SchemeManagers[manager].URL+suffix, path); err != nil {
557
					return nil, err
558
				}
559
				updatedManagers[manager] = struct{}{}
560
561
562
563
			}
		}
	}
	for credid := range set.CredentialTypes {
564
		if _, contains := conf.CredentialTypes[credid]; !contains {
565
566
			issuer := credid.IssuerIdentifier()
			manager := issuer.SchemeManagerIdentifier()
567
			local := fmt.Sprintf("%s/%s/%s/Issues", conf.path, manager.Name(), issuer.Name())
568
			if err := fs.EnsureDirectoryExists(local); err != nil {
569
				return nil, err
570
			}
571
572
			if err = transport.GetFile(
				fmt.Sprintf("%s/%s/Issues/%s/description.xml", conf.SchemeManagers[manager].URL, issuer.Name(), credid.Name()),
573
				fmt.Sprintf("%s/%s/description.xml", local, credid.Name()),
574
575
576
			); err != nil {
				return nil, err
			}
577
578
579
580
			_ = 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()),
			)
581
			updatedManagers[manager] = struct{}{}
582
			downloaded.CredentialTypes[credid] = struct{}{}
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
609
610
611
612
613
614
615
	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
616
// FromString populates this index by parsing the specified string.
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
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
}

636
637
638
// 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
639
	if err := fs.AssertPathExists(path); err != nil {
640
		return fmt.Errorf("Missing scheme manager index file; tried %s", path)
641
	}
Sietse Ringers's avatar
Sietse Ringers committed
642
	indexbts, err := ioutil.ReadFile(path)
643
644
645
	if err != nil {
		return err
	}
646
647
	manager.Index = make(map[string]ConfigurationFileHash)
	return manager.Index.FromString(string(indexbts))
648
649
}

650
func (conf *Configuration) VerifySchemeManager(manager *SchemeManager) error {
651
	for file := range manager.Index {
652
653
654
655
656
657
658
		exists, err := fs.PathExists(filepath.Join(conf.path, file))
		if err != nil {
			return err
		}
		if !exists {
			continue
		}
659
660
661
662
663
664
665
666
667
		// Don't care about the actual bytes
		if _, err := conf.ReadAuthenticatedFile(manager, file); err != nil {
			return err
		}
	}

	return nil
}

668
669
670
671
// 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) {
672
	signedHash, ok := manager.Index[path]
673
	if !ok {
674
		return nil, errors.Errorf("File %s not present in scheme manager index", path)
675
676
677
678
679
680
681
682
683
	}

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

	if !bytes.Equal(computedHash[:], signedHash) {
684
		return nil, errors.Errorf("Hash of %s does not match scheme manager index", path)
685
686
687
688
689
690
691
	}
	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).
692
693
694
695
696
697
698
699
700
701
702
703
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")
			}
		}
	}()

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
734
735
736
737
738
739
740
	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
741
}
742
743
744
745

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