Go DevOps Vault Initialization and Keys Security

 1type AESGCMBarrier struct {
 2    backend physical.Backend
 3
 4    l      sync.RWMutex
 5    sealed bool
 6
 7    // keyring is used to maintain all of the encryption keys, including
 8    // the active key used for encryption, but also prior keys to allow
 9    // decryption of keys encrypted under previous terms.
10    keyring *Keyring
11
12    // cache is used to reduce the number of AEAD constructions we do
13    cache     map[uint32]cipher.AEAD
14    cacheLock sync.RWMutex
15
16    // currentAESGCMVersionByte is prefixed to a message to allow for
17    // future versioning of barrier implementations. It's var instead
18    // of const to allow for testing
19    currentAESGCMVersionByte byte
20
21    initialized atomic.Bool
22}

1// vault/init.go
2// BarrierKey is master key. barrierKeyShares is only used for testing. 
3barrierKey, barrierKeyShares, err := c.generateShares(barrierConfig)

 1func (b *AESGCMBarrier) Initialize(ctx context.Context, key, sealKey []byte, reader io.Reader) error {
 2    // ...
 3    // Generate encryption key
 4    encrypt, err := b.GenerateKey(reader)
 5    if err != nil {
 6        return errwrap.Wrapf("failed to generate encryption key: {{err}}", err)
 7    }
 8
 9    // Create a new keyring, install the keys
10    keyring := NewKeyring()
11    keyring = keyring.SetMasterKey(key)
12    keyring, err = keyring.AddKey(&Key{
13        Term:    1,
14        Version: 1,
15        Value:   encrypt,
16    })
17    if err != nil {
18        return errwrap.Wrapf("failed to create keyring: {{err}}", err)
19    }
20
21    err = b.persistKeyring(ctx, keyring)
22    if err != nil {
23        return err
24    }
25
26    // ...
27}

1type Keyring struct {
2	masterKey  []byte
3	keys       map[uint32]*Key
4	activeTerm uint32
5}

 1func (b *AESGCMBarrier) persistKeyring(ctx context.Context, keyring *Keyring) error {
 2    // Create the keyring entry
 3    keyringBuf, err := keyring.Serialize()
 4    defer memzero(keyringBuf)
 5    if err != nil {
 6        return errwrap.Wrapf("failed to serialize keyring: {{err}}", err)
 7    }
 8
 9    // Create the AES-GCM
10    gcm, err := b.aeadFromKey(keyring.MasterKey())
11    if err != nil {
12        return err
13    }
14
15    // Encrypt the barrier init value
16    value, err := b.encrypt(keyringPath, initialKeyTerm, gcm, keyringBuf)
17    if err != nil {
18        return err
19    }
20
21    // Create the keyring physical entry
22    pe := &physical.Entry{
23        Key:   keyringPath,
24        Value: value,
25    }
26    if err := b.backend.Put(ctx, pe); err != nil {
27        return errwrap.Wrapf("failed to persist keyring: {{err}}", err)
28    }
29
30    // Serialize the master key value
31    key := &Key{
32        Term:    1,
33        Version: 1,
34        Value:   keyring.MasterKey(),
35    }
36    keyBuf, err := key.Serialize()
37    defer memzero(keyBuf)
38    if err != nil {
39        return errwrap.Wrapf("failed to serialize master key: {{err}}", err)
40    }
41
42    // Encrypt the master key
43    activeKey := keyring.ActiveKey()
44    aead, err := b.aeadFromKey(activeKey.Value)
45    if err != nil {
46        return err
47    }
48    value, err = b.encrypt(masterKeyPath, activeKey.Term, aead, keyBuf)
49    if err != nil {
50        return err
51    }
52
53    // Update the masterKeyPath for standby instances
54    pe = &physical.Entry{
55        Key:   masterKeyPath,
56        Value: value,
57    }
58    if err := b.backend.Put(ctx, pe); err != nil {
59        return errwrap.Wrapf("failed to persist master key: {{err}}", err)
60    }
61    return nil
62}

 1// vault/init.go
 2switch c.seal.StoredKeysSupported() {
 3    case seal.StoredKeysSupportedShamirMaster:
 4        // store the master key(barrierKey)
 5		keysToStore := [][]byte{barrierKey}
 6		if err := c.seal.GetAccess().Wrapper.(*aeadwrapper.ShamirWrapper).SetAESGCMKeyBytes(sealKey); err != nil {
 7			c.logger.Error("failed to set seal key", "error", err)
 8			return nil, errwrap.Wrapf("failed to set seal key: {{err}}", err)
 9		}
10		if err := c.seal.SetStoredKeys(ctx, keysToStore); err != nil {
11			c.logger.Error("failed to store keys", "error", err)
12			return nil, errwrap.Wrapf("failed to store keys: {{err}}", err)
13		}
14		results.SecretShares = sealKeyShares
15	case seal.StoredKeysSupportedGeneric:
16		keysToStore := [][]byte{barrierKey}
17		if err := c.seal.SetStoredKeys(ctx, keysToStore); err != nil {
18			c.logger.Error("failed to store keys", "error", err)
19			return nil, errwrap.Wrapf("failed to store keys: {{err}}", err)
20		}
21	default:
22		// We don't support initializing an old-style Shamir seal anymore, so
23		// this case is only reachable by tests.
24		results.SecretShares = barrierKeyShares
25	}

 1const charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
 2const csLen = byte(len(charset))
 3
 4// Resulting entropy is ~5.95 bits/character.
 5func RandomWithReader(length int, reader io.Reader) (string, error) {
 6    if length == 0 {
 7        return "", nil
 8    }
 9    output := make([]byte, 0, length)
10
11    // Request a bit more than length to reduce the chance
12    // of needing more than one batch of random bytes
13    batchSize := length + length/4
14
15    for {
16        buf, err := uuid.GenerateRandomBytesWithReader(batchSize, reader)
17        if err != nil {
18            return "", err
19        }
20
21        for _, b := range buf {
22            // Avoid bias by using a value range that's a multiple of 62
23            if b < (csLen * 4) {
24                output = append(output, charset[b%csLen])
25
26                if len(output) == length {
27                    return string(output), nil
28                }
29            }
30        }
31    }
32}