Refactor enforced/expected PCRs (#553)

* Merge enforced and expected measurements

* Update measurement generation to new format

* Write expected measurements hex encoded by default

* Allow hex or base64 encoded expected measurements

* Allow hex or base64 encoded clusterID

* Allow security upgrades to warnOnly flag

* Upload signed measurements in JSON format

* Fetch measurements either from JSON or YAML

* Use yaml.v3 instead of yaml.v2

* Error on invalid enforced selection

* Add placeholder measurements to config

* Update e2e test to new measurement format

Signed-off-by: Daniel Weiße <dw@edgeless.systems>

cli/internal/cloudcmd/upgrade.go

@@ -112,6 +112,13 @@ func (u *Upgrader) updateMeasurements(ctx context.Context, newMeasurements measu
 		return nil
 	}
 
+	// don't allow potential security downgrades by setting the warnOnly flag to true
+	for k, newM := range newMeasurements {
+		if currentM, ok := currentMeasurements[k]; ok && !currentM.WarnOnly && newM.WarnOnly {
+			return fmt.Errorf("setting enforced measurement %d to warn only: not allowed", k)
+		}
+	}
+
 	// backup of previous measurements
 	existingConf.Data["oldMeasurements"] = existingConf.Data[constants.MeasurementsFilename]
 

cli/internal/cloudcmd/upgrade_test.go

@@ -33,12 +33,12 @@ func TestUpdateMeasurements(t *testing.T) {
 			updater: &stubMeasurementsUpdater{
 				oldMeasurements: &corev1.ConfigMap{
 					Data: map[string]string{
-						constants.MeasurementsFilename: `{"0":"AAAAAA=="}`,
+						constants.MeasurementsFilename: `{"0":{"expected":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA","warnOnly":false}}`,
 					},
 				},
 			},
 			newMeasurements: measurements.M{
-				0: []byte("1"),
+				0: measurements.WithAllBytes(0xBB, false),
 			},
 			wantUpdate: true,
 		},
@@ -46,14 +46,40 @@ func TestUpdateMeasurements(t *testing.T) {
 			updater: &stubMeasurementsUpdater{
 				oldMeasurements: &corev1.ConfigMap{
 					Data: map[string]string{
-						constants.MeasurementsFilename: `{"0":"MQ=="}`,
+						constants.MeasurementsFilename: `{"0":{"expected":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA","warnOnly":false}}`,
 					},
 				},
 			},
 			newMeasurements: measurements.M{
-				0: []byte("1"),
+				0: measurements.WithAllBytes(0xAA, false),
 			},
 		},
+		"trying to set warnOnly to true results in error": {
+			updater: &stubMeasurementsUpdater{
+				oldMeasurements: &corev1.ConfigMap{
+					Data: map[string]string{
+						constants.MeasurementsFilename: `{"0":{"expected":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA","warnOnly":false}}`,
+					},
+				},
+			},
+			newMeasurements: measurements.M{
+				0: measurements.WithAllBytes(0xAA, true),
+			},
+			wantErr: true,
+		},
+		"setting warnOnly to false is allowed": {
+			updater: &stubMeasurementsUpdater{
+				oldMeasurements: &corev1.ConfigMap{
+					Data: map[string]string{
+						constants.MeasurementsFilename: `{"0":{"expected":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA","warnOnly":true}}`,
+					},
+				},
+			},
+			newMeasurements: measurements.M{
+				0: measurements.WithAllBytes(0xAA, false),
+			},
+			wantUpdate: true,
+		},
 		"getCurrent error": {
 			updater: &stubMeasurementsUpdater{getErr: someErr},
 			wantErr: true,
@@ -62,7 +88,7 @@ func TestUpdateMeasurements(t *testing.T) {
 			updater: &stubMeasurementsUpdater{
 				oldMeasurements: &corev1.ConfigMap{
 					Data: map[string]string{
-						constants.MeasurementsFilename: `{"0":"AAAAAA=="}`,
+						constants.MeasurementsFilename: `{"0":{"expected":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA","warnOnly":false}}`,
 					},
 				},
 				updateErr: someErr,
@@ -82,7 +108,7 @@ func TestUpdateMeasurements(t *testing.T) {
 
 			err := upgrader.updateMeasurements(context.Background(), tc.newMeasurements)
 			if tc.wantErr {
-				assert.ErrorIs(err, someErr)
+				assert.Error(err)
 				return
 			}
 

cli/internal/cloudcmd/validators.go

@@ -20,17 +20,16 @@ import (
 	"github.com/edgelesssys/constellation/v2/internal/attestation/gcp"
 	"github.com/edgelesssys/constellation/v2/internal/attestation/measurements"
 	"github.com/edgelesssys/constellation/v2/internal/attestation/qemu"
-	"github.com/edgelesssys/constellation/v2/internal/attestation/vtpm"
 	"github.com/edgelesssys/constellation/v2/internal/cloud/cloudprovider"
 	"github.com/edgelesssys/constellation/v2/internal/config"
 	"github.com/spf13/cobra"
+	"go.uber.org/multierr"
 )
 
 // Validator validates Platform Configuration Registers (PCRs).
 type Validator struct {
 	provider           cloudprovider.Provider
 	pcrs               measurements.M
-	enforcedPCRs       []uint32
 	idkeydigest        []byte
 	enforceIDKeyDigest bool
 	azureCVM           bool
@@ -65,41 +64,44 @@ func NewValidator(provider cloudprovider.Provider, conf *config.Config) (*Valida
 
 // UpdateInitPCRs sets the owner and cluster PCR values.
 func (v *Validator) UpdateInitPCRs(ownerID, clusterID string) error {
-	if err := v.updatePCR(uint32(vtpm.PCRIndexOwnerID), ownerID); err != nil {
+	if err := v.updatePCR(uint32(measurements.PCRIndexOwnerID), ownerID); err != nil {
 		return err
 	}
-	return v.updatePCR(uint32(vtpm.PCRIndexClusterID), clusterID)
+	return v.updatePCR(uint32(measurements.PCRIndexClusterID), clusterID)
 }
 
-// updatePCR adds a new entry to the pcr map of v, or removes the key if the input is an empty string.
+// updatePCR adds a new entry to the measurements of v, or removes the key if the input is an empty string.
 //
-// When adding, the input is first decoded from base64.
+// When adding, the input is first decoded from hex or base64.
 // We then calculate the expected PCR by hashing the input using SHA256,
 // appending expected PCR for initialization, and then hashing once more.
 func (v *Validator) updatePCR(pcrIndex uint32, encoded string) error {
 	if encoded == "" {
 		delete(v.pcrs, pcrIndex)
-
-		// remove enforced PCR if it exists
-		for i, enforcedIdx := range v.enforcedPCRs {
-			if enforcedIdx == pcrIndex {
-				v.enforcedPCRs[i] = v.enforcedPCRs[len(v.enforcedPCRs)-1]
-				v.enforcedPCRs = v.enforcedPCRs[:len(v.enforcedPCRs)-1]
-				break
-			}
-		}
-
 		return nil
 	}
-	decoded, err := base64.StdEncoding.DecodeString(encoded)
+
+	// decode from hex or base64
+	decoded, err := hex.DecodeString(encoded)
 	if err != nil {
-		return fmt.Errorf("input [%s] is not base64 encoded: %w", encoded, err)
+		hexErr := err
+		decoded, err = base64.StdEncoding.DecodeString(encoded)
+		if err != nil {
+			return multierr.Append(
+				fmt.Errorf("input [%s] is not hex encoded: %w", encoded, hexErr),
+				fmt.Errorf("input [%s] is not base64 encoded: %w", encoded, err),
+			)
+		}
 	}
 	// new_pcr_value := hash(old_pcr_value || data_to_extend)
 	// Since we use the TPM2_PCR_Event call to extend the PCR, data_to_extend is the hash of our input
 	hashedInput := sha256.Sum256(decoded)
-	expectedPcr := sha256.Sum256(append(v.pcrs[pcrIndex], hashedInput[:]...))
-	v.pcrs[pcrIndex] = expectedPcr[:]
+	oldExpected := v.pcrs[pcrIndex].Expected
+	expectedPcr := sha256.Sum256(append(oldExpected[:], hashedInput[:]...))
+	v.pcrs[pcrIndex] = measurements.Measurement{
+		Expected: expectedPcr,
+		WarnOnly: v.pcrs[pcrIndex].WarnOnly,
+	}
 	return nil
 }
 
@@ -107,35 +109,27 @@ func (v *Validator) setPCRs(config *config.Config) error {
 	switch v.provider {
 	case cloudprovider.AWS:
 		awsPCRs := config.Provider.AWS.Measurements
-		enforcedPCRs := config.Provider.AWS.EnforcedMeasurements
-		if err := v.checkPCRs(awsPCRs, enforcedPCRs); err != nil {
-			return err
+		if len(awsPCRs) == 0 {
+			return errors.New("no expected measurement provided")
 		}
-		v.enforcedPCRs = enforcedPCRs
 		v.pcrs = awsPCRs
 	case cloudprovider.Azure:
 		azurePCRs := config.Provider.Azure.Measurements
-		enforcedPCRs := config.Provider.Azure.EnforcedMeasurements
-		if err := v.checkPCRs(azurePCRs, enforcedPCRs); err != nil {
-			return err
+		if len(azurePCRs) == 0 {
+			return errors.New("no expected measurement provided")
 		}
-		v.enforcedPCRs = enforcedPCRs
 		v.pcrs = azurePCRs
 	case cloudprovider.GCP:
 		gcpPCRs := config.Provider.GCP.Measurements
-		enforcedPCRs := config.Provider.GCP.EnforcedMeasurements
-		if err := v.checkPCRs(gcpPCRs, enforcedPCRs); err != nil {
-			return err
+		if len(gcpPCRs) == 0 {
+			return errors.New("no expected measurement provided")
 		}
-		v.enforcedPCRs = enforcedPCRs
 		v.pcrs = gcpPCRs
 	case cloudprovider.QEMU:
 		qemuPCRs := config.Provider.QEMU.Measurements
-		enforcedPCRs := config.Provider.QEMU.EnforcedMeasurements
-		if err := v.checkPCRs(qemuPCRs, enforcedPCRs); err != nil {
-			return err
+		if len(qemuPCRs) == 0 {
+			return errors.New("no expected measurement provided")
 		}
-		v.enforcedPCRs = enforcedPCRs
 		v.pcrs = qemuPCRs
 	}
 	return nil
@@ -156,37 +150,20 @@ func (v *Validator) updateValidator(cmd *cobra.Command) {
 	log := warnLogger{cmd: cmd}
 	switch v.provider {
 	case cloudprovider.GCP:
-		v.validator = gcp.NewValidator(v.pcrs, v.enforcedPCRs, log)
+		v.validator = gcp.NewValidator(v.pcrs, log)
 	case cloudprovider.Azure:
 		if v.azureCVM {
-			v.validator = snp.NewValidator(v.pcrs, v.enforcedPCRs, v.idkeydigest, v.enforceIDKeyDigest, log)
+			v.validator = snp.NewValidator(v.pcrs, v.idkeydigest, v.enforceIDKeyDigest, log)
 		} else {
-			v.validator = trustedlaunch.NewValidator(v.pcrs, v.enforcedPCRs, log)
+			v.validator = trustedlaunch.NewValidator(v.pcrs, log)
 		}
 	case cloudprovider.AWS:
-		v.validator = aws.NewValidator(v.pcrs, v.enforcedPCRs, log)
+		v.validator = aws.NewValidator(v.pcrs, log)
 	case cloudprovider.QEMU:
-		v.validator = qemu.NewValidator(v.pcrs, v.enforcedPCRs, log)
+		v.validator = qemu.NewValidator(v.pcrs, log)
 	}
 }
 
-func (v *Validator) checkPCRs(pcrs measurements.M, enforcedPCRs []uint32) error {
-	if len(pcrs) == 0 {
-		return errors.New("no PCR values provided")
-	}
-	for k, v := range pcrs {
-		if len(v) != 32 {
-			return fmt.Errorf("bad config: PCR[%d]: expected length: %d, but got: %d", k, 32, len(v))
-		}
-	}
-	for _, v := range enforcedPCRs {
-		if _, ok := pcrs[v]; !ok {
-			return fmt.Errorf("bad config: PCR[%d] is enforced, but no expected measurement is provided", v)
-		}
-	}
-	return nil
-}
-
 // warnLogger implements logging of warnings for validators.
 type warnLogger struct {
 	cmd *cobra.Command

cli/internal/cloudcmd/validators_test.go

@@ -7,9 +7,9 @@ SPDX-License-Identifier: AGPL-3.0-only
 package cloudcmd
 
 import (
-	"bytes"
 	"crypto/sha256"
 	"encoding/base64"
+	"encoding/hex"
 	"testing"
 
 	"github.com/edgelesssys/constellation/v2/internal/atls"
@@ -18,7 +18,6 @@ import (
 	"github.com/edgelesssys/constellation/v2/internal/attestation/gcp"
 	"github.com/edgelesssys/constellation/v2/internal/attestation/measurements"
 	"github.com/edgelesssys/constellation/v2/internal/attestation/qemu"
-	"github.com/edgelesssys/constellation/v2/internal/attestation/vtpm"
 	"github.com/edgelesssys/constellation/v2/internal/cloud/cloudprovider"
 	"github.com/edgelesssys/constellation/v2/internal/config"
 	"github.com/spf13/cobra"
@@ -27,12 +26,12 @@ import (
 
 func TestNewValidator(t *testing.T) {
 	testPCRs := measurements.M{
-		0: measurements.PCRWithAllBytes(0x00),
-		1: measurements.PCRWithAllBytes(0xFF),
-		2: measurements.PCRWithAllBytes(0x00),
-		3: measurements.PCRWithAllBytes(0xFF),
-		4: measurements.PCRWithAllBytes(0x00),
-		5: measurements.PCRWithAllBytes(0x00),
+		0: measurements.WithAllBytes(0x00, false),
+		1: measurements.WithAllBytes(0xFF, false),
+		2: measurements.WithAllBytes(0x00, false),
+		3: measurements.WithAllBytes(0xFF, false),
+		4: measurements.WithAllBytes(0x00, false),
+		5: measurements.WithAllBytes(0x00, false),
 	}
 
 	testCases := map[string]struct {
@@ -67,13 +66,6 @@ func TestNewValidator(t *testing.T) {
 			pcrs:     measurements.M{},
 			wantErr:  true,
 		},
-		"invalid pcr length": {
-			provider: cloudprovider.GCP,
-			pcrs: measurements.M{
-				0: bytes.Repeat([]byte{0x00}, 31),
-			},
-			wantErr: true,
-		},
 		"unknown provider": {
 			provider: cloudprovider.Unknown,
 			pcrs:     testPCRs,
@@ -126,19 +118,19 @@ func TestNewValidator(t *testing.T) {
 func TestValidatorV(t *testing.T) {
 	newTestPCRs := func() measurements.M {
 		return measurements.M{
-			0:  measurements.PCRWithAllBytes(0x00),
-			1:  measurements.PCRWithAllBytes(0x00),
-			2:  measurements.PCRWithAllBytes(0x00),
-			3:  measurements.PCRWithAllBytes(0x00),
-			4:  measurements.PCRWithAllBytes(0x00),
-			5:  measurements.PCRWithAllBytes(0x00),
-			6:  measurements.PCRWithAllBytes(0x00),
-			7:  measurements.PCRWithAllBytes(0x00),
-			8:  measurements.PCRWithAllBytes(0x00),
-			9:  measurements.PCRWithAllBytes(0x00),
-			10: measurements.PCRWithAllBytes(0x00),
-			11: measurements.PCRWithAllBytes(0x00),
-			12: measurements.PCRWithAllBytes(0x00),
+			0:  measurements.WithAllBytes(0x00, true),
+			1:  measurements.WithAllBytes(0x00, true),
+			2:  measurements.WithAllBytes(0x00, true),
+			3:  measurements.WithAllBytes(0x00, true),
+			4:  measurements.WithAllBytes(0x00, true),
+			5:  measurements.WithAllBytes(0x00, true),
+			6:  measurements.WithAllBytes(0x00, true),
+			7:  measurements.WithAllBytes(0x00, true),
+			8:  measurements.WithAllBytes(0x00, true),
+			9:  measurements.WithAllBytes(0x00, true),
+			10: measurements.WithAllBytes(0x00, true),
+			11: measurements.WithAllBytes(0x00, true),
+			12: measurements.WithAllBytes(0x00, true),
 		}
 	}
 
@@ -151,23 +143,23 @@ func TestValidatorV(t *testing.T) {
 		"gcp": {
 			provider: cloudprovider.GCP,
 			pcrs:     newTestPCRs(),
-			wantVs:   gcp.NewValidator(newTestPCRs(), nil, nil),
+			wantVs:   gcp.NewValidator(newTestPCRs(), nil),
 		},
 		"azure cvm": {
 			provider: cloudprovider.Azure,
 			pcrs:     newTestPCRs(),
-			wantVs:   snp.NewValidator(newTestPCRs(), nil, nil, false, nil),
+			wantVs:   snp.NewValidator(newTestPCRs(), nil, false, nil),
 			azureCVM: true,
 		},
 		"azure trusted launch": {
 			provider: cloudprovider.Azure,
 			pcrs:     newTestPCRs(),
-			wantVs:   trustedlaunch.NewValidator(newTestPCRs(), nil, nil),
+			wantVs:   trustedlaunch.NewValidator(newTestPCRs(), nil),
 		},
 		"qemu": {
 			provider: cloudprovider.QEMU,
 			pcrs:     newTestPCRs(),
-			wantVs:   qemu.NewValidator(newTestPCRs(), nil, nil),
+			wantVs:   qemu.NewValidator(newTestPCRs(), nil),
 		},
 	}
 
@@ -185,37 +177,37 @@ func TestValidatorV(t *testing.T) {
 }
 
 func TestValidatorUpdateInitPCRs(t *testing.T) {
-	zero := []byte("00000000000000000000000000000000")
-	one := []byte("11111111111111111111111111111111")
-	one64 := base64.StdEncoding.EncodeToString(one)
-	oneHash := sha256.Sum256(one)
-	pcrZeroUpdatedOne := sha256.Sum256(append(zero, oneHash[:]...))
-	newTestPCRs := func() map[uint32][]byte {
-		return map[uint32][]byte{
-			0:  zero,
-			1:  zero,
-			2:  zero,
-			3:  zero,
-			4:  zero,
-			5:  zero,
-			6:  zero,
-			7:  zero,
-			8:  zero,
-			9:  zero,
-			10: zero,
-			11: zero,
-			12: zero,
-			13: zero,
-			14: zero,
-			15: zero,
-			16: zero,
-			17: one,
-			18: one,
-			19: one,
-			20: one,
-			21: one,
-			22: one,
-			23: zero,
+	zero := measurements.WithAllBytes(0x00, true)
+	one := measurements.WithAllBytes(0x11, true)
+	one64 := base64.StdEncoding.EncodeToString(one.Expected[:])
+	oneHash := sha256.Sum256(one.Expected[:])
+	pcrZeroUpdatedOne := sha256.Sum256(append(zero.Expected[:], oneHash[:]...))
+	newTestPCRs := func() measurements.M {
+		return measurements.M{
+			0:  measurements.WithAllBytes(0x00, true),
+			1:  measurements.WithAllBytes(0x00, true),
+			2:  measurements.WithAllBytes(0x00, true),
+			3:  measurements.WithAllBytes(0x00, true),
+			4:  measurements.WithAllBytes(0x00, true),
+			5:  measurements.WithAllBytes(0x00, true),
+			6:  measurements.WithAllBytes(0x00, true),
+			7:  measurements.WithAllBytes(0x00, true),
+			8:  measurements.WithAllBytes(0x00, true),
+			9:  measurements.WithAllBytes(0x00, true),
+			10: measurements.WithAllBytes(0x00, true),
+			11: measurements.WithAllBytes(0x00, true),
+			12: measurements.WithAllBytes(0x00, true),
+			13: measurements.WithAllBytes(0x00, true),
+			14: measurements.WithAllBytes(0x00, true),
+			15: measurements.WithAllBytes(0x00, true),
+			16: measurements.WithAllBytes(0x00, true),
+			17: measurements.WithAllBytes(0x11, true),
+			18: measurements.WithAllBytes(0x11, true),
+			19: measurements.WithAllBytes(0x11, true),
+			20: measurements.WithAllBytes(0x11, true),
+			21: measurements.WithAllBytes(0x11, true),
+			22: measurements.WithAllBytes(0x11, true),
+			23: measurements.WithAllBytes(0x00, true),
 		}
 	}
 
@@ -285,25 +277,25 @@ func TestValidatorUpdateInitPCRs(t *testing.T) {
 			assert.NoError(err)
 			for i := 0; i < len(tc.pcrs); i++ {
 				switch {
-				case i == int(vtpm.PCRIndexClusterID) && tc.clusterID == "":
+				case i == int(measurements.PCRIndexClusterID) && tc.clusterID == "":
 					// should be deleted
 					_, ok := validators.pcrs[uint32(i)]
 					assert.False(ok)
 
-				case i == int(vtpm.PCRIndexClusterID):
+				case i == int(measurements.PCRIndexClusterID):
 					pcr, ok := validators.pcrs[uint32(i)]
 					assert.True(ok)
-					assert.Equal(pcrZeroUpdatedOne[:], pcr)
+					assert.Equal(pcrZeroUpdatedOne, pcr.Expected)
 
-				case i == int(vtpm.PCRIndexOwnerID) && tc.ownerID == "":
+				case i == int(measurements.PCRIndexOwnerID) && tc.ownerID == "":
 					// should be deleted
 					_, ok := validators.pcrs[uint32(i)]
 					assert.False(ok)
 
-				case i == int(vtpm.PCRIndexOwnerID):
+				case i == int(measurements.PCRIndexOwnerID):
 					pcr, ok := validators.pcrs[uint32(i)]
 					assert.True(ok)
-					assert.Equal(pcrZeroUpdatedOne[:], pcr)
+					assert.Equal(pcrZeroUpdatedOne, pcr.Expected)
 
 				default:
 					if i >= 17 && i <= 22 {
@@ -320,8 +312,8 @@ func TestValidatorUpdateInitPCRs(t *testing.T) {
 func TestUpdatePCR(t *testing.T) {
 	emptyMap := measurements.M{}
 	defaultMap := measurements.M{
-		0: measurements.PCRWithAllBytes(0xAA),
-		1: measurements.PCRWithAllBytes(0xBB),
+		0: measurements.WithAllBytes(0xAA, false),
+		1: measurements.WithAllBytes(0xBB, false),
 	}
 
 	testCases := map[string]struct {
@@ -359,6 +351,20 @@ func TestUpdatePCR(t *testing.T) {
 			wantEntries: len(defaultMap) + 1,
 			wantErr:     false,
 		},
+		"hex input, empty map": {
+			pcrMap:      emptyMap,
+			pcrIndex:    10,
+			encoded:     hex.EncodeToString([]byte("Constellation")),
+			wantEntries: 1,
+			wantErr:     false,
+		},
+		"hex input, default map": {
+			pcrMap:      defaultMap,
+			pcrIndex:    10,
+			encoded:     hex.EncodeToString([]byte("Constellation")),
+			wantEntries: len(defaultMap) + 1,
+			wantErr:     false,
+		},
 		"unencoded input, empty map": {
 			pcrMap:      emptyMap,
 			pcrIndex:    10,
@@ -403,9 +409,6 @@ func TestUpdatePCR(t *testing.T) {
 				assert.NoError(err)
 			}
 			assert.Len(pcrs, tc.wantEntries)
-			for _, v := range pcrs {
-				assert.Len(v, 32)
-			}
 		})
 	}
 }