AB#2316 Configurable enforced PCRs (#361)

* Add warnings for non enforced, untrusted PCRs

* Fix global state in Config PCR map

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

cli/internal/cloudcmd/validators.go

@@ -5,7 +5,6 @@ import (
 	"encoding/base64"
 	"errors"
 	"fmt"
-	"strings"
 
 	"github.com/edgelesssys/constellation/internal/atls"
 	"github.com/edgelesssys/constellation/internal/attestation/azure"
@@ -14,14 +13,14 @@ import (
 	"github.com/edgelesssys/constellation/internal/attestation/vtpm"
 	"github.com/edgelesssys/constellation/internal/cloud/cloudprovider"
 	"github.com/edgelesssys/constellation/internal/config"
+	"github.com/spf13/cobra"
 )
 
-const warningStr = "Warning: not verifying the Constellation cluster's %s measurements\n"
-
 type Validator struct {
-	provider  cloudprovider.Provider
-	pcrs      map[uint32][]byte
-	validator atls.Validator
+	provider     cloudprovider.Provider
+	pcrs         map[uint32][]byte
+	enforcedPCRs []uint32
+	validator    atls.Validator
 }
 
 func NewValidator(provider cloudprovider.Provider, config *config.Config) (*Validator, error) {
@@ -51,6 +50,16 @@ func (v *Validator) UpdateInitPCRs(ownerID, clusterID string) error {
 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)
@@ -69,29 +78,35 @@ func (v *Validator) setPCRs(config *config.Config) error {
 	switch v.provider {
 	case cloudprovider.GCP:
 		gcpPCRs := config.Provider.GCP.Measurements
-		if err := v.checkPCRs(gcpPCRs); err != nil {
+		enforcedPCRs := config.Provider.GCP.EnforcedMeasurements
+		if err := v.checkPCRs(gcpPCRs, enforcedPCRs); err != nil {
 			return err
 		}
+		v.enforcedPCRs = enforcedPCRs
 		v.pcrs = gcpPCRs
 	case cloudprovider.Azure:
 		azurePCRs := config.Provider.Azure.Measurements
-		if err := v.checkPCRs(azurePCRs); err != nil {
+		enforcedPCRs := config.Provider.Azure.EnforcedMeasurements
+		if err := v.checkPCRs(azurePCRs, enforcedPCRs); err != nil {
 			return err
 		}
+		v.enforcedPCRs = enforcedPCRs
 		v.pcrs = azurePCRs
 	case cloudprovider.QEMU:
 		qemuPCRs := config.Provider.QEMU.Measurements
-		if err := v.checkPCRs(qemuPCRs); err != nil {
+		enforcedPCRs := config.Provider.QEMU.EnforcedMeasurements
+		if err := v.checkPCRs(qemuPCRs, enforcedPCRs); err != nil {
 			return err
 		}
+		v.enforcedPCRs = enforcedPCRs
 		v.pcrs = qemuPCRs
 	}
 	return nil
 }
 
 // V returns the validator as atls.Validator.
-func (v *Validator) V() atls.Validator {
-	v.updateValidator()
+func (v *Validator) V(cmd *cobra.Command) atls.Validator {
+	v.updateValidator(cmd)
 	return v.validator
 }
 
@@ -100,60 +115,19 @@ func (v *Validator) PCRS() map[uint32][]byte {
 	return v.pcrs
 }
 
-func (v *Validator) updateValidator() {
+func (v *Validator) updateValidator(cmd *cobra.Command) {
 	switch v.provider {
 	case cloudprovider.GCP:
-		v.validator = gcp.NewValidator(v.pcrs)
+		v.validator = gcp.NewValidator(v.pcrs, v.enforcedPCRs)
 	case cloudprovider.Azure:
-		v.validator = azure.NewValidator(v.pcrs)
+		v.validator = azure.NewValidator(v.pcrs, v.enforcedPCRs)
 	case cloudprovider.QEMU:
-		v.validator = qemu.NewValidator(v.pcrs)
+		v.validator = qemu.NewValidator(v.pcrs, v.enforcedPCRs)
 	}
+	v.validator.AddLogger(warnLogger{cmd: cmd})
 }
 
-// Warnings returns warnings for the specifc PCR values that are not verified.
-//
-// PCR allocation inspired by https://link.springer.com/chapter/10.1007/978-1-4302-6584-9_12#Tab1
-func (v *Validator) Warnings() string {
-	sb := &strings.Builder{}
-
-	if v.pcrs[0] == nil || v.pcrs[1] == nil {
-		writeWarnFmt(sb, "BIOS")
-	}
-
-	if v.pcrs[2] == nil || v.pcrs[3] == nil {
-		writeWarnFmt(sb, "OPROM")
-	}
-
-	if v.pcrs[4] == nil || v.pcrs[5] == nil {
-		writeWarnFmt(sb, "MBR")
-	}
-
-	// GRUB measures kernel command line and initrd into pcrs 8 and 9
-	if v.pcrs[8] == nil {
-		writeWarnFmt(sb, "kernel command line")
-	}
-	if v.pcrs[9] == nil {
-		writeWarnFmt(sb, "initrd")
-	}
-
-	return sb.String()
-}
-
-// WarningsIncludeInit returns warnings for the specific PCR values that are not verified.
-// Warnings regarding the initialization are included.
-//
-// PCR allocation inspired by https://link.springer.com/chapter/10.1007/978-1-4302-6584-9_12#Tab1
-func (v *Validator) WarningsIncludeInit() string {
-	warnings := v.Warnings()
-	if v.pcrs[uint32(vtpm.PCRIndexOwnerID)] == nil || v.pcrs[uint32(vtpm.PCRIndexClusterID)] == nil {
-		warnings = warnings + fmt.Sprintf(warningStr, "initialization status")
-	}
-
-	return warnings
-}
-
-func (v *Validator) checkPCRs(pcrs map[uint32][]byte) error {
+func (v *Validator) checkPCRs(pcrs map[uint32][]byte, enforcedPCRs []uint32) error {
 	if len(pcrs) == 0 {
 		return errors.New("no PCR values provided")
 	}
@@ -162,13 +136,20 @@ func (v *Validator) checkPCRs(pcrs map[uint32][]byte) error {
 			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
 }
 
-func writeWarnFmt(sb *strings.Builder, args ...any) {
-	writeFmt(sb, warningStr, args...)
+// warnLogger implements logging of warnings for validators.
+type warnLogger struct {
+	cmd *cobra.Command
 }
 
-func writeFmt(sb *strings.Builder, fmtStr string, args ...any) {
-	sb.WriteString(fmt.Sprintf(fmtStr, args...))
+// Warnf prints a formatted warning from the validator.
+func (wl warnLogger) Warnf(fmtStr string, args ...interface{}) {
+	wl.cmd.PrintErrf("Warning: %s\n", fmt.Sprintf(fmtStr, args...))
 }

cli/internal/cloudcmd/validators_test.go

@@ -12,6 +12,7 @@ import (
 	"github.com/edgelesssys/constellation/internal/attestation/vtpm"
 	"github.com/edgelesssys/constellation/internal/cloud/cloudprovider"
 	"github.com/edgelesssys/constellation/internal/config"
+	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -93,172 +94,6 @@ func TestNewValidator(t *testing.T) {
 	}
 }
 
-func TestValidatorWarnings(t *testing.T) {
-	zero := []byte("00000000000000000000000000000000")
-
-	testCases := map[string]struct {
-		pcrs         map[uint32][]byte
-		wantWarnings []string
-		wantWInclude []string
-	}{
-		"no warnings": {
-			pcrs: 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,
-			},
-		},
-		"no warnings for missing non critical values": {
-			pcrs: map[uint32][]byte{
-				0:  zero,
-				1:  zero,
-				2:  zero,
-				3:  zero,
-				4:  zero,
-				5:  zero,
-				8:  zero,
-				9:  zero,
-				11: zero,
-				12: zero,
-			},
-		},
-		"warn for BIOS": {
-			pcrs: map[uint32][]byte{
-				0:  zero,
-				2:  zero,
-				3:  zero,
-				4:  zero,
-				5:  zero,
-				8:  zero,
-				9:  zero,
-				11: zero,
-				12: zero,
-			},
-			wantWarnings: []string{"BIOS"},
-		},
-		"warn for OPROM": {
-			pcrs: map[uint32][]byte{
-				0:  zero,
-				1:  zero,
-				3:  zero,
-				4:  zero,
-				5:  zero,
-				8:  zero,
-				9:  zero,
-				11: zero,
-				12: zero,
-			},
-			wantWarnings: []string{"OPROM"},
-		},
-		"warn for MBR": {
-			pcrs: map[uint32][]byte{
-				0:  zero,
-				1:  zero,
-				2:  zero,
-				3:  zero,
-				5:  zero,
-				8:  zero,
-				9:  zero,
-				11: zero,
-				12: zero,
-			},
-			wantWarnings: []string{"MBR"},
-		},
-		"warn for kernel": {
-			pcrs: map[uint32][]byte{
-				0:  zero,
-				1:  zero,
-				2:  zero,
-				3:  zero,
-				4:  zero,
-				5:  zero,
-				9:  zero,
-				11: zero,
-				12: zero,
-			},
-			wantWarnings: []string{"kernel"},
-		},
-		"warn for initrd": {
-			pcrs: map[uint32][]byte{
-				0:  zero,
-				1:  zero,
-				2:  zero,
-				3:  zero,
-				4:  zero,
-				5:  zero,
-				8:  zero,
-				11: zero,
-				12: zero,
-			},
-			wantWarnings: []string{"initrd"},
-		},
-		"warn for initialization": {
-			pcrs: map[uint32][]byte{
-				0:  zero,
-				1:  zero,
-				2:  zero,
-				3:  zero,
-				4:  zero,
-				5:  zero,
-				8:  zero,
-				9:  zero,
-				11: zero,
-			},
-			wantWInclude: []string{"initialization"},
-		},
-		"multi warning": {
-			pcrs: map[uint32][]byte{},
-			wantWarnings: []string{
-				"BIOS",
-				"OPROM",
-				"MBR",
-				"initrd",
-				"kernel",
-			},
-			wantWInclude: []string{"initialization"},
-		},
-	}
-
-	for name, tc := range testCases {
-		t.Run(name, func(t *testing.T) {
-			assert := assert.New(t)
-
-			validators := Validator{pcrs: tc.pcrs}
-
-			warnings := validators.Warnings()
-			warningsInclueInit := validators.WarningsIncludeInit()
-
-			if len(tc.wantWarnings) == 0 {
-				assert.Empty(warnings)
-			}
-			for _, w := range tc.wantWarnings {
-				assert.Contains(warnings, w)
-			}
-			for _, w := range tc.wantWarnings {
-				assert.Contains(warningsInclueInit, w)
-			}
-			if len(tc.wantWInclude) == 0 {
-				assert.Equal(len(warnings), len(warningsInclueInit))
-			} else {
-				assert.Greater(len(warningsInclueInit), len(warnings))
-			}
-			for _, w := range tc.wantWInclude {
-				assert.Contains(warningsInclueInit, w)
-			}
-		})
-	}
-}
-
 func TestValidatorV(t *testing.T) {
 	zero := []byte("00000000000000000000000000000000")
 	newTestPCRs := func() map[uint32][]byte {
@@ -287,17 +122,17 @@ func TestValidatorV(t *testing.T) {
 		"gcp": {
 			provider: cloudprovider.GCP,
 			pcrs:     newTestPCRs(),
-			wantVs:   gcp.NewValidator(newTestPCRs()),
+			wantVs:   gcp.NewValidator(newTestPCRs(), nil),
 		},
 		"azure": {
 			provider: cloudprovider.Azure,
 			pcrs:     newTestPCRs(),
-			wantVs:   azure.NewValidator(newTestPCRs()),
+			wantVs:   azure.NewValidator(newTestPCRs(), nil),
 		},
 		"qemu": {
 			provider: cloudprovider.QEMU,
 			pcrs:     newTestPCRs(),
-			wantVs:   qemu.NewValidator(newTestPCRs()),
+			wantVs:   qemu.NewValidator(newTestPCRs(), nil),
 		},
 	}
 
@@ -307,7 +142,7 @@ func TestValidatorV(t *testing.T) {
 
 			validators := &Validator{provider: tc.provider, pcrs: tc.pcrs}
 
-			resultValidator := validators.V()
+			resultValidator := validators.V(&cobra.Command{})
 
 			assert.Equal(tc.wantVs.OID(), resultValidator.OID())
 		})

cli/internal/cmd/init.go

@@ -54,7 +54,7 @@ func runInitialize(cmd *cobra.Command, args []string) error {
 	fileHandler := file.NewHandler(afero.NewOsFs())
 	serviceAccountCreator := cloudcmd.NewServiceAccountCreator()
 	newDialer := func(validator *cloudcmd.Validator) *dialer.Dialer {
-		return dialer.New(nil, validator.V(), &net.Dialer{})
+		return dialer.New(nil, validator.V(cmd), &net.Dialer{})
 	}
 	helmLoader := &helm.ChartLoader{}
 	return initialize(cmd, newDialer, serviceAccountCreator, fileHandler, helmLoader)
@@ -96,7 +96,6 @@ func initialize(cmd *cobra.Command, newDialer func(validator *cloudcmd.Validator
 	if err != nil {
 		return err
 	}
-	cmd.Print(validator.WarningsIncludeInit())
 
 	cmd.Println("Creating service account ...")
 	serviceAccount, stat, err := serviceAccCreator.Create(cmd.Context(), stat, config)
@@ -135,6 +134,7 @@ func initialize(cmd *cobra.Command, newDialer func(validator *cloudcmd.Validator
 		KubernetesVersion:      config.KubernetesVersion,
 		SshUserKeys:            ssh.ToProtoSlice(sshUsers),
 		HelmDeployments:        helmDeployments,
+		EnforcedPcrs:           getEnforcedMeasurements(provider, config),
 	}
 	resp, err := initCall(cmd.Context(), newDialer(validator), stat.BootstrapperHost, req)
 	if err != nil {
@@ -214,6 +214,19 @@ func writeRow(wr io.Writer, col1 string, col2 string) {
 	fmt.Fprint(wr, col1, "\t", col2, "\n")
 }
 
+func getEnforcedMeasurements(provider cloudprovider.Provider, config *config.Config) []uint32 {
+	switch provider {
+	case cloudprovider.Azure:
+		return config.Provider.Azure.EnforcedMeasurements
+	case cloudprovider.GCP:
+		return config.Provider.GCP.EnforcedMeasurements
+	case cloudprovider.QEMU:
+		return config.Provider.QEMU.EnforcedMeasurements
+	default:
+		return nil
+	}
+}
+
 // evalFlagArgs gets the flag values and does preprocessing of these values like
 // reading the content from file path flags and deriving other values from flag combinations.
 func evalFlagArgs(cmd *cobra.Command, fileHandler file.Handler) (initFlags, error) {

cli/internal/cmd/init_test.go

@@ -14,6 +14,7 @@ import (
 
 	"github.com/edgelesssys/constellation/bootstrapper/initproto"
 	"github.com/edgelesssys/constellation/cli/internal/cloudcmd"
+	"github.com/edgelesssys/constellation/internal/attestation/vtpm"
 	"github.com/edgelesssys/constellation/internal/cloud/cloudprovider"
 	"github.com/edgelesssys/constellation/internal/cloud/cloudtypes"
 	"github.com/edgelesssys/constellation/internal/config"
@@ -158,9 +159,12 @@ func TestInitialize(t *testing.T) {
 			cmd.SetOut(&out)
 			var errOut bytes.Buffer
 			cmd.SetErr(&errOut)
-			cmd.Flags().String("config", "", "") // register persistent flag manually
+			cmd.Flags().String("config", constants.ConfigFilename, "") // register persistent flag manually
 			fs := afero.NewMemMapFs()
 			fileHandler := file.NewHandler(fs)
+
+			config := defaultConfigWithExpectedMeasurements(t, cloudprovider.FromString(tc.existingState.CloudProvider))
+			require.NoError(fileHandler.WriteYAML(constants.ConfigFilename, config))
 			require.NoError(fileHandler.WriteJSON(constants.StateFilename, tc.existingState, file.OptNone))
 			require.NoError(cmd.Flags().Set("autoscale", strconv.FormatBool(tc.setAutoscaleFlag)))
 
@@ -476,6 +480,8 @@ func (v *testValidator) Validate(attDoc []byte, nonce []byte) ([]byte, error) {
 	return attestation.UserData, nil
 }
 
+func (v *testValidator) AddLogger(vtpm.WarnLogger) {}
+
 type testIssuer struct {
 	oid.Getter
 	pcrs map[uint32][]byte
@@ -506,3 +512,27 @@ func (s *stubInitServer) Init(ctx context.Context, req *initproto.InitRequest) (
 	s.activateAutoscalingNodeGroups = req.AutoscalingNodeGroups
 	return s.initResp, s.initErr
 }
+
+func defaultConfigWithExpectedMeasurements(t *testing.T, csp cloudprovider.Provider) *config.Config {
+	t.Helper()
+	config := config.Default()
+
+	config.Provider.Azure.SubscriptionID = "01234567-0123-0123-0123-0123456789ab"
+	config.Provider.Azure.TenantID = "01234567-0123-0123-0123-0123456789ab"
+	config.Provider.Azure.Location = "test-location"
+	config.Provider.Azure.UserAssignedIdentity = "test-identity"
+	config.Provider.Azure.Measurements[8] = []byte("00000000000000000000000000000000")
+	config.Provider.Azure.Measurements[9] = []byte("11111111111111111111111111111111")
+
+	config.Provider.GCP.Region = "test-region"
+	config.Provider.GCP.Project = "test-project"
+	config.Provider.GCP.Zone = "test-zone"
+	config.Provider.GCP.Measurements[8] = []byte("00000000000000000000000000000000")
+	config.Provider.GCP.Measurements[9] = []byte("11111111111111111111111111111111")
+
+	config.Provider.QEMU.Measurements[8] = []byte("00000000000000000000000000000000")
+	config.Provider.QEMU.Measurements[9] = []byte("11111111111111111111111111111111")
+
+	config.RemoveProviderExcept(csp)
+	return config
+}

cli/internal/cmd/recover.go

@@ -72,9 +72,8 @@ func recover(cmd *cobra.Command, fileHandler file.Handler, recoveryClient recove
 	if err != nil {
 		return err
 	}
-	cmd.Print(validators.WarningsIncludeInit())
 
-	if err := recoveryClient.Connect(flags.endpoint, validators.V()); err != nil {
+	if err := recoveryClient.Connect(flags.endpoint, validators.V(cmd)); err != nil {
 		return err
 	}
 

cli/internal/cmd/recover_test.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/edgelesssys/constellation/internal/cloud/cloudprovider"
 	"github.com/edgelesssys/constellation/internal/constants"
 	"github.com/edgelesssys/constellation/internal/crypto/testvector"
 	"github.com/edgelesssys/constellation/internal/file"
@@ -125,7 +126,7 @@ func TestRecover(t *testing.T) {
 			require := require.New(t)
 
 			cmd := NewRecoverCmd()
-			cmd.Flags().String("config", "", "") // register persistent flag manually
+			cmd.Flags().String("config", constants.ConfigFilename, "") // register persistent flag manually
 			out := &bytes.Buffer{}
 			cmd.SetOut(out)
 			cmd.SetErr(&bytes.Buffer{})
@@ -144,6 +145,10 @@ func TestRecover(t *testing.T) {
 
 			fs := afero.NewMemMapFs()
 			fileHandler := file.NewHandler(fs)
+
+			config := defaultConfigWithExpectedMeasurements(t, cloudprovider.FromString(tc.existingState.CloudProvider))
+			require.NoError(fileHandler.WriteYAML(constants.ConfigFilename, config))
+
 			require.NoError(fileHandler.WriteJSON("constellation-mastersecret.json", masterSecret{Key: tc.masterSecret.Secret, Salt: tc.masterSecret.Salt}, file.OptNone))
 			if !tc.stateless {
 				require.NoError(fileHandler.WriteJSON(constants.StateFilename, tc.existingState, file.OptNone))

cli/internal/cmd/verify.go

@@ -70,9 +70,6 @@ func verify(
 	if err := validators.UpdateInitPCRs(flags.ownerID, flags.clusterID); err != nil {
 		return err
 	}
-	if validators.Warnings() != "" {
-		cmd.Print(validators.Warnings())
-	}
 
 	nonce, err := crypto.GenerateRandomBytes(32)
 	if err != nil {
@@ -90,7 +87,7 @@ func verify(
 			Nonce:    nonce,
 			UserData: userData,
 		},
-		validators.V(),
+		validators.V(cmd),
 	); err != nil {
 		return err
 	}

cli/internal/cmd/verify_test.go

@@ -172,7 +172,7 @@ func TestVerify(t *testing.T) {
 			require := require.New(t)
 
 			cmd := NewVerifyCmd()
-			cmd.Flags().String("config", "", "") // register persistent flag manually
+			cmd.Flags().String("config", constants.ConfigFilename, "") // register persistent flag manually
 			out := &bytes.Buffer{}
 			cmd.SetOut(out)
 			cmd.SetErr(&bytes.Buffer{})
@@ -190,6 +190,8 @@ func TestVerify(t *testing.T) {
 			}
 			fileHandler := file.NewHandler(tc.setupFs(require))
 
+			config := defaultConfigWithExpectedMeasurements(t, tc.provider)
+			require.NoError(fileHandler.WriteYAML(constants.ConfigFilename, config))
 			if tc.idFile != nil {
 				require.NoError(fileHandler.WriteJSON(constants.ClusterIDsFileName, tc.idFile, file.OptNone))
 			}