Clean up random package, move config registering from init to prep phase

crypto/random/entropy.go

@@ -10,23 +10,10 @@ import (
 )
 
 var (
-	rngFeeder      = make(chan []byte, 0)
+	rngFeeder      = make(chan []byte)
 	minFeedEntropy config.IntOption
 )
 
-func init() {
-	config.Register(&config.Option{
-		Name:            "Minimum Feed Entropy",
-		Key:             "random/min_feed_entropy",
-		Description:     "The minimum amount of entropy before a entropy source is feed to the RNG, in bits.",
-		ExpertiseLevel:  config.ExpertiseLevelDeveloper,
-		OptType:         config.OptTypeInt,
-		DefaultValue:    256,
-		ValidationRegex: "^[0-9]{3,5}$",
-	})
-	minFeedEntropy = config.Concurrent.GetAsInt("random/min_feed_entropy", 256)
-}
-
 // The Feeder is used to feed entropy to the RNG.
 type Feeder struct {
 	input        chan *entropyData
@@ -43,7 +30,7 @@ type entropyData struct {
 // NewFeeder returns a new entropy Feeder.
 func NewFeeder() *Feeder {
 	new := &Feeder{
-		input:        make(chan *entropyData, 0),
+		input:        make(chan *entropyData),
 		needsEntropy: abool.NewBool(true),
 		buffer:       container.New(),
 	}

crypto/random/get.go

@@ -25,28 +25,6 @@ var (
 type reader struct{}
 
 func init() {
-	config.Register(&config.Option{
-		Name:            "Reseed after x seconds",
-		Key:             "random/reseed_after_seconds",
-		Description:     "Number of seconds until reseed",
-		ExpertiseLevel:  config.ExpertiseLevelDeveloper,
-		OptType:         config.OptTypeInt,
-		DefaultValue:    360, // ten minutes
-		ValidationRegex: "^[1-9][0-9]{1,5}$",
-	})
-	reseedAfterSeconds = config.Concurrent.GetAsInt("random/reseed_after_seconds", 360)
-
-	config.Register(&config.Option{
-		Name:            "Reseed after x bytes",
-		Key:             "random/reseed_after_bytes",
-		Description:     "Number of fetched bytes until reseed",
-		ExpertiseLevel:  config.ExpertiseLevelDeveloper,
-		OptType:         config.OptTypeInt,
-		DefaultValue:    1000000, // one megabyte
-		ValidationRegex: "^[1-9][0-9]{2,9}$",
-	})
-	reseedAfterBytes = config.GetAsInt("random/reseed_after_bytes", 1000000)
-
 	Reader = reader{}
 }
 
@@ -55,7 +33,7 @@ func checkEntropy() (err error) {
 		return errors.New("RNG is not ready yet")
 	}
 	if rngBytesRead > reseedAfterBytes() ||
-		int64(time.Now().Sub(rngLastFeed).Seconds()) > reseedAfterSeconds() {
+		int64(time.Since(rngLastFeed).Seconds()) > reseedAfterSeconds() {
 		select {
 		case r := <-rngFeeder:
 			rng.Reseed(r)

crypto/random/rng.go

@@ -19,13 +19,15 @@ var (
 	rngReady        = false
 	rngCipherOption config.StringOption
 
-	shutdownSignal = make(chan struct{}, 0)
+	shutdownSignal = make(chan struct{})
 )
 
 func init() {
-	modules.Register("random", prep, Start, stop, "base")
+	modules.Register("random", prep, Start, nil, "base")
+}
 
-	config.Register(&config.Option{
+func prep() error {
+	err := config.Register(&config.Option{
 		Name:            "RNG Cipher",
 		Key:             "random/rng_cipher",
 		Description:     "Cipher to use for the Fortuna RNG. Requires restart to take effect.",
@@ -35,10 +37,53 @@ func init() {
 		DefaultValue:    "aes",
 		ValidationRegex: "^(aes|serpent)$",
 	})
+	if err != nil {
+		return err
+	}
 	rngCipherOption = config.GetAsString("random/rng_cipher", "aes")
-}
 
-func prep() error {
+	err = config.Register(&config.Option{
+		Name:            "Minimum Feed Entropy",
+		Key:             "random/min_feed_entropy",
+		Description:     "The minimum amount of entropy before a entropy source is feed to the RNG, in bits.",
+		ExpertiseLevel:  config.ExpertiseLevelDeveloper,
+		OptType:         config.OptTypeInt,
+		DefaultValue:    256,
+		ValidationRegex: "^[0-9]{3,5}$",
+	})
+	if err != nil {
+		return err
+	}
+	minFeedEntropy = config.Concurrent.GetAsInt("random/min_feed_entropy", 256)
+
+	err = config.Register(&config.Option{
+		Name:            "Reseed after x seconds",
+		Key:             "random/reseed_after_seconds",
+		Description:     "Number of seconds until reseed",
+		ExpertiseLevel:  config.ExpertiseLevelDeveloper,
+		OptType:         config.OptTypeInt,
+		DefaultValue:    360, // ten minutes
+		ValidationRegex: "^[1-9][0-9]{1,5}$",
+	})
+	if err != nil {
+		return err
+	}
+	reseedAfterSeconds = config.Concurrent.GetAsInt("random/reseed_after_seconds", 360)
+
+	err = config.Register(&config.Option{
+		Name:            "Reseed after x bytes",
+		Key:             "random/reseed_after_bytes",
+		Description:     "Number of fetched bytes until reseed",
+		ExpertiseLevel:  config.ExpertiseLevelDeveloper,
+		OptType:         config.OptTypeInt,
+		DefaultValue:    1000000, // one megabyte
+		ValidationRegex: "^[1-9][0-9]{2,9}$",
+	})
+	if err != nil {
+		return err
+	}
+	reseedAfterBytes = config.GetAsInt("random/reseed_after_bytes", 1000000)
+
 	return nil
 }
 
@@ -73,7 +118,3 @@ func Start() (err error) {
 
 	return nil
 }
-
-func stop() error {
-	return nil
-}

crypto/random/rng_test.go

@@ -7,21 +7,34 @@ import (
 )
 
 func init() {
-	prep()
-	Start()
+	err := prep()
+	if err != nil {
+		panic(err)
+	}
+
+	err = Start()
+	if err != nil {
+		panic(err)
+	}
 }
 
 func TestRNG(t *testing.T) {
 	key := make([]byte, 16)
 
-	config.SetConfigOption("random.rng_cipher", "aes")
-	_, err := newCipher(key)
+	err := config.SetConfigOption("random/rng_cipher", "aes")
+	if err != nil {
+		t.Errorf("failed to set random/rng_cipher config: %s", err)
+	}
+	_, err = newCipher(key)
 	if err != nil {
 		t.Errorf("failed to create aes cipher: %s", err)
 	}
 	rng.Reseed(key)
 
-	config.SetConfigOption("random.rng_cipher", "serpent")
+	err = config.SetConfigOption("random/rng_cipher", "serpent")
+	if err != nil {
+		t.Errorf("failed to set random/rng_cipher config: %s", err)
+	}
 	_, err = newCipher(key)
 	if err != nil {
 		t.Errorf("failed to create serpent cipher: %s", err)

crypto/random/test/main.go

@@ -55,7 +55,10 @@ func main() {
 	switch os.Args[1] {
 	case "fortuna":
 
-		random.Start()
+		err := random.Start()
+		if err != nil {
+			panic(err)
+		}
 
 		for {
 			b, err := random.Bytes(64)