irmaconfig.go 22.2 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
	}
	_, err = conf.pathToDescription(manager, dir+"/description.xml", manager)
170
171
172
	if err != nil {
		manager.Status = SchemeManagerStatusParsingError
		return
173
174
175
	}

	if manager.XMLVersion < 7 {
176
177
		manager.Status = SchemeManagerStatusParsingError
		return errors.New("Unsupported scheme manager description"), manager
178
179
180
	}
	valid, err := conf.VerifySignature(manager.Identifier())
	if err != nil {
181
182
		manager.Status = SchemeManagerStatusInvalidSignature
		return
183
184
	}
	if !valid {
185
186
		manager.Status = SchemeManagerStatusInvalidSignature
		return errors.New("Scheme manager signature was invalid"), manager
187
	}
188

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

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

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

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

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

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

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

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

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

286
287
288
	return nil
}

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

	return nil
}

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

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

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

	return true, nil
}
357

358
359
360
361
362
// 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
363
}
364

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

372
	err := filepath.Walk(conf.assets, filepath.WalkFunc(
373
		func(path string, info os.FileInfo, err error) error {
374
			if path == conf.assets {
375
376
				return nil
			}
377
			subpath := path[len(conf.assets):]
378
			if info.IsDir() {
379
				if err := fs.EnsureDirectoryExists(conf.path + subpath); err != nil {
380
381
382
383
384
385
386
387
					return err
				}
			} else {
				srcfile, err := os.Open(path)
				if err != nil {
					return err
				}
				defer srcfile.Close()
388
				bts, err := ioutil.ReadAll(srcfile)
Sietse Ringers's avatar
Sietse Ringers committed
389
390
391
				if err != nil {
					return err
				}
392
				if err := fs.SaveFile(conf.path+subpath, bts); err != nil {
393
394
395
396
397
398
					return err
				}
			}
			return nil
		}),
	)
399
400
401
402
403

	if err != nil {
		return err
	}
	if parse {
404
		return conf.ParseFolder()
405
406
	}
	return nil
407
}
408

409
410
// DownloadSchemeManager downloads and returns a scheme manager description.xml file
// from the specified URL.
411
func (conf *Configuration) DownloadSchemeManager(url string) (*SchemeManager, error) {
412
413
414
415
416
417
418
419
420
	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")]
	}
421
	b, err := NewHTTPTransport(url).GetBytes("description.xml")
422
423
424
425
426
427
428
429
430
431
432
433
	if err != nil {
		return nil, err
	}
	manager := &SchemeManager{}
	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
434
435
// RemoveSchemeManager removes the specified scheme manager and all associated issuers,
// public keys and credential types from this Configuration.
436
func (conf *Configuration) RemoveSchemeManager(id SchemeManagerIdentifier, fromStorage bool) error {
437
	// Remove everything falling under the manager's responsibility
438
	for credid := range conf.CredentialTypes {
439
		if credid.IssuerIdentifier().SchemeManagerIdentifier() == id {
440
			delete(conf.CredentialTypes, credid)
441
442
		}
	}
443
	for issid := range conf.Issuers {
444
		if issid.SchemeManagerIdentifier() == id {
445
			delete(conf.Issuers, issid)
446
447
		}
	}
448
	for issid := range conf.publicKeys {
449
		if issid.SchemeManagerIdentifier() == id {
450
			delete(conf.publicKeys, issid)
451
452
		}
	}
453
	delete(conf.SchemeManagers, id)
454
455
456
457
458

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

Sietse Ringers's avatar
Sietse Ringers committed
461
462
// AddSchemeManager adds the specified scheme manager to this Configuration,
// provided its signature is valid.
463
func (conf *Configuration) AddSchemeManager(manager *SchemeManager) error {
464
	name := manager.ID
465
	if err := fs.EnsureDirectoryExists(fmt.Sprintf("%s/%s", conf.path, name)); err != nil {
466
467
		return err
	}
468
469
470
471
472
473

	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
	}
474
	if err := t.GetFile("pk.pem", path+"/pk.pem"); err != nil {
475
476
		return err
	}
477
	if err := conf.DownloadSchemeManagerSignature(manager); err != nil {
478
479
		return err
	}
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503

	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
504
505
	valid, err := conf.VerifySignature(manager.Identifier())
	if err != nil {
506
		_ = conf.restoreManagerSignature(index, sig)
Sietse Ringers's avatar
Sietse Ringers committed
507
508
509
		return err
	}
	if !valid {
510
		_ = conf.restoreManagerSignature(index, sig)
Sietse Ringers's avatar
Sietse Ringers committed
511
512
		return errors.New("Scheme manager signature invalid")
	}
513

514
515
	return nil
}
516

517
518
519
520
521
522
523
524
525
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
}
526

527
528
func (conf *Configuration) restoreManagerSignature(index, sig string) error {
	if err := fs.Copy(index+".backup", index); err != nil {
529
530
		return err
	}
531
	if err := fs.Copy(sig+".backup", sig); err != nil {
532
533
534
535
536
		return err
	}
	return nil
}

Sietse Ringers's avatar
Sietse Ringers committed
537
538
539
// 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.
540
func (conf *Configuration) Download(set *IrmaIdentifierSet) (*IrmaIdentifierSet, error) {
541
	var contains bool
542
543
544
545
546
547
	var err error
	downloaded := &IrmaIdentifierSet{
		SchemeManagers:  map[SchemeManagerIdentifier]struct{}{},
		Issuers:         map[IssuerIdentifier]struct{}{},
		CredentialTypes: map[CredentialTypeIdentifier]struct{}{},
	}
548
	updatedManagers := make(map[SchemeManagerIdentifier]struct{})
549

550
	for manid := range set.SchemeManagers {
551
		if _, contains = conf.SchemeManagers[manid]; !contains {
552
			return nil, errors.Errorf("Unknown scheme manager: %s", manid)
553
554
555
556
557
		}
	}

	transport := NewHTTPTransport("")
	for issid := range set.Issuers {
558
		if _, contains = conf.Issuers[issid]; !contains {
559
560
561
			manager := issid.SchemeManagerIdentifier()
			url := conf.SchemeManagers[manager].URL + "/" + issid.Name()
			path := fmt.Sprintf("%s/%s/%s", conf.path, manager.String(), issid.Name())
562
563
564
			if err = transport.GetFile(url+"/description.xml", path+"/description.xml"); err != nil {
				return nil, err
			}
565
			if err = transport.GetFile(url+"/logo.png", path+"/logo.png"); err != nil {
566
567
				return nil, err
			}
568
			updatedManagers[manager] = struct{}{}
569
			downloaded.Issuers[issid] = struct{}{}
570
		}
Sietse Ringers's avatar
Sietse Ringers committed
571
572
573
	}
	for issid, list := range set.PublicKeys {
		for _, count := range list {
574
			pk, err := conf.PublicKey(issid, count)
Sietse Ringers's avatar
Sietse Ringers committed
575
576
577
578
579
580
			if err != nil {
				return nil, err
			}
			if pk == nil {
				manager := issid.SchemeManagerIdentifier()
				suffix := fmt.Sprintf("/%s/PublicKeys/%d.xml", issid.Name(), count)
581
				path := fmt.Sprintf("%s/%s/%s", conf.path, manager.String(), suffix)
582
				if err = transport.GetFile(conf.SchemeManagers[manager].URL+suffix, path); err != nil {
583
					return nil, err
584
				}
585
				updatedManagers[manager] = struct{}{}
586
587
588
589
			}
		}
	}
	for credid := range set.CredentialTypes {
590
		if _, contains := conf.CredentialTypes[credid]; !contains {
591
592
			issuer := credid.IssuerIdentifier()
			manager := issuer.SchemeManagerIdentifier()
593
			local := fmt.Sprintf("%s/%s/%s/Issues", conf.path, manager.Name(), issuer.Name())
594
			if err := fs.EnsureDirectoryExists(local); err != nil {
595
				return nil, err
596
			}
597
598
			if err = transport.GetFile(
				fmt.Sprintf("%s/%s/Issues/%s/description.xml", conf.SchemeManagers[manager].URL, issuer.Name(), credid.Name()),
599
				fmt.Sprintf("%s/%s/description.xml", local, credid.Name()),
600
601
602
			); err != nil {
				return nil, err
			}
603
604
605
606
			_ = 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()),
			)
607
			updatedManagers[manager] = struct{}{}
608
			downloaded.CredentialTypes[credid] = struct{}{}
609
610
611
		}
	}

612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
	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
642
// FromString populates this index by parsing the specified string.
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
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
}

662
663
664
// 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
665
	if err := fs.AssertPathExists(path); err != nil {
666
		return fmt.Errorf("Missing scheme manager index file; tried %s", path)
667
	}
Sietse Ringers's avatar
Sietse Ringers committed
668
	indexbts, err := ioutil.ReadFile(path)
669
670
671
	if err != nil {
		return err
	}
672
673
	manager.Index = make(map[string]ConfigurationFileHash)
	return manager.Index.FromString(string(indexbts))
674
675
676
677
678
679
}

// 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) {
680
	signedHash, ok := manager.Index[path]
681
	if !ok {
682
		return nil, errors.Errorf("File %s not present in scheme manager index", path)
683
684
685
686
687
688
689
690
691
	}

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

	if !bytes.Equal(computedHash[:], signedHash) {
692
		return nil, errors.Errorf("Hash of %s does not match scheme manager index", path)
693
694
695
696
697
698
699
	}
	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).
700
701
702
703
704
705
706
707
708
709
710
711
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")
			}
		}
	}()

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
741
742
743
744
745
746
747
748
	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
749
}
750
751
752
753

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