diff --git a/efi/efi.go b/efi/efi.go
index fc8e4344..4815ed1b 100644
--- a/efi/efi.go
+++ b/efi/efi.go
@@ -22,11 +22,7 @@ package efi
 import "github.com/canonical/go-tpm2"
 
 const (
-	platformFirmwarePCR tpm2.Handle = 0 // SRTM, POST BIOS, and Embedded Drivers
-	driversAndAppsPCR   tpm2.Handle = 2 // UEFI Drivers and UEFI Applications
-	bootManagerCodePCR  tpm2.Handle = 4 // Boot Manager Code and Boot Attempts PCR
-	secureBootPolicyPCR tpm2.Handle = 7 // Secure Boot Policy Measurements PCR
-	kernelConfigPCR     tpm2.Handle = 12
+	kernelConfigPCR tpm2.Handle = 12
 )
 
 // pcrFlags corresponds to a set of PCRs. This can only represent actual PCRs, it
diff --git a/efi/efi_test.go b/efi/efi_test.go
index c317115b..5be3c25a 100644
--- a/efi/efi_test.go
+++ b/efi/efi_test.go
@@ -33,6 +33,7 @@ import (
 	. "gopkg.in/check.v1"
 
 	. "github.com/snapcore/secboot/efi"
+	"github.com/snapcore/secboot/efi/internal"
 	"github.com/snapcore/secboot/internal/efitest"
 	"github.com/snapcore/secboot/internal/testutil"
 )
@@ -693,61 +694,79 @@ type efiSuite struct{}
 var _ = Suite(&efiSuite{})
 
 func (s *efiSuite) TestMakePcrFlags1(c *C) {
-	flags := MakePcrFlags(SecureBootPolicyPCR)
-	c.Check(flags, Equals, PcrFlags(1<<SecureBootPolicyPCR))
+	flags := MakePcrFlags(internal.SecureBootPolicyPCR)
+	c.Check(flags, Equals, PcrFlags(1<<internal.SecureBootPolicyPCR))
 }
 
 func (s *efiSuite) TestMakePcrFlags2(c *C) {
-	flags := MakePcrFlags(BootManagerCodePCR)
-	c.Check(flags, Equals, PcrFlags(1<<BootManagerCodePCR))
+	flags := MakePcrFlags(internal.BootManagerCodePCR)
+	c.Check(flags, Equals, PcrFlags(1<<internal.BootManagerCodePCR))
 }
 
 func (s *efiSuite) TestMakePcrFlags3(c *C) {
-	flags := MakePcrFlags(BootManagerCodePCR, SecureBootPolicyPCR)
-	c.Check(flags, Equals, PcrFlags(1<<BootManagerCodePCR|1<<SecureBootPolicyPCR))
+	flags := MakePcrFlags(internal.BootManagerCodePCR, internal.SecureBootPolicyPCR)
+	c.Check(flags, Equals, PcrFlags(1<<internal.BootManagerCodePCR|1<<internal.SecureBootPolicyPCR))
 }
 
 func (e *efiSuite) TestPcrFlagsPCRs1(c *C) {
-	flags := PcrFlags(1 << SecureBootPolicyPCR)
-	c.Check(flags.PCRs(), DeepEquals, tpm2.HandleList{SecureBootPolicyPCR})
+	flags := PcrFlags(1 << internal.SecureBootPolicyPCR)
+	c.Check(flags.PCRs(), DeepEquals, tpm2.HandleList{internal.SecureBootPolicyPCR})
 }
 
 func (e *efiSuite) TestPcrFlagsPCRs2(c *C) {
-	flags := PcrFlags(1 << BootManagerCodePCR)
-	c.Check(flags.PCRs(), DeepEquals, tpm2.HandleList{BootManagerCodePCR})
+	flags := PcrFlags(1 << internal.BootManagerCodePCR)
+	c.Check(flags.PCRs(), DeepEquals, tpm2.HandleList{internal.BootManagerCodePCR})
 }
 
 func (e *efiSuite) TestPcrFlagsPCRs3(c *C) {
-	flags := PcrFlags((1 << BootManagerCodePCR) | (1 << SecureBootPolicyPCR))
-	c.Check(flags.PCRs(), DeepEquals, tpm2.HandleList{BootManagerCodePCR, SecureBootPolicyPCR})
+	flags := PcrFlags((1 << internal.BootManagerCodePCR) | (1 << internal.SecureBootPolicyPCR))
+	c.Check(flags.PCRs(), DeepEquals, tpm2.HandleList{internal.BootManagerCodePCR, internal.SecureBootPolicyPCR})
 }
 
 func (e *efiSuite) TestPcrFlagsContains1(c *C) {
-	flags := PcrFlags(1 << SecureBootPolicyPCR)
-	c.Check(flags.Contains(SecureBootPolicyPCR), testutil.IsTrue)
+	flags := PcrFlags(1 << internal.SecureBootPolicyPCR)
+	c.Check(flags.Contains(internal.SecureBootPolicyPCR), testutil.IsTrue)
 }
 
 func (e *efiSuite) TestPcrFlagsContains2(c *C) {
-	flags := PcrFlags(1 << BootManagerCodePCR)
-	c.Check(flags.Contains(BootManagerCodePCR), testutil.IsTrue)
+	flags := PcrFlags(1 << internal.BootManagerCodePCR)
+	c.Check(flags.Contains(internal.BootManagerCodePCR), testutil.IsTrue)
 }
 
 func (e *efiSuite) TestPcrFlagsContains3(c *C) {
-	flags := PcrFlags((1 << BootManagerCodePCR) | (1 << SecureBootPolicyPCR))
-	c.Check(flags.Contains(BootManagerCodePCR, SecureBootPolicyPCR), testutil.IsTrue)
+	flags := PcrFlags((1 << internal.BootManagerCodePCR) | (1 << internal.SecureBootPolicyPCR))
+	c.Check(flags.Contains(internal.BootManagerCodePCR, internal.SecureBootPolicyPCR), testutil.IsTrue)
 }
 
 func (e *efiSuite) TestPcrFlagsContains4(c *C) {
-	flags := PcrFlags((1 << BootManagerCodePCR) | (1 << SecureBootPolicyPCR))
-	c.Check(flags.Contains(SecureBootPolicyPCR), testutil.IsTrue)
+	flags := PcrFlags((1 << internal.BootManagerCodePCR) | (1 << internal.SecureBootPolicyPCR))
+	c.Check(flags.Contains(internal.SecureBootPolicyPCR), testutil.IsTrue)
 }
 
 func (e *efiSuite) TestPcrFlagsDoesNotContain1(c *C) {
-	flags := PcrFlags(1 << SecureBootPolicyPCR)
-	c.Check(flags.Contains(PlatformFirmwarePCR), testutil.IsFalse)
+	flags := PcrFlags(1 << internal.SecureBootPolicyPCR)
+	c.Check(flags.Contains(internal.PlatformFirmwarePCR), testutil.IsFalse)
 }
 
 func (e *efiSuite) TestPcrFlagsDoesNotContain2(c *C) {
-	flags := PcrFlags(1 << SecureBootPolicyPCR)
-	c.Check(flags.Contains(PlatformFirmwarePCR, SecureBootPolicyPCR), testutil.IsFalse)
+	flags := PcrFlags(1 << internal.SecureBootPolicyPCR)
+	c.Check(flags.Contains(internal.PlatformFirmwarePCR, internal.SecureBootPolicyPCR), testutil.IsFalse)
+}
+
+type mockPcrProfileOptionVisitor struct {
+	pcrs         tpm2.HandleList
+	env          HostEnvironment
+	varModifiers []internal.InitialVariablesModifier
+}
+
+func (v *mockPcrProfileOptionVisitor) AddPCRs(pcrs ...tpm2.Handle) {
+	v.pcrs = append(v.pcrs, pcrs...)
+}
+
+func (v *mockPcrProfileOptionVisitor) SetEnvironment(env internal.HostEnvironment) {
+	v.env = env
+}
+
+func (v *mockPcrProfileOptionVisitor) AddInitialVariablesModifier(fn internal.InitialVariablesModifier) {
+	v.varModifiers = append(v.varModifiers, fn)
 }
diff --git a/efi/env.go b/efi/env.go
index 306bdcde..793bbcad 100644
--- a/efi/env.go
+++ b/efi/env.go
@@ -29,6 +29,7 @@ import (
 
 	efi "github.com/canonical/go-efilib"
 	"github.com/canonical/tcglog-parser"
+	"github.com/snapcore/secboot/efi/internal"
 	"golang.org/x/xerrors"
 )
 
@@ -54,8 +55,9 @@ func WithHostEnvironment(env HostEnvironment) PCRProfileOption {
 	return &hostEnvironmentOption{HostEnvironment: env}
 }
 
-func (o *hostEnvironmentOption) applyOptionTo(gen *pcrProfileGenerator) {
-	gen.env = o.HostEnvironment
+func (o *hostEnvironmentOption) ApplyOptionTo(visitor internal.PCRProfileOptionVisitor) error {
+	visitor.SetEnvironment(o.HostEnvironment)
+	return nil
 }
 
 // varReader is a subset of HostEnvironment that is just for EFI variables
@@ -64,6 +66,8 @@ type varReader interface {
 	ReadVar(name string, guid efi.GUID) ([]byte, efi.VariableAttributes, error)
 }
 
+// varReadWriter is an interface for reading and mock updating EFI variables during
+// profile generation.
 type varReadWriter interface {
 	varReader
 
@@ -74,29 +78,29 @@ type varReadWriter interface {
 // varUpdate is the sequence of updates generated by a profile branch, associated with
 // a varBranch.
 type varUpdate struct {
-	previous *varUpdate
-	name     efi.VariableDescriptor
-	attrs    efi.VariableAttributes
-	data     []byte
+	previous *varUpdate             // link to the previous update
+	name     efi.VariableDescriptor // the variable name associated with the update
+	attrs    efi.VariableAttributes // the corresponding attributes
+	data     []byte                 // the updated variable data
 }
 
 type varBranchRegisterUpdatesFn func(*varUpdate) error
 
-// varBranch corresponds to a EFI variable state associated with a profile branch,
+// varBranch corresponds to a EFI variable set associated with a profile branch,
 // consisting of an initial starting environment and a sequence of updates that have been
 // added during profile generation. Each profile generation loop starts with one of these
 // without any updates. Branches in a profile inherit a copy of this from the parent branch
 // and may make modifications to EFI variables (eg, applying a SBAT update) which may affect
 // other branches - in this case, the profile generation may be re-executed multiple times
-// with different starting states as a result of these updates. These starting states are
-// computed by the assocated rootVarsCollector.
+// with different initial sets as a result of these updates. These starting sets are
+// computed and tracked by the assocated variableSetCollector.
 type varBranch struct {
 	initial         varReader  // the initial starting environment
 	updates         *varUpdate // the updates applied by the associated branch
 	registerUpdates varBranchRegisterUpdatesFn
 }
 
-// ReadVar implements varReader.ReadVar.
+// ReadVar implements varReader.ReadVar and internal.VariableSet.ReadVar.
 func (s *varBranch) ReadVar(name string, guid efi.GUID) ([]byte, efi.VariableAttributes, error) {
 	update := s.updates
 	for ; update != nil; update = update.previous {
@@ -108,7 +112,9 @@ func (s *varBranch) ReadVar(name string, guid efi.GUID) ([]byte, efi.VariableAtt
 	return s.initial.ReadVar(name, guid)
 }
 
-// WriteVar implements varReadWriter.WriteVar.
+// WriteVar implements varReadWriter.WriteVar and internal.VariableSet.WriteVar.
+// Calling this creates and registers an update which may create a new initial
+// starting variable set for another profile generation loop.
 func (s *varBranch) WriteVar(name string, guid efi.GUID, attrs efi.VariableAttributes, data []byte) error {
 	orig, _, err := s.ReadVar(name, guid)
 	switch {
@@ -130,26 +136,34 @@ func (s *varBranch) WriteVar(name string, guid efi.GUID, attrs efi.VariableAttri
 	return s.registerUpdates(s.updates)
 }
 
-// rootVarReaderKey is a SHA1 used to uniquely identify the contents of a rootVarReader.
+// Clone implements internal.VariableSet.Clone. It returns an exact copy of this
+// varBranch to enable callers to WriteVar to create multiple branches with different
+// write sequences.
+func (s *varBranch) Clone() internal.VariableSet {
+	clone := *s
+	return &clone
+}
+
+// initialVarReaderKey is a SHA1 used to uniquely identify the contents of a initialVarReader.
 // This is to ensure that we don't generate multiple profile branches with the same
 // starting state.
-type rootVarReaderKey [sha1.Size]byte
+type initialVarReaderKey [sha1.Size]byte
 
 type varContents struct {
 	attrs efi.VariableAttributes
 	data  []byte
 }
 
-// rootVarReader provides the initial state for each profile generation branch. It
-// consists of the host environment and updates that have been generated by previous
+// initialVarReader provides the initial starting set for each profile generation branch.
+// It consists of the host environment and updates that have been generated by previous
 // iterations of the profile generation.
-type rootVarReader struct {
+type initialVarReader struct {
 	host      varReader
 	overrides map[efi.VariableDescriptor]varContents
 }
 
 // ReadVar implements varReader.ReadVar
-func (r *rootVarReader) ReadVar(name string, guid efi.GUID) ([]byte, efi.VariableAttributes, error) {
+func (r *initialVarReader) ReadVar(name string, guid efi.GUID) ([]byte, efi.VariableAttributes, error) {
 	override, exists := r.overrides[efi.VariableDescriptor{Name: name, GUID: guid}]
 	if exists {
 		return override.data, override.attrs, nil
@@ -160,7 +174,7 @@ func (r *rootVarReader) ReadVar(name string, guid efi.GUID) ([]byte, efi.Variabl
 // Key returns the unique key for this reader, and is based on the set of updates on the
 // original host environment. This is used to track which initial states have been handled
 // already for a profile.
-func (r *rootVarReader) Key() rootVarReaderKey {
+func (r *initialVarReader) Key() initialVarReaderKey {
 	// Ensure that this is stable by building an ordered list
 	var descs []efi.VariableDescriptor
 	for desc := range r.overrides {
@@ -172,7 +186,7 @@ func (r *rootVarReader) Key() rootVarReaderKey {
 
 	// Start with an empty key which corresponds to the original
 	// host environment.
-	var key rootVarReaderKey
+	var key initialVarReaderKey
 
 	for _, desc := range descs {
 		override := r.overrides[desc]
@@ -191,9 +205,9 @@ func (r *rootVarReader) Key() rootVarReaderKey {
 	return key
 }
 
-// Copy returns a copy of this rootVarReader.
-func (r *rootVarReader) Copy() *rootVarReader {
-	out := &rootVarReader{
+// Copy returns a copy of this initialVarReader.
+func (r *initialVarReader) Copy() *initialVarReader {
+	out := &initialVarReader{
 		host:      r.host,
 		overrides: make(map[efi.VariableDescriptor]varContents)}
 	for k, v := range r.overrides {
@@ -202,8 +216,8 @@ func (r *rootVarReader) Copy() *rootVarReader {
 	return out
 }
 
-// ApplyUpdates applies the specified sequence of updates to this rootVarReader.
-func (r *rootVarReader) ApplyUpdates(updates *varUpdate) error {
+// ApplyUpdates applies the specified sequence of updates to this initialVarReader.
+func (r *initialVarReader) ApplyUpdates(updates *varUpdate) error {
 	// arrange in order of application from oldest to newest
 	var updateSlice []*varUpdate
 	for ; updates != nil; updates = updates.previous {
@@ -227,28 +241,27 @@ func (r *rootVarReader) ApplyUpdates(updates *varUpdate) error {
 	return nil
 }
 
-// rootVarsCollector keeps track of all of the starting EFI variable states that
+// variableSetCollector keeps track of all of the starting EFI variable sets that
 // a profile needs to be generated against. The profile generation runs an outer
-// loop that adds a branch for each of the starting states. Profile generation may
+// loop that adds a branch for each of the starting sets. Profile generation may
 // add more starting states as some branches have paths that update EFI variables
 // (such as applying SBAT updates) which may have an effect on other branches.
-type rootVarsCollector struct {
+type variableSetCollector struct {
 	host varReader // the externally supplied host environment
 
-	seen map[rootVarReaderKey]struct{} // known starting states
+	seen map[initialVarReaderKey]struct{} // known starting states
 
-	// todo contains a list of starting states that a profile branch still
-	// needs to be generated for. When this is empty, pendingUpdates is
-	// drained in order to try to create more.
-	todo []*rootVarReader
+	// todo contains a list of starting sets that a profile branch still
+	// needs to be generated for.
+	todo []*initialVarReader
 }
 
-func newRootVarsCollector(vars varReader) *rootVarsCollector {
-	return &rootVarsCollector{
+func newVariableSetCollector(vars varReader) *variableSetCollector {
+	return &variableSetCollector{
 		host: vars,
-		seen: map[rootVarReaderKey]struct{}{rootVarReaderKey{}: struct{}{}}, // add the current environment
-		todo: []*rootVarReader{
-			&rootVarReader{
+		seen: map[initialVarReaderKey]struct{}{initialVarReaderKey{}: struct{}{}}, // add the current environment
+		todo: []*initialVarReader{
+			&initialVarReader{
 				host:      vars,
 				overrides: make(map[efi.VariableDescriptor]varContents)}}} // add the current environment
 }
@@ -258,25 +271,25 @@ func newRootVarsCollector(vars varReader) *rootVarsCollector {
 // processed. This should be called on every update - this ensures that if a branch
 // makes more than one update, the generated profile will be valid for intermediate
 // states.
-func (c *rootVarsCollector) registerUpdatesFor(initial *rootVarReader, updates *varUpdate) error {
-	newRoot := initial.Copy()
-	if err := newRoot.ApplyUpdates(updates); err != nil {
+func (c *variableSetCollector) registerUpdatesFor(initial *initialVarReader, updates *varUpdate) error {
+	newInitial := initial.Copy()
+	if err := newInitial.ApplyUpdates(updates); err != nil {
 		return xerrors.Errorf("cannot compute updated starting state: %w", err)
 	}
 
-	key := newRoot.Key()
+	key := newInitial.Key()
 	if _, exists := c.seen[key]; exists {
 		// we've already generated this starting state
 		return nil
 	}
 
 	c.seen[key] = struct{}{}
-	c.todo = append(c.todo, newRoot)
+	c.todo = append(c.todo, newInitial)
 
 	return nil
 }
 
-func (c *rootVarsCollector) newVarBranch(root *rootVarReader) *varBranch {
+func (c *variableSetCollector) newVarBranch(root *initialVarReader) *varBranch {
 	return &varBranch{
 		initial: root,
 		registerUpdates: func(updates *varUpdate) error {
@@ -284,28 +297,27 @@ func (c *rootVarsCollector) newVarBranch(root *rootVarReader) *varBranch {
 		}}
 }
 
-// More indicates that there are more starting states to generate profile
+// More indicates that there are more starting sets to generate profile
 // branches for.
-func (c *rootVarsCollector) More() bool {
+func (c *variableSetCollector) More() bool {
 	return len(c.todo) > 0
 }
 
-// Next returns the next starting state to generate a profile branch for. This will
-// not return the same starting state more than once.
-func (c *rootVarsCollector) Next() *varBranch {
+// Next returns the next starting set to generate a profile branch for. This will
+// not return the same starting set more than once.
+func (c *variableSetCollector) Next() *varBranch {
 	next := c.todo[0]
 	c.todo = c.todo[1:]
 	return c.newVarBranch(next)
 }
 
-// PeekAll returns all of the pending starting states to generate profile
-// branches for.
-func (c *rootVarsCollector) PeekAll() []*varBranch {
+// PeekAll returns all of the pending starting sets to generate profile
+// branches for, without consuming them. It allows them to be added to
+// with options that run before the profile generation.
+func (c *variableSetCollector) PeekAll() []*varBranch {
 	var out []*varBranch
 	for _, r := range c.todo {
 		out = append(out, c.newVarBranch(r))
 	}
 	return out
 }
-
-type rootVarsModifier func(*rootVarsCollector) error
diff --git a/efi/env_test.go b/efi/env_test.go
index 1a4ac8e2..cbf75556 100644
--- a/efi/env_test.go
+++ b/efi/env_test.go
@@ -33,12 +33,12 @@ type envSuite struct{}
 
 var _ = Suite(&envSuite{})
 
-func (s *envSuite) TestRootVarReaderReadVar(c *C) {
+func (s *envSuite) TestInitialVarReaderReadVar(c *C) {
 	env := efitest.NewMockHostEnvironment(efitest.MockVars{
 		{Name: "SecureBoot", GUID: efi.GlobalVariable}: {Payload: []byte{1}, Attrs: efi.AttributeBootserviceAccess | efi.AttributeRuntimeAccess},
 	}, nil)
 
-	reader := NewRootVarReader(env)
+	reader := NewInitialVarReader(env)
 
 	data, attrs, err := reader.ReadVar("SecureBoot", efi.GlobalVariable)
 	c.Check(err, IsNil)
@@ -46,12 +46,12 @@ func (s *envSuite) TestRootVarReaderReadVar(c *C) {
 	c.Check(attrs, Equals, efi.AttributeBootserviceAccess|efi.AttributeRuntimeAccess)
 }
 
-func (s *envSuite) TestRootVarReaderApplyOneUpdate(c *C) {
+func (s *envSuite) TestInitialVarReaderApplyOneUpdate(c *C) {
 	env := efitest.NewMockHostEnvironment(efitest.MockVars{
 		{Name: "foo", GUID: testGuid1}: {Payload: []byte{1}, Attrs: efi.AttributeNonVolatile | efi.AttributeBootserviceAccess},
 	}, nil)
 
-	reader := NewRootVarReader(env)
+	reader := NewInitialVarReader(env)
 	reader.ApplyUpdates(NewVarUpdate(nil, efi.VariableDescriptor{Name: "foo", GUID: testGuid1}, efi.AttributeNonVolatile|efi.AttributeBootserviceAccess, []byte{2}))
 
 	data, attrs, err := reader.ReadVar("foo", testGuid1)
@@ -60,12 +60,12 @@ func (s *envSuite) TestRootVarReaderApplyOneUpdate(c *C) {
 	c.Check(attrs, Equals, efi.AttributeNonVolatile|efi.AttributeBootserviceAccess)
 }
 
-func (s *envSuite) TestRootVarReaderApplyMultipleUpdates(c *C) {
+func (s *envSuite) TestInitialVarReaderApplyMultipleUpdates(c *C) {
 	env := efitest.NewMockHostEnvironment(efitest.MockVars{
 		{Name: "foo", GUID: testGuid1}: {Payload: []byte{1}, Attrs: efi.AttributeNonVolatile | efi.AttributeBootserviceAccess},
 	}, nil)
 
-	reader := NewRootVarReader(env)
+	reader := NewInitialVarReader(env)
 	reader.ApplyUpdates(
 		NewVarUpdate(
 			NewVarUpdate(nil, efi.VariableDescriptor{Name: "bar", GUID: testGuid1}, efi.AttributeNonVolatile|efi.AttributeBootserviceAccess, []byte{5}),
@@ -82,12 +82,12 @@ func (s *envSuite) TestRootVarReaderApplyMultipleUpdates(c *C) {
 	c.Check(attrs, Equals, efi.AttributeNonVolatile|efi.AttributeBootserviceAccess)
 }
 
-func (s *envSuite) TestRootVarReaderApplyUpdatesOrdering(c *C) {
+func (s *envSuite) TestInitialVarReaderApplyUpdatesOrdering(c *C) {
 	env := efitest.NewMockHostEnvironment(efitest.MockVars{
 		{Name: "foo", GUID: testGuid1}: {Payload: []byte{1}, Attrs: efi.AttributeNonVolatile | efi.AttributeBootserviceAccess},
 	}, nil)
 
-	reader := NewRootVarReader(env)
+	reader := NewInitialVarReader(env)
 	reader.ApplyUpdates(
 		NewVarUpdate(
 			NewVarUpdate(nil, efi.VariableDescriptor{Name: "foo", GUID: testGuid1}, efi.AttributeNonVolatile|efi.AttributeBootserviceAccess, []byte{2}),
@@ -99,61 +99,61 @@ func (s *envSuite) TestRootVarReaderApplyUpdatesOrdering(c *C) {
 	c.Check(attrs, Equals, efi.AttributeNonVolatile|efi.AttributeBootserviceAccess)
 }
 
-func (s *envSuite) TestRootVarReaderKey(c *C) {
+func (s *envSuite) TestInitialVarReaderKey(c *C) {
 	env := efitest.NewMockHostEnvironment(efitest.MockVars{
 		{Name: "foo", GUID: testGuid1}: {Payload: []byte{1}, Attrs: efi.AttributeNonVolatile | efi.AttributeBootserviceAccess},
 	}, nil)
 
-	reader := NewRootVarReader(env)
-	c.Check(reader.Key(), DeepEquals, RootVarReaderKey{})
+	reader := NewInitialVarReader(env)
+	c.Check(reader.Key(), DeepEquals, InitialVarReaderKey{})
 }
 
-func (s *envSuite) TestRootVarReaderKeyWithOneUpdate(c *C) {
+func (s *envSuite) TestInitialVarReaderKeyWithOneUpdate(c *C) {
 	env := efitest.NewMockHostEnvironment(efitest.MockVars{
 		{Name: "foo", GUID: testGuid1}: {Payload: []byte{1}, Attrs: efi.AttributeNonVolatile | efi.AttributeBootserviceAccess},
 	}, nil)
 
-	reader := NewRootVarReader(env)
+	reader := NewInitialVarReader(env)
 	reader.ApplyUpdates(NewVarUpdate(nil, efi.VariableDescriptor{Name: "foo", GUID: testGuid1}, efi.AttributeNonVolatile|efi.AttributeBootserviceAccess, []byte{2}))
 
-	var expected RootVarReaderKey
+	var expected InitialVarReaderKey
 	copy(expected[:], testutil.DecodeHexString(c, "af83642902c9f89dc8f761bb03a29bae54cc648e"))
 	c.Check(reader.Key(), DeepEquals, expected)
 }
 
-func (s *envSuite) TestRootVarReaderKeyWithMultipleUpdates(c *C) {
+func (s *envSuite) TestInitialVarReaderKeyWithMultipleUpdates(c *C) {
 	env := efitest.NewMockHostEnvironment(efitest.MockVars{
 		{Name: "foo", GUID: testGuid1}: {Payload: []byte{1}, Attrs: efi.AttributeNonVolatile | efi.AttributeBootserviceAccess},
 	}, nil)
 
-	reader := NewRootVarReader(env)
+	reader := NewInitialVarReader(env)
 	reader.ApplyUpdates(
 		NewVarUpdate(
 			NewVarUpdate(nil, efi.VariableDescriptor{Name: "bar", GUID: testGuid1}, efi.AttributeNonVolatile|efi.AttributeBootserviceAccess, []byte{5}),
 			efi.VariableDescriptor{Name: "foo", GUID: testGuid1}, efi.AttributeNonVolatile|efi.AttributeBootserviceAccess, []byte{2}))
 
-	var expected RootVarReaderKey
+	var expected InitialVarReaderKey
 	copy(expected[:], testutil.DecodeHexString(c, "d9d3425d3e48666ff1ffc66d211b4bbe2dc654ae"))
 	c.Check(reader.Key(), DeepEquals, expected)
 }
 
-func (s *envSuite) TestRootVarReaderKeyOmitsUnchanged(c *C) {
+func (s *envSuite) TestInitialVarReaderKeyOmitsUnchanged(c *C) {
 	env := efitest.NewMockHostEnvironment(efitest.MockVars{
 		{Name: "foo", GUID: testGuid1}: {Payload: []byte{1}, Attrs: efi.AttributeNonVolatile | efi.AttributeBootserviceAccess},
 	}, nil)
 
-	reader := NewRootVarReader(env)
+	reader := NewInitialVarReader(env)
 	reader.ApplyUpdates(NewVarUpdate(nil, efi.VariableDescriptor{Name: "foo", GUID: testGuid1}, efi.AttributeNonVolatile|efi.AttributeBootserviceAccess, []byte{1}))
 
-	c.Check(reader.Key(), DeepEquals, RootVarReaderKey{})
+	c.Check(reader.Key(), DeepEquals, InitialVarReaderKey{})
 }
 
-func (s *envSuite) TestRootVarReaderCopy(c *C) {
+func (s *envSuite) TestInitialVarReaderCopy(c *C) {
 	env := efitest.NewMockHostEnvironment(efitest.MockVars{
 		{Name: "foo", GUID: testGuid1}: {Payload: []byte{1}, Attrs: efi.AttributeNonVolatile | efi.AttributeBootserviceAccess},
 	}, nil)
 
-	reader := NewRootVarReader(env)
+	reader := NewInitialVarReader(env)
 	reader.ApplyUpdates(
 		NewVarUpdate(
 			NewVarUpdate(nil, efi.VariableDescriptor{Name: "bar", GUID: testGuid1}, efi.AttributeNonVolatile|efi.AttributeBootserviceAccess, []byte{5}),
@@ -195,7 +195,7 @@ type testRootVarsCollectorData struct {
 }
 
 func (s *envSuite) testRootVarsCollector(c *C, data *testRootVarsCollectorData) {
-	collector := NewRootVarsCollector(data.env)
+	collector := NewVariableSetCollector(data.env)
 	c.Assert(collector, NotNil)
 
 	for i, expected := range data.expected {
@@ -531,7 +531,7 @@ func (s *envSuite) TestRootVarsCollectorPeekAll(c *C) {
 		{Name: "SecureBoot", GUID: efi.GlobalVariable}: {Payload: []byte{1}, Attrs: efi.AttributeBootserviceAccess | efi.AttributeRuntimeAccess},
 	}, nil)
 
-	collector := NewRootVarsCollector(env)
+	collector := NewVariableSetCollector(env)
 	c.Assert(collector, NotNil)
 
 	roots := collector.PeekAll()
@@ -559,7 +559,7 @@ func (s *envSuite) TestRootVarsCollectorPeekAll(c *C) {
 func (s *envSuite) TestVarBranchReadsUpdate(c *C) {
 	env := efitest.NewMockHostEnvironment(efitest.MockVars{}, nil)
 
-	collector := NewRootVarsCollector(env)
+	collector := NewVariableSetCollector(env)
 	root := collector.Next()
 
 	c.Check(root.WriteVar("foo", testGuid1, efi.AttributeNonVolatile|efi.AttributeBootserviceAccess, []byte{1}), IsNil)
diff --git a/efi/export_test.go b/efi/export_test.go
index 31189d73..983d2f15 100644
--- a/efi/export_test.go
+++ b/efi/export_test.go
@@ -22,16 +22,13 @@ package efi
 import (
 	efi "github.com/canonical/go-efilib"
 	"github.com/canonical/tcglog-parser"
+	"github.com/snapcore/secboot/efi/internal"
 )
 
 // Export constants for testing
 const (
-	BootManagerCodePCR                         = bootManagerCodePCR
-	DriversAndAppsPCR                          = driversAndAppsPCR
 	GrubChainloaderUsesShimProtocol            = grubChainloaderUsesShimProtocol
 	KernelConfigPCR                            = kernelConfigPCR
-	PlatformFirmwarePCR                        = platformFirmwarePCR
-	SecureBootPolicyPCR                        = secureBootPolicyPCR
 	ShimFixVariableAuthorityEventsMatchSpec    = shimFixVariableAuthorityEventsMatchSpec
 	ShimHasSbatRevocationManagement            = shimHasSbatRevocationManagement
 	ShimHasSbatVerification                    = shimHasSbatVerification
@@ -48,7 +45,6 @@ const (
 // Export variables and unexported functions for testing
 var (
 	ApplySignatureDBUpdate                      = applySignatureDBUpdate
-	DefaultEnv                                  = defaultEnv
 	ErrNoHandler                                = errNoHandler
 	ImageAlwaysMatches                          = imageAlwaysMatches
 	ImageDigestMatches                          = imageDigestMatches
@@ -69,11 +65,11 @@ var (
 	NewPcrImagesMeasurer                        = newPcrImagesMeasurer
 	NewPcrProfileGenerator                      = newPcrProfileGenerator
 	NewRootPcrBranchCtx                         = newRootPcrBranchCtx
-	NewRootVarsCollector                        = newRootVarsCollector
 	NewSecureBootNamespaceRules                 = newSecureBootNamespaceRules
 	NewShimImageHandle                          = newShimImageHandle
 	NewShimLoadHandler                          = newShimLoadHandler
 	NewShimLoadHandlerConstructor               = newShimLoadHandlerConstructor
+	NewVariableSetCollector                     = newVariableSetCollector
 	OpenPeImage                                 = openPeImage
 	ParseShimVersion                            = parseShimVersion
 	ParseShimVersionDataIdent                   = parseShimVersionDataIdent
@@ -100,6 +96,7 @@ type ImageLoadParamsSet = imageLoadParamsSet
 type ImageRules = imageRules
 type ImageSectionExists = imageSectionExists
 type ImageSignedByOrganization = imageSignedByOrganization
+type InitialVarReaderKey = initialVarReaderKey
 type LoadParams = loadParams
 type NullLoadHandler = nullLoadHandler
 type PcrBranchContext = pcrBranchContext
@@ -107,8 +104,6 @@ type PcrFlags = pcrFlags
 type PcrImagesMeasurer = pcrImagesMeasurer
 type PcrProfileContext = pcrProfileContext
 type PeImageHandle = peImageHandle
-type RootVarReaderKey = rootVarReaderKey
-type RootVarsCollector = rootVarsCollector
 type SbatComponent = sbatComponent
 type SbatComponentExists = sbatComponentExists
 type SecureBootAuthority = secureBootAuthority
@@ -126,6 +121,7 @@ type ShimVersion = shimVersion
 type SignatureDBUpdateFirmwareQuirk = signatureDBUpdateFirmwareQuirk
 type UbuntuCoreUKILoadHandler = ubuntuCoreUKILoadHandler
 type VarBranch = varBranch
+type VariableSetCollector = variableSetCollector
 type VarReadWriter = varReadWriter
 type VendorAuthorityGetter = vendorAuthorityGetter
 
@@ -146,14 +142,6 @@ func (s *ImageLoadSequences) Params() imageLoadParamsSet {
 	return s.params
 }
 
-func MockEventLogPath(path string) (restore func()) {
-	origPath := eventLogPath
-	eventLogPath = path
-	return func() {
-		eventLogPath = origPath
-	}
-}
-
 func MockMakeImageLoadHandlerMap(fn func() imageLoadHandlerMap) (restore func()) {
 	orig := makeImageLoadHandlerMap
 	makeImageLoadHandlerMap = fn
@@ -194,14 +182,6 @@ func MockOpenPeImage(fn func(Image) (peImageHandle, error)) (restore func()) {
 	}
 }
 
-func MockReadVar(fn func(string, efi.GUID) ([]byte, efi.VariableAttributes, error)) (restore func()) {
-	origReadVar := readVar
-	readVar = fn
-	return func() {
-		readVar = origReadVar
-	}
-}
-
 func MockSnapdenvTesting(testing bool) (restore func()) {
 	orig := snapdenvTesting
 	snapdenvTesting = func() bool { return testing }
@@ -210,8 +190,8 @@ func MockSnapdenvTesting(testing bool) (restore func()) {
 	}
 }
 
-func NewRootVarReader(host HostEnvironment) *rootVarReader {
-	return &rootVarReader{
+func NewInitialVarReader(host HostEnvironment) *initialVarReader {
+	return &initialVarReader{
 		host:      host,
 		overrides: make(map[efi.VariableDescriptor]varContents)}
 }
@@ -224,12 +204,13 @@ func NewVarUpdate(prev *varUpdate, name efi.VariableDescriptor, attrs efi.Variab
 		data:     data}
 }
 
-type mockRootVarsModifierOption rootVarsModifier
+type mockInitialVariablesModifierOption internal.InitialVariablesModifier
 
-func (o mockRootVarsModifierOption) applyOptionTo(gen *pcrProfileGenerator) {
-	gen.varModifiers = append(gen.varModifiers, rootVarsModifier(o))
+func (o mockInitialVariablesModifierOption) ApplyOptionTo(visitor internal.PCRProfileOptionVisitor) error {
+	visitor.AddInitialVariablesModifier(internal.InitialVariablesModifier(o))
+	return nil
 }
 
-func WithMockRootVarsModifierOption(fn func(vars *RootVarsCollector) error) PCRProfileOption {
-	return mockRootVarsModifierOption(fn)
+func WithMockInitialVariablesModifierOption(fn func(internal.VariableSet) error) PCRProfileOption {
+	return mockInitialVariablesModifierOption(fn)
 }
diff --git a/efi/fw_load_handler.go b/efi/fw_load_handler.go
index a43f593d..dcf31ebb 100644
--- a/efi/fw_load_handler.go
+++ b/efi/fw_load_handler.go
@@ -53,7 +53,7 @@ func (h *fwLoadHandler) measureSeparator(ctx pcrBranchContext, pcr tpm2.Handle,
 
 	data, ok := event.Data.(*tcglog.SeparatorEventData)
 	if !ok {
-		// if decoding fails, the resulting type is guaranteed to implement error.
+		// if the event data failed to decode, the resulting implementation is guaranteed to implement error.
 		return fmt.Errorf("cannot measure invalid separator event: %w", event.Data.(error))
 	}
 	if data.IsError() {
@@ -69,7 +69,7 @@ func (h *fwLoadHandler) readAndMeasureSignatureDb(ctx pcrBranchContext, name efi
 		return nil, xerrors.Errorf("cannot read current variable: %w", err)
 	}
 
-	ctx.MeasureVariable(secureBootPolicyPCR, name.GUID, name.Name, db)
+	ctx.MeasureVariable(internal.SecureBootPolicyPCR, name.GUID, name.Name, db)
 	return db, nil
 }
 
@@ -91,7 +91,7 @@ func (h *fwLoadHandler) measureSecureBootPolicyPreOS(ctx pcrBranchContext) error
 	// This hard-codes a profile that will only work on devices with secure boot enabled,
 	// deployed mode on (where UEFI >= 2.5), without a UEFI debugger enabled and which
 	// measure events in the correct order.
-	ctx.MeasureVariable(secureBootPolicyPCR, efi.GlobalVariable, sbStateName, []byte{1})
+	ctx.MeasureVariable(internal.SecureBootPolicyPCR, efi.GlobalVariable, sbStateName, []byte{1})
 	if _, err := h.readAndMeasureSignatureDb(ctx, PK); err != nil {
 		return xerrors.Errorf("cannot measure PK: %w", err)
 	}
@@ -118,19 +118,19 @@ func (h *fwLoadHandler) measureSecureBootPolicyPreOS(ctx pcrBranchContext) error
 		events = events[1:]
 
 		switch {
-		case e.PCRIndex < tcglog.PCRIndex(secureBootPolicyPCR) && e.EventType == tcglog.EventTypeSeparator:
+		case e.PCRIndex < tcglog.PCRIndex(internal.SecureBootPolicyPCR) && e.EventType == tcglog.EventTypeSeparator:
 			// pre-OS to OS-present signal
 			foundOsPresent = true
-		case e.PCRIndex == tcglog.PCRIndex(secureBootPolicyPCR) && e.EventType == tcglog.EventTypeSeparator:
+		case e.PCRIndex == tcglog.PCRIndex(internal.SecureBootPolicyPCR) && e.EventType == tcglog.EventTypeSeparator:
 			// end of secure boot configuration signal
 			if foundSecureBootSeparator {
 				return errors.New("unexpected separator")
 			}
-			if err := h.measureSeparator(ctx, secureBootPolicyPCR, e); err != nil {
+			if err := h.measureSeparator(ctx, internal.SecureBootPolicyPCR, e); err != nil {
 				return err
 			}
 			foundSecureBootSeparator = true
-		case e.PCRIndex == tcglog.PCRIndex(secureBootPolicyPCR) && e.EventType == tcglog.EventTypeEFIVariableAuthority:
+		case e.PCRIndex == tcglog.PCRIndex(internal.SecureBootPolicyPCR) && e.EventType == tcglog.EventTypeEFIVariableAuthority:
 			// secure boot verification event - shouldn't see this before the end of secure
 			// boot configuration signal.
 			if !foundSecureBootSeparator {
@@ -138,14 +138,14 @@ func (h *fwLoadHandler) measureSecureBootPolicyPreOS(ctx pcrBranchContext) error
 			}
 			digest := tpm2.Digest(e.Digests[ctx.PCRAlg()])
 			ctx.FwContext().AppendVerificationEvent(digest)
-			ctx.ExtendPCR(secureBootPolicyPCR, digest)
-		case e.PCRIndex == tcglog.PCRIndex(secureBootPolicyPCR) && e.EventType == tcglog.EventTypeEFIVariableDriverConfig:
+			ctx.ExtendPCR(internal.SecureBootPolicyPCR, digest)
+		case e.PCRIndex == tcglog.PCRIndex(internal.SecureBootPolicyPCR) && e.EventType == tcglog.EventTypeEFIVariableDriverConfig:
 			// ignore: part of the secure boot configuration - shouldn't see this after the
 			// end of secure boot configuration signal.
 			if foundSecureBootSeparator {
 				return errors.New("unexpected configuration event")
 			}
-		case e.PCRIndex == tcglog.PCRIndex(secureBootPolicyPCR):
+		case e.PCRIndex == tcglog.PCRIndex(internal.SecureBootPolicyPCR):
 			return fmt.Errorf("unexpected event type (%v) found in log", e.EventType)
 		default:
 			// not a secure boot event
@@ -166,7 +166,7 @@ func (h *fwLoadHandler) measurePlatformFirmware(ctx pcrBranchContext) error {
 	donePcrReset := false
 
 	for _, event := range h.log.Events {
-		if event.PCRIndex != tcglog.PCRIndex(platformFirmwarePCR) {
+		if event.PCRIndex != tcglog.PCRIndex(internal.PlatformFirmwarePCR) {
 			continue
 		}
 		if event.EventType == tcglog.EventTypeNoAction {
@@ -184,14 +184,14 @@ func (h *fwLoadHandler) measurePlatformFirmware(ctx pcrBranchContext) error {
 		}
 
 		if !donePcrReset {
-			ctx.ResetPCR(platformFirmwarePCR)
+			ctx.ResetPCR(internal.PlatformFirmwarePCR)
 			donePcrReset = true
 		}
 
 		if event.EventType == tcglog.EventTypeSeparator {
-			return h.measureSeparator(ctx, platformFirmwarePCR, event)
+			return h.measureSeparator(ctx, internal.PlatformFirmwarePCR, event)
 		}
-		ctx.ExtendPCR(platformFirmwarePCR, tpm2.Digest(event.Digests[ctx.PCRAlg()]))
+		ctx.ExtendPCR(internal.PlatformFirmwarePCR, tpm2.Digest(event.Digests[ctx.PCRAlg()]))
 	}
 
 	return errors.New("missing separator")
@@ -199,14 +199,14 @@ func (h *fwLoadHandler) measurePlatformFirmware(ctx pcrBranchContext) error {
 
 func (h *fwLoadHandler) measureDriversAndApps(ctx pcrBranchContext) error {
 	for _, event := range h.log.Events {
-		if event.PCRIndex != tcglog.PCRIndex(driversAndAppsPCR) {
+		if event.PCRIndex != tcglog.PCRIndex(internal.DriversAndAppsPCR) {
 			continue
 		}
 
 		if event.EventType == tcglog.EventTypeSeparator {
-			return h.measureSeparator(ctx, driversAndAppsPCR, event)
+			return h.measureSeparator(ctx, internal.DriversAndAppsPCR, event)
 		}
-		ctx.ExtendPCR(driversAndAppsPCR, tpm2.Digest(event.Digests[ctx.PCRAlg()]))
+		ctx.ExtendPCR(internal.DriversAndAppsPCR, tpm2.Digest(event.Digests[ctx.PCRAlg()]))
 	}
 
 	return errors.New("missing separator")
@@ -252,18 +252,18 @@ func (h *fwLoadHandler) measureBootManagerCodePreOS(ctx pcrBranchContext) error
 		event := events[0]
 		events = events[1:]
 
-		if event.PCRIndex != tcglog.PCRIndex(bootManagerCodePCR) {
+		if event.PCRIndex != tcglog.PCRIndex(internal.BootManagerCodePCR) {
 			continue
 		}
 
 		if event.EventType == tcglog.EventTypeSeparator {
-			if err := h.measureSeparator(ctx, bootManagerCodePCR, event); err != nil {
+			if err := h.measureSeparator(ctx, internal.BootManagerCodePCR, event); err != nil {
 				return err
 			}
 			measuredSeparator = true
 			break
 		}
-		ctx.ExtendPCR(bootManagerCodePCR, tpm2.Digest(event.Digests[ctx.PCRAlg()]))
+		ctx.ExtendPCR(internal.BootManagerCodePCR, tpm2.Digest(event.Digests[ctx.PCRAlg()]))
 	}
 
 	if !measuredSeparator {
@@ -279,7 +279,7 @@ func (h *fwLoadHandler) measureBootManagerCodePreOS(ctx pcrBranchContext) error
 		event := events[0]
 		events = events[1:]
 
-		if event.PCRIndex != tcglog.PCRIndex(bootManagerCodePCR) {
+		if event.PCRIndex != tcglog.PCRIndex(internal.BootManagerCodePCR) {
 			continue
 		}
 		if event.EventType != tcglog.EventTypeEFIBootServicesApplication {
@@ -295,7 +295,7 @@ func (h *fwLoadHandler) measureBootManagerCodePreOS(ctx pcrBranchContext) error
 		}
 		if isAbsolute {
 			// copy the digest to the policy
-			ctx.ExtendPCR(bootManagerCodePCR, tpm2.Digest(event.Digests[ctx.PCRAlg()]))
+			ctx.ExtendPCR(internal.BootManagerCodePCR, tpm2.Digest(event.Digests[ctx.PCRAlg()]))
 		}
 		// If it's not Absolute, we assume it's related to the OS launch which we will predict
 		// later on. If it's something else, discarding it here creates an invalid policy but this is
@@ -316,28 +316,28 @@ func (h *fwLoadHandler) MeasureImageStart(ctx pcrBranchContext) error {
 	// extends it later on. We ignore PCR0 here as a special case because it doesn't
 	// necessarily have a zero reset value.
 	for _, pcr := range ctx.PCRs().PCRs() {
-		if pcr == platformFirmwarePCR {
+		if pcr == internal.PlatformFirmwarePCR {
 			continue
 		}
 		ctx.ResetPCR(pcr)
 	}
 
-	if ctx.PCRs().Contains(platformFirmwarePCR) {
+	if ctx.PCRs().Contains(internal.PlatformFirmwarePCR) {
 		if err := h.measurePlatformFirmware(ctx); err != nil {
 			return fmt.Errorf("cannot measure platform firmware: %w", err)
 		}
 	}
-	if ctx.PCRs().Contains(driversAndAppsPCR) {
+	if ctx.PCRs().Contains(internal.DriversAndAppsPCR) {
 		if err := h.measureDriversAndApps(ctx); err != nil {
 			return fmt.Errorf("cannot measure drivers and apps: %w", err)
 		}
 	}
-	if ctx.PCRs().Contains(bootManagerCodePCR) {
+	if ctx.PCRs().Contains(internal.BootManagerCodePCR) {
 		if err := h.measureBootManagerCodePreOS(ctx); err != nil {
 			return fmt.Errorf("cannot measure boot manager code: %w", err)
 		}
 	}
-	if ctx.PCRs().Contains(secureBootPolicyPCR) {
+	if ctx.PCRs().Contains(internal.SecureBootPolicyPCR) {
 		if err := h.measureSecureBootPolicyPreOS(ctx); err != nil {
 			return xerrors.Errorf("cannot measure secure boot policy: %w", err)
 		}
@@ -390,7 +390,7 @@ func (m *fwImageLoadMeasurer) measureVerification() error {
 		return nil
 	}
 	m.FwContext().AppendVerificationEvent(digest)
-	m.ExtendPCR(secureBootPolicyPCR, digest)
+	m.ExtendPCR(internal.SecureBootPolicyPCR, digest)
 	return nil
 }
 
@@ -399,18 +399,18 @@ func (m *fwImageLoadMeasurer) measurePEImageDigest() error {
 	if err != nil {
 		return xerrors.Errorf("cannot compute PE digest: %w", err)
 	}
-	m.ExtendPCR(bootManagerCodePCR, digest)
+	m.ExtendPCR(internal.BootManagerCodePCR, digest)
 	return nil
 }
 
 func (m *fwImageLoadMeasurer) measure() error {
-	if m.PCRs().Contains(secureBootPolicyPCR) {
+	if m.PCRs().Contains(internal.SecureBootPolicyPCR) {
 		if err := m.measureVerification(); err != nil {
 			return xerrors.Errorf("cannot measure secure boot event: %w", err)
 		}
 	}
 
-	if m.PCRs().Contains(bootManagerCodePCR) {
+	if m.PCRs().Contains(internal.BootManagerCodePCR) {
 		if err := m.measurePEImageDigest(); err != nil {
 			return xerrors.Errorf("cannot measure boot manager code event: %w", err)
 		}
diff --git a/efi/fw_load_handler_test.go b/efi/fw_load_handler_test.go
index 5869e5bb..1eeab096 100644
--- a/efi/fw_load_handler_test.go
+++ b/efi/fw_load_handler_test.go
@@ -31,6 +31,7 @@ import (
 	"github.com/canonical/tcglog-parser"
 
 	. "github.com/snapcore/secboot/efi"
+	"github.com/snapcore/secboot/efi/internal"
 	"github.com/snapcore/secboot/internal/efitest"
 	"github.com/snapcore/secboot/internal/testutil"
 )
@@ -54,7 +55,7 @@ type testFwMeasureImageStartData struct {
 }
 
 func (s *fwLoadHandlerSuite) testMeasureImageStart(c *C, data *testFwMeasureImageStartData) *FwContext {
-	collector := NewRootVarsCollector(efitest.NewMockHostEnvironment(data.vars, nil))
+	collector := NewVariableSetCollector(efitest.NewMockHostEnvironment(data.vars, nil))
 	ctx := newMockPcrBranchContext(&mockPcrProfileContext{
 		alg:  data.alg,
 		pcrs: data.pcrs}, nil, collector.Next())
@@ -75,7 +76,7 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartSecureBootPolicyProfile(c *C)
 		vars:       vars,
 		logOptions: &efitest.LogOptions{Algorithms: []tpm2.HashAlgorithmId{tpm2.HashAlgorithmSHA256, tpm2.HashAlgorithmSHA1}},
 		alg:        tpm2.HashAlgorithmSHA256,
-		pcrs:       MakePcrFlags(SecureBootPolicyPCR),
+		pcrs:       MakePcrFlags(internal.SecureBootPolicyPCR),
 		expectedEvents: []*mockPcrBranchEvent{
 			{pcr: 7, eventType: mockPcrBranchResetEvent},
 			{pcr: 7, eventType: mockPcrBranchMeasureVariableEvent, varName: efi.VariableDescriptor{Name: "SecureBoot", GUID: efi.GlobalVariable}, varData: []byte{0x01}},
@@ -99,7 +100,7 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartSecureBootPolicyProfileSecureB
 			SecureBootDisabled: true,
 		},
 		alg:  tpm2.HashAlgorithmSHA256,
-		pcrs: MakePcrFlags(SecureBootPolicyPCR),
+		pcrs: MakePcrFlags(internal.SecureBootPolicyPCR),
 		expectedEvents: []*mockPcrBranchEvent{
 			{pcr: 7, eventType: mockPcrBranchResetEvent},
 			{pcr: 7, eventType: mockPcrBranchMeasureVariableEvent, varName: efi.VariableDescriptor{Name: "SecureBoot", GUID: efi.GlobalVariable}, varData: []byte{0x01}},
@@ -123,7 +124,7 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartSecureBootPolicyProfileInclude
 			IncludeDriverLaunch: true,
 		},
 		alg:  tpm2.HashAlgorithmSHA256,
-		pcrs: MakePcrFlags(SecureBootPolicyPCR),
+		pcrs: MakePcrFlags(internal.SecureBootPolicyPCR),
 		expectedEvents: []*mockPcrBranchEvent{
 			{pcr: 7, eventType: mockPcrBranchResetEvent},
 			{pcr: 7, eventType: mockPcrBranchMeasureVariableEvent, varName: efi.VariableDescriptor{Name: "SecureBoot", GUID: efi.GlobalVariable}, varData: []byte{0x01}},
@@ -144,7 +145,7 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartBootManagerCodeProfile(c *C) {
 		vars:       vars,
 		logOptions: &efitest.LogOptions{Algorithms: []tpm2.HashAlgorithmId{tpm2.HashAlgorithmSHA256, tpm2.HashAlgorithmSHA1}},
 		alg:        tpm2.HashAlgorithmSHA256,
-		pcrs:       MakePcrFlags(BootManagerCodePCR),
+		pcrs:       MakePcrFlags(internal.BootManagerCodePCR),
 		expectedEvents: []*mockPcrBranchEvent{
 			{pcr: 4, eventType: mockPcrBranchResetEvent},
 			{pcr: 4, eventType: mockPcrBranchExtendEvent, digest: testutil.DecodeHexString(c, "3d6772b4f84ed47595d72a2c4c5ffd15f5bb72c7507fe26f2aaee2c69d5633ba")},
@@ -164,7 +165,7 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartBootManagerCodeProfileWithoutC
 			NoCallingEFIApplicationEvent: true,
 		},
 		alg:  tpm2.HashAlgorithmSHA256,
-		pcrs: MakePcrFlags(BootManagerCodePCR),
+		pcrs: MakePcrFlags(internal.BootManagerCodePCR),
 		expectedEvents: []*mockPcrBranchEvent{
 			{pcr: 4, eventType: mockPcrBranchResetEvent},
 			{pcr: 4, eventType: mockPcrBranchExtendEvent, digest: testutil.DecodeHexString(c, "df3f619804a92fdb4057192dc43dd748ea778adc52bc498ce80524c014b81119")},
@@ -182,7 +183,7 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartBootManagerCodeProfileIncludeS
 			IncludeSysPrepAppLaunch: true,
 		},
 		alg:  tpm2.HashAlgorithmSHA256,
-		pcrs: MakePcrFlags(BootManagerCodePCR),
+		pcrs: MakePcrFlags(internal.BootManagerCodePCR),
 		expectedEvents: []*mockPcrBranchEvent{
 			{pcr: 4, eventType: mockPcrBranchResetEvent},
 			{pcr: 4, eventType: mockPcrBranchExtendEvent, digest: testutil.DecodeHexString(c, "11b68a5ce0facfa4233cb71140e3d59c686bc7a176a49a520947c57247fe86f4")},
@@ -203,7 +204,7 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartBootManagerCodeProfileIncludeA
 			IncludeOSPresentFirmwareAppLaunch: efi.MakeGUID(0x821aca26, 0x29ea, 0x4993, 0x839f, [...]byte{0x59, 0x7f, 0xc0, 0x21, 0x70, 0x8d}),
 		},
 		alg:  tpm2.HashAlgorithmSHA256,
-		pcrs: MakePcrFlags(BootManagerCodePCR),
+		pcrs: MakePcrFlags(internal.BootManagerCodePCR),
 		expectedEvents: []*mockPcrBranchEvent{
 			{pcr: 4, eventType: mockPcrBranchResetEvent},
 			{pcr: 4, eventType: mockPcrBranchExtendEvent, digest: testutil.DecodeHexString(c, "3d6772b4f84ed47595d72a2c4c5ffd15f5bb72c7507fe26f2aaee2c69d5633ba")},
@@ -224,7 +225,7 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartBootManagerCodeProfileIncludeA
 			IncludeOSPresentFirmwareAppLaunch: efi.MakeGUID(0x8feeecf1, 0xbcfd, 0x4a78, 0x9231, [...]byte{0x48, 0x01, 0x56, 0x6b, 0x35, 0x67}),
 		},
 		alg:  tpm2.HashAlgorithmSHA256,
-		pcrs: MakePcrFlags(BootManagerCodePCR),
+		pcrs: MakePcrFlags(internal.BootManagerCodePCR),
 		expectedEvents: []*mockPcrBranchEvent{
 			{pcr: 4, eventType: mockPcrBranchResetEvent},
 			{pcr: 4, eventType: mockPcrBranchExtendEvent, digest: testutil.DecodeHexString(c, "3d6772b4f84ed47595d72a2c4c5ffd15f5bb72c7507fe26f2aaee2c69d5633ba")},
@@ -246,7 +247,7 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartBootManagerCodeProfileIgnoreUn
 			IncludeOSPresentFirmwareAppLaunch: efi.MakeGUID(0xee993080, 0x5197, 0x4d4e, 0xb63c, [...]byte{0xf1, 0xf7, 0x41, 0x3e, 0x33, 0xce}),
 		},
 		alg:  tpm2.HashAlgorithmSHA256,
-		pcrs: MakePcrFlags(BootManagerCodePCR),
+		pcrs: MakePcrFlags(internal.BootManagerCodePCR),
 		expectedEvents: []*mockPcrBranchEvent{
 			{pcr: 4, eventType: mockPcrBranchResetEvent},
 			{pcr: 4, eventType: mockPcrBranchExtendEvent, digest: testutil.DecodeHexString(c, "3d6772b4f84ed47595d72a2c4c5ffd15f5bb72c7507fe26f2aaee2c69d5633ba")},
@@ -261,7 +262,7 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartSecureBootPolicyAndBootManager
 		vars:       vars,
 		logOptions: &efitest.LogOptions{Algorithms: []tpm2.HashAlgorithmId{tpm2.HashAlgorithmSHA256, tpm2.HashAlgorithmSHA1}},
 		alg:        tpm2.HashAlgorithmSHA256,
-		pcrs:       MakePcrFlags(BootManagerCodePCR, SecureBootPolicyPCR),
+		pcrs:       MakePcrFlags(internal.BootManagerCodePCR, internal.SecureBootPolicyPCR),
 		expectedEvents: []*mockPcrBranchEvent{
 			{pcr: 4, eventType: mockPcrBranchResetEvent},
 			{pcr: 7, eventType: mockPcrBranchResetEvent},
@@ -281,7 +282,7 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartPlatformFirmwareProfile(c *C)
 	s.testMeasureImageStart(c, &testFwMeasureImageStartData{
 		logOptions: &efitest.LogOptions{Algorithms: []tpm2.HashAlgorithmId{tpm2.HashAlgorithmSHA256, tpm2.HashAlgorithmSHA1}},
 		alg:        tpm2.HashAlgorithmSHA256,
-		pcrs:       MakePcrFlags(PlatformFirmwarePCR),
+		pcrs:       MakePcrFlags(internal.PlatformFirmwarePCR),
 		expectedEvents: []*mockPcrBranchEvent{
 			{pcr: 0, eventType: mockPcrBranchResetEvent},
 			{pcr: 0, eventType: mockPcrBranchExtendEvent, digest: testutil.DecodeHexString(c, "d0ff5974b6aa52cf562bea5921840c032a860a91a3512f7fe8f768f6bbe005f6")},
@@ -296,7 +297,7 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartPlatformFirmwareProfileSL3(c *
 	s.testMeasureImageStart(c, &testFwMeasureImageStartData{
 		logOptions: &efitest.LogOptions{Algorithms: []tpm2.HashAlgorithmId{tpm2.HashAlgorithmSHA256, tpm2.HashAlgorithmSHA1}, StartupLocality: 3},
 		alg:        tpm2.HashAlgorithmSHA256,
-		pcrs:       MakePcrFlags(PlatformFirmwarePCR),
+		pcrs:       MakePcrFlags(internal.PlatformFirmwarePCR),
 		expectedEvents: []*mockPcrBranchEvent{
 			{pcr: 0, eventType: mockPcrBranchResetCRTMPCREvent, locality: 3},
 			{pcr: 0, eventType: mockPcrBranchExtendEvent, digest: testutil.DecodeHexString(c, "d0ff5974b6aa52cf562bea5921840c032a860a91a3512f7fe8f768f6bbe005f6")},
@@ -311,7 +312,7 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartDriversAndAppsProfile(c *C) {
 	s.testMeasureImageStart(c, &testFwMeasureImageStartData{
 		logOptions: &efitest.LogOptions{Algorithms: []tpm2.HashAlgorithmId{tpm2.HashAlgorithmSHA256, tpm2.HashAlgorithmSHA1}},
 		alg:        tpm2.HashAlgorithmSHA256,
-		pcrs:       MakePcrFlags(DriversAndAppsPCR),
+		pcrs:       MakePcrFlags(internal.DriversAndAppsPCR),
 		expectedEvents: []*mockPcrBranchEvent{
 			{pcr: 2, eventType: mockPcrBranchResetEvent},
 			{pcr: 2, eventType: mockPcrBranchExtendEvent, digest: testutil.DecodeHexString(c, "df3f619804a92fdb4057192dc43dd748ea778adc52bc498ce80524c014b81119")},
@@ -323,7 +324,7 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartDriversAndAppsProfile2(c *C) {
 	s.testMeasureImageStart(c, &testFwMeasureImageStartData{
 		logOptions: &efitest.LogOptions{Algorithms: []tpm2.HashAlgorithmId{tpm2.HashAlgorithmSHA256, tpm2.HashAlgorithmSHA1}, IncludeDriverLaunch: true},
 		alg:        tpm2.HashAlgorithmSHA256,
-		pcrs:       MakePcrFlags(DriversAndAppsPCR),
+		pcrs:       MakePcrFlags(internal.DriversAndAppsPCR),
 		expectedEvents: []*mockPcrBranchEvent{
 			{pcr: 2, eventType: mockPcrBranchResetEvent},
 			{pcr: 2, eventType: mockPcrBranchExtendEvent, digest: testutil.DecodeHexString(c, "1e94aaed2ad59a4409f3230dca2ad8c03ef8e3fde77cc47dc7b81bb8b242f3e6")},
@@ -334,10 +335,10 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartDriversAndAppsProfile2(c *C) {
 
 func (s *fwLoadHandlerSuite) TestMeasureImageStartErrBadLogPCR7_1(c *C) {
 	// Insert a second EV_SEPARATOR event into PCR7
-	collector := NewRootVarsCollector(efitest.NewMockHostEnvironment(makeMockVars(c, withMsSecureBootConfig()), nil))
+	collector := NewVariableSetCollector(efitest.NewMockHostEnvironment(makeMockVars(c, withMsSecureBootConfig()), nil))
 	ctx := newMockPcrBranchContext(&mockPcrProfileContext{
 		alg:  tpm2.HashAlgorithmSHA256,
-		pcrs: MakePcrFlags(SecureBootPolicyPCR)}, nil, collector.Next())
+		pcrs: MakePcrFlags(internal.SecureBootPolicyPCR)}, nil, collector.Next())
 
 	log := efitest.NewLog(c, &efitest.LogOptions{Algorithms: []tpm2.HashAlgorithmId{tpm2.HashAlgorithmSHA256, tpm2.HashAlgorithmSHA1}})
 	for i, event := range log.Events {
@@ -358,10 +359,10 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartErrBadLogPCR7_1(c *C) {
 
 func (s *fwLoadHandlerSuite) TestMeasureImageStartErrBadLogPCR7_2(c *C) {
 	// Prepend a verification event into PCR7 before the EV_SEPARATOR
-	collector := NewRootVarsCollector(efitest.NewMockHostEnvironment(makeMockVars(c, withMsSecureBootConfig()), nil))
+	collector := NewVariableSetCollector(efitest.NewMockHostEnvironment(makeMockVars(c, withMsSecureBootConfig()), nil))
 	ctx := newMockPcrBranchContext(&mockPcrProfileContext{
 		alg:  tpm2.HashAlgorithmSHA256,
-		pcrs: MakePcrFlags(SecureBootPolicyPCR)}, nil, collector.Next())
+		pcrs: MakePcrFlags(internal.SecureBootPolicyPCR)}, nil, collector.Next())
 
 	log := efitest.NewLog(c, &efitest.LogOptions{Algorithms: []tpm2.HashAlgorithmId{tpm2.HashAlgorithmSHA256, tpm2.HashAlgorithmSHA1}})
 	for i, event := range log.Events {
@@ -385,10 +386,10 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartErrBadLogPCR7_2(c *C) {
 
 func (s *fwLoadHandlerSuite) TestMeasureImageStartErrBadLogPCR7_3(c *C) {
 	// Append a configuration event into PCR7 after the EV_SEPARATOR
-	collector := NewRootVarsCollector(efitest.NewMockHostEnvironment(makeMockVars(c, withMsSecureBootConfig()), nil))
+	collector := NewVariableSetCollector(efitest.NewMockHostEnvironment(makeMockVars(c, withMsSecureBootConfig()), nil))
 	ctx := newMockPcrBranchContext(&mockPcrProfileContext{
 		alg:  tpm2.HashAlgorithmSHA256,
-		pcrs: MakePcrFlags(SecureBootPolicyPCR)}, nil, collector.Next())
+		pcrs: MakePcrFlags(internal.SecureBootPolicyPCR)}, nil, collector.Next())
 
 	log := efitest.NewLog(c, &efitest.LogOptions{Algorithms: []tpm2.HashAlgorithmId{tpm2.HashAlgorithmSHA256, tpm2.HashAlgorithmSHA1}})
 	for i, event := range log.Events {
@@ -412,10 +413,10 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartErrBadLogPCR7_3(c *C) {
 
 func (s *fwLoadHandlerSuite) TestMeasureImageStartErrBadLogPCR7_4(c *C) {
 	// Insert an unexpected event type into PCR7
-	collector := NewRootVarsCollector(efitest.NewMockHostEnvironment(makeMockVars(c, withMsSecureBootConfig()), nil))
+	collector := NewVariableSetCollector(efitest.NewMockHostEnvironment(makeMockVars(c, withMsSecureBootConfig()), nil))
 	ctx := newMockPcrBranchContext(&mockPcrProfileContext{
 		alg:  tpm2.HashAlgorithmSHA256,
-		pcrs: MakePcrFlags(SecureBootPolicyPCR)}, nil, collector.Next())
+		pcrs: MakePcrFlags(internal.SecureBootPolicyPCR)}, nil, collector.Next())
 
 	log := efitest.NewLog(c, &efitest.LogOptions{Algorithms: []tpm2.HashAlgorithmId{tpm2.HashAlgorithmSHA256, tpm2.HashAlgorithmSHA1}})
 	for i, event := range log.Events {
@@ -439,10 +440,10 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartErrBadLogPCR7_4(c *C) {
 
 func (s *fwLoadHandlerSuite) TestMeasureImageStartErrBadLogPCR0_1(c *C) {
 	// Insert an invalid StartupLocality event data into the log
-	collector := NewRootVarsCollector(efitest.NewMockHostEnvironment(nil, nil))
+	collector := NewVariableSetCollector(efitest.NewMockHostEnvironment(nil, nil))
 	ctx := newMockPcrBranchContext(&mockPcrProfileContext{
 		alg:  tpm2.HashAlgorithmSHA256,
-		pcrs: MakePcrFlags(PlatformFirmwarePCR)}, nil, collector.Next())
+		pcrs: MakePcrFlags(internal.PlatformFirmwarePCR)}, nil, collector.Next())
 
 	log := efitest.NewLog(c, &efitest.LogOptions{
 		Algorithms:      []tpm2.HashAlgorithmId{tpm2.HashAlgorithmSHA256, tpm2.HashAlgorithmSHA1},
@@ -464,10 +465,10 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartErrBadLogPCR0_1(c *C) {
 
 func (s *fwLoadHandlerSuite) TestMeasureImageStartErrBadLogPCR0_2(c *C) {
 	// Insert an extra StartupLocality event data into the log
-	collector := NewRootVarsCollector(efitest.NewMockHostEnvironment(nil, nil))
+	collector := NewVariableSetCollector(efitest.NewMockHostEnvironment(nil, nil))
 	ctx := newMockPcrBranchContext(&mockPcrProfileContext{
 		alg:  tpm2.HashAlgorithmSHA256,
-		pcrs: MakePcrFlags(PlatformFirmwarePCR)}, nil, collector.Next())
+		pcrs: MakePcrFlags(internal.PlatformFirmwarePCR)}, nil, collector.Next())
 
 	log := efitest.NewLog(c, &efitest.LogOptions{
 		Algorithms:      []tpm2.HashAlgorithmId{tpm2.HashAlgorithmSHA256, tpm2.HashAlgorithmSHA1},
@@ -493,10 +494,10 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartErrBadLogPCR0_2(c *C) {
 
 func (s *fwLoadHandlerSuite) TestMeasureImageStartErrBadLogPCR4_1(c *C) {
 	// Insert an unexpected event type in the OS-present phase
-	collector := NewRootVarsCollector(efitest.NewMockHostEnvironment(nil, nil))
+	collector := NewVariableSetCollector(efitest.NewMockHostEnvironment(nil, nil))
 	ctx := newMockPcrBranchContext(&mockPcrProfileContext{
 		alg:  tpm2.HashAlgorithmSHA256,
-		pcrs: MakePcrFlags(BootManagerCodePCR)}, nil, collector.Next())
+		pcrs: MakePcrFlags(internal.BootManagerCodePCR)}, nil, collector.Next())
 
 	log := efitest.NewLog(c, &efitest.LogOptions{
 		Algorithms:                        []tpm2.HashAlgorithmId{tpm2.HashAlgorithmSHA256, tpm2.HashAlgorithmSHA1},
@@ -514,10 +515,10 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartErrBadLogPCR4_1(c *C) {
 
 func (s *fwLoadHandlerSuite) TestMeasureImageStartErrBadLogPCR4_2(c *C) {
 	// Insert invalid event data in the OS-present phase so that internal.IsAbsoluteAgentLaunch returns an error
-	collector := NewRootVarsCollector(efitest.NewMockHostEnvironment(nil, nil))
+	collector := NewVariableSetCollector(efitest.NewMockHostEnvironment(nil, nil))
 	ctx := newMockPcrBranchContext(&mockPcrProfileContext{
 		alg:  tpm2.HashAlgorithmSHA256,
-		pcrs: MakePcrFlags(BootManagerCodePCR)}, nil, collector.Next())
+		pcrs: MakePcrFlags(internal.BootManagerCodePCR)}, nil, collector.Next())
 
 	log := efitest.NewLog(c, &efitest.LogOptions{
 		Algorithms:                        []tpm2.HashAlgorithmId{tpm2.HashAlgorithmSHA256, tpm2.HashAlgorithmSHA1},
@@ -538,7 +539,7 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartErrBadLogPCR4_2(c *C) {
 
 func (s *fwLoadHandlerSuite) testMeasureImageStartErrBadLogSeparatorError(c *C, pcr tpm2.Handle) error {
 	// Insert an invalid error separator event into the log for the specified pcr
-	collector := NewRootVarsCollector(efitest.NewMockHostEnvironment(nil, nil))
+	collector := NewVariableSetCollector(efitest.NewMockHostEnvironment(nil, nil))
 	ctx := newMockPcrBranchContext(&mockPcrProfileContext{
 		alg:  tpm2.HashAlgorithmSHA256,
 		pcrs: MakePcrFlags(pcr)}, nil, collector.Next())
@@ -579,7 +580,7 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartErrBadLogSeparatorErrorPCR7(c
 
 func (s *fwLoadHandlerSuite) testMeasureImageStartErrBadLogInvalidSeparator(c *C, pcr tpm2.Handle) error {
 	// Insert an invalid separator event into the log for the specified PCR
-	collector := NewRootVarsCollector(efitest.NewMockHostEnvironment(nil, nil))
+	collector := NewVariableSetCollector(efitest.NewMockHostEnvironment(nil, nil))
 	ctx := newMockPcrBranchContext(&mockPcrProfileContext{
 		alg:  tpm2.HashAlgorithmSHA256,
 		pcrs: MakePcrFlags(pcr)}, nil, collector.Next())
@@ -620,7 +621,7 @@ func (s *fwLoadHandlerSuite) TestMeasureImageStartErrBadLogInvalidSeparatorPCR7(
 
 func (s *fwLoadHandlerSuite) testMeasureImageStartErrBadLogMissingSeparator(c *C, pcr tpm2.Handle) error {
 	// Remove the separator from the specified PCR
-	collector := NewRootVarsCollector(efitest.NewMockHostEnvironment(nil, nil))
+	collector := NewVariableSetCollector(efitest.NewMockHostEnvironment(nil, nil))
 	ctx := newMockPcrBranchContext(&mockPcrProfileContext{
 		alg:  tpm2.HashAlgorithmSHA256,
 		pcrs: MakePcrFlags(pcr)}, nil, collector.Next())
@@ -703,7 +704,7 @@ func (s *fwLoadHandlerSuite) TestMeasureImageLoadSecureBootPolicyProfile(c *C) {
 
 	s.testMeasureImageLoad(c, &testFwMeasureImageLoadData{
 		alg:   tpm2.HashAlgorithmSHA256,
-		pcrs:  MakePcrFlags(SecureBootPolicyPCR),
+		pcrs:  MakePcrFlags(internal.SecureBootPolicyPCR),
 		db:    msDb(c),
 		image: newMockImage().appendSignatures(efitest.ReadWinCertificateAuthenticodeDetached(c, shimUbuntuSig4)),
 		expectedEvents: []*mockPcrBranchEvent{
@@ -721,7 +722,7 @@ func (s *fwLoadHandlerSuite) TestMeasureImageLoadSecureBootPolicyProfileExisting
 
 	s.testMeasureImageLoad(c, &testFwMeasureImageLoadData{
 		alg:   tpm2.HashAlgorithmSHA256,
-		pcrs:  MakePcrFlags(SecureBootPolicyPCR),
+		pcrs:  MakePcrFlags(internal.SecureBootPolicyPCR),
 		db:    msDb(c),
 		fc:    fc,
 		image: newMockImage().appendSignatures(efitest.ReadWinCertificateAuthenticodeDetached(c, shimUbuntuSig4)),
@@ -731,7 +732,7 @@ func (s *fwLoadHandlerSuite) TestMeasureImageLoadSecureBootPolicyProfileExisting
 func (s *fwLoadHandlerSuite) TestMeasureImageLoadBootManagerCodeProfile1(c *C) {
 	s.testMeasureImageLoad(c, &testFwMeasureImageLoadData{
 		alg:   tpm2.HashAlgorithmSHA256,
-		pcrs:  MakePcrFlags(BootManagerCodePCR),
+		pcrs:  MakePcrFlags(internal.BootManagerCodePCR),
 		image: newMockImage().appendSignatures(efitest.ReadWinCertificateAuthenticodeDetached(c, shimUbuntuSig4)),
 		expectedEvents: []*mockPcrBranchEvent{
 			{pcr: 4, eventType: mockPcrBranchExtendEvent, digest: testutil.DecodeHexString(c, "bf6b6dfdb1f6435a81e4808db7f846d86d170566e4753d4384fdab6504be4fb9")},
@@ -742,7 +743,7 @@ func (s *fwLoadHandlerSuite) TestMeasureImageLoadBootManagerCodeProfile1(c *C) {
 func (s *fwLoadHandlerSuite) TestMeasureImageLoadBootManagerCodeProfile2(c *C) {
 	s.testMeasureImageLoad(c, &testFwMeasureImageLoadData{
 		alg:   tpm2.HashAlgorithmSHA256,
-		pcrs:  MakePcrFlags(BootManagerCodePCR),
+		pcrs:  MakePcrFlags(internal.BootManagerCodePCR),
 		image: newMockImage().appendSignatures(efitest.ReadWinCertificateAuthenticodeDetached(c, shimUbuntuSig3)),
 		expectedEvents: []*mockPcrBranchEvent{
 			{pcr: 4, eventType: mockPcrBranchExtendEvent, digest: testutil.DecodeHexString(c, "dbffd70a2c43fd2c1931f18b8f8c08c5181db15f996f747dfed34def52fad036")},
@@ -755,7 +756,7 @@ func (s *fwLoadHandlerSuite) TestMeasureImageLoadSecureBootPolicyAndBootManagerC
 
 	s.testMeasureImageLoad(c, &testFwMeasureImageLoadData{
 		alg:   tpm2.HashAlgorithmSHA256,
-		pcrs:  MakePcrFlags(BootManagerCodePCR, SecureBootPolicyPCR),
+		pcrs:  MakePcrFlags(internal.BootManagerCodePCR, internal.SecureBootPolicyPCR),
 		db:    msDb(c),
 		image: newMockImage().appendSignatures(efitest.ReadWinCertificateAuthenticodeDetached(c, shimUbuntuSig4)),
 		expectedEvents: []*mockPcrBranchEvent{
diff --git a/efi/grub_load_handler_test.go b/efi/grub_load_handler_test.go
index 5af1f4fc..a90d73ff 100644
--- a/efi/grub_load_handler_test.go
+++ b/efi/grub_load_handler_test.go
@@ -25,6 +25,7 @@ import (
 	efi "github.com/canonical/go-efilib"
 	"github.com/canonical/go-tpm2"
 	. "github.com/snapcore/secboot/efi"
+	"github.com/snapcore/secboot/efi/internal"
 	"github.com/snapcore/secboot/internal/efitest"
 	"github.com/snapcore/secboot/internal/testutil"
 )
@@ -42,7 +43,7 @@ var _ = Suite(&grubLoadHandlerSuite{})
 func (s *grubLoadHandlerSuite) TestMeasureImageLoadUbuntuUsesShim15_7(c *C) {
 	ctx := newMockPcrBranchContext(&mockPcrProfileContext{
 		alg:      tpm2.HashAlgorithmSHA256,
-		pcrs:     MakePcrFlags(SecureBootPolicyPCR),
+		pcrs:     MakePcrFlags(internal.SecureBootPolicyPCR),
 		handlers: s,
 	}, nil, nil)
 	ctx.FwContext().Db = &SecureBootDB{
@@ -71,7 +72,7 @@ func (s *grubLoadHandlerSuite) TestMeasureImageLoadUbuntuUsesShim15_7(c *C) {
 func (s *grubLoadHandlerSuite) TestMeasureImageLoadUbuntuUsesShim15_6(c *C) {
 	ctx := newMockPcrBranchContext(&mockPcrProfileContext{
 		alg:      tpm2.HashAlgorithmSHA256,
-		pcrs:     MakePcrFlags(SecureBootPolicyPCR),
+		pcrs:     MakePcrFlags(internal.SecureBootPolicyPCR),
 		handlers: s,
 	}, nil, nil)
 	ctx.FwContext().Db = &SecureBootDB{
@@ -100,7 +101,7 @@ func (s *grubLoadHandlerSuite) TestMeasureImageLoadUbuntuUsesShim15_6(c *C) {
 func (s *grubLoadHandlerSuite) TestMeasureImageLoadNoShim(c *C) {
 	ctx := newMockPcrBranchContext(&mockPcrProfileContext{
 		alg:      tpm2.HashAlgorithmSHA256,
-		pcrs:     MakePcrFlags(SecureBootPolicyPCR),
+		pcrs:     MakePcrFlags(internal.SecureBootPolicyPCR),
 		handlers: s,
 	}, nil, nil)
 	ctx.FwContext().Db = &SecureBootDB{
@@ -129,7 +130,7 @@ func (s *grubLoadHandlerSuite) TestMeasureImageLoadNoShim(c *C) {
 func (s *grubLoadHandlerSuite) TestMeasureImageLoadNoShimError(c *C) {
 	ctx := newMockPcrBranchContext(&mockPcrProfileContext{
 		alg:      tpm2.HashAlgorithmSHA256,
-		pcrs:     MakePcrFlags(SecureBootPolicyPCR),
+		pcrs:     MakePcrFlags(internal.SecureBootPolicyPCR),
 		handlers: s,
 	}, nil, nil)
 	ctx.FwContext().Db = &SecureBootDB{
diff --git a/efi/image_rules_defs.go b/efi/image_rules_defs.go
index 77845088..69c95baf 100644
--- a/efi/image_rules_defs.go
+++ b/efi/image_rules_defs.go
@@ -22,58 +22,25 @@ package efi
 import (
 	"crypto"
 	"crypto/x509"
+
+	"github.com/snapcore/secboot/efi/internal"
 )
 
 func makeMicrosoftUEFICASecureBootNamespaceRules() *secureBootNamespaceRules {
 	return newSecureBootNamespaceRules(
 		"Microsoft UEFI CA",
 		withAuthority(
-			// CN=Microsoft Corporation UEFI CA 2011,O=Microsoft Corporation,L=Redmond,ST=Washington,C=US
-			[]byte{
-				0x30, 0x81, 0x81, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55,
-				0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x13, 0x30, 0x11,
-				0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x0a, 0x57, 0x61, 0x73,
-				0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x31, 0x10, 0x30,
-				0x0e, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x07, 0x52, 0x65,
-				0x64, 0x6d, 0x6f, 0x6e, 0x64, 0x31, 0x1e, 0x30, 0x1c, 0x06,
-				0x03, 0x55, 0x04, 0x0a, 0x13, 0x15, 0x4d, 0x69, 0x63, 0x72,
-				0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x43, 0x6f, 0x72, 0x70,
-				0x6f, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x31, 0x2b, 0x30,
-				0x29, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x22, 0x4d, 0x69,
-				0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x43, 0x6f,
-				0x72, 0x70, 0x6f, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20,
-				0x55, 0x45, 0x46, 0x49, 0x20, 0x43, 0x41, 0x20, 0x32, 0x30,
-				0x31, 0x31,
-			},
-			// SKID
-			[]byte{
-				0x13, 0xad, 0xbf, 0x43, 0x09, 0xbd, 0x82, 0x70, 0x9c, 0x8c,
-				0xd5, 0x4f, 0x31, 0x6e, 0xd5, 0x22, 0x98, 0x8a, 0x1b, 0xd4,
-			},
-			// pubkey alg
-			x509.RSA,
+			internal.MSUefiCA2011.Subject,
+			internal.MSUefiCA2011.SubjectKeyId,
+			internal.MSUefiCA2011.PublicKeyAlgorithm,
 		),
 		// TODO(chrisccoulson): add tests for this when we find something that it's
 		// been used to sign and we have a signing certificate in the wild that we
 		// can add to embeds_test.go in order to create a mock shim with it
 		withAuthority(
-			// CN=Microsoft UEFI CA 2023,O=Microsoft Corporation,C=US
-			[]byte{
-				0x30, 0x4e, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04,
-				0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x1e, 0x30, 0x1c, 0x06,
-				0x03, 0x55, 0x04, 0x0a, 0x13, 0x15, 0x4d, 0x69, 0x63, 0x72,
-				0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x43, 0x6f, 0x72, 0x70,
-				0x6f, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x31, 0x1f, 0x30,
-				0x1d, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x16, 0x4d, 0x69,
-				0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x55, 0x45,
-				0x46, 0x49, 0x20, 0x43, 0x41, 0x20, 0x32, 0x30, 0x32, 0x33,
-			},
-			[]byte{
-				0x81, 0xaa, 0x6b, 0x32, 0x44, 0xc9, 0x35, 0xbc, 0xe0, 0xd6,
-				0x62, 0x8a, 0xf3, 0x98, 0x27, 0x42, 0x1e, 0x32, 0x49, 0x7d,
-			},
-			// pubkey alg
-			x509.RSA,
+			internal.MSUefiCA2023.Subject,
+			internal.MSUefiCA2023.SubjectKeyId,
+			internal.MSUefiCA2023.PublicKeyAlgorithm,
 		),
 		withSelfSignedSignerOnlyForTesting(
 			// O = Snake Oil
diff --git a/efi/internal/MicrosoftKEK.crt b/efi/internal/MicrosoftKEK.crt
new file mode 100644
index 00000000..37c814a7
--- /dev/null
+++ b/efi/internal/MicrosoftKEK.crt
@@ -0,0 +1,34 @@
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
diff --git a/efi/default_env.go b/efi/internal/default_env.go
similarity index 90%
rename from efi/default_env.go
rename to efi/internal/default_env.go
index 692a283f..e792cfde 100644
--- a/efi/default_env.go
+++ b/efi/internal/default_env.go
@@ -17,7 +17,7 @@
  *
  */
 
-package efi
+package internal
 
 import (
 	"os"
@@ -47,4 +47,6 @@ func (e defaultEnvImpl) ReadEventLog() (*tcglog.Log, error) {
 	return tcglog.ReadLog(f, &tcglog.LogOptions{})
 }
 
-var defaultEnv = defaultEnvImpl{}
+// DefaultEnv corresponds to the environment associated with the host
+// machine.
+var DefaultEnv = defaultEnvImpl{}
diff --git a/efi/default_env_test.go b/efi/internal/default_env_test.go
similarity index 80%
rename from efi/default_env_test.go
rename to efi/internal/default_env_test.go
index 777a1a9b..0fbc2215 100644
--- a/efi/default_env_test.go
+++ b/efi/internal/default_env_test.go
@@ -17,9 +17,10 @@
  *
  */
 
-package efi_test
+package internal_test
 
 import (
+	_ "embed"
 	"io"
 	"os"
 	"path/filepath"
@@ -27,12 +28,24 @@ import (
 	efi "github.com/canonical/go-efilib"
 	"github.com/canonical/go-tpm2"
 	"github.com/canonical/tcglog-parser"
-	. "github.com/snapcore/secboot/efi"
+	. "github.com/snapcore/secboot/efi/internal"
 	"github.com/snapcore/secboot/internal/efitest"
+	"github.com/snapcore/secboot/internal/testutil"
 
 	. "gopkg.in/check.v1"
 )
 
+var (
+	//go:embed MicrosoftKEK.crt
+	msKEKCertPEM []byte
+
+	msKEKCert []byte
+)
+
+func init() {
+	msKEKCert = testutil.MustDecodePEMType("CERTIFICATE", msKEKCertPEM)
+}
+
 type defaultEnvSuite struct{}
 
 var _ = Suite(&defaultEnvSuite{})
@@ -43,7 +56,22 @@ type testReadVarData struct {
 }
 
 func (s *defaultEnvSuite) testReadVar(c *C, data *testReadVarData) {
-	vars := makeMockVars(c, withMsSecureBootConfig())
+	ownerGuid := efi.MakeGUID(0x77fa9abd, 0x0359, 0x4d32, 0xbd60, [...]uint8{0x28, 0xf4, 0xe7, 0x8f, 0x78, 0x4b})
+	kek := &efi.SignatureList{
+		Type: efi.CertX509Guid,
+		Signatures: []*efi.SignatureData{
+			{
+				Owner: ownerGuid,
+				Data:  msKEKCert,
+			},
+		},
+	}
+	dbx := efitest.NewSignatureListNullSHA256(ownerGuid)
+	vars := efitest.MakeMockVars()
+	vars.SetSecureBoot(true)
+	vars.SetKEK(c, efi.SignatureDatabase{kek})
+	vars.SetDbx(c, efi.SignatureDatabase{dbx})
+
 	restore := MockReadVar(func(name string, guid efi.GUID) ([]byte, efi.VariableAttributes, error) {
 		entry, exists := vars[efi.VariableDescriptor{Name: name, GUID: guid}]
 		if !exists {
@@ -73,7 +101,7 @@ func (s *defaultEnvSuite) TestReadVar1(c *C) {
 
 func (s *defaultEnvSuite) TestReadVar2(c *C) {
 	s.testReadVar(c, &testReadVarData{
-		name: "PK",
+		name: "KEK",
 		guid: efi.GlobalVariable})
 }
 
diff --git a/efi/internal/export_test.go b/efi/internal/export_test.go
new file mode 100644
index 00000000..f2191a36
--- /dev/null
+++ b/efi/internal/export_test.go
@@ -0,0 +1,38 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2019-2024 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package internal
+
+import efi "github.com/canonical/go-efilib"
+
+func MockEventLogPath(path string) (restore func()) {
+	origPath := eventLogPath
+	eventLogPath = path
+	return func() {
+		eventLogPath = origPath
+	}
+}
+
+func MockReadVar(fn func(string, efi.GUID) ([]byte, efi.VariableAttributes, error)) (restore func()) {
+	origReadVar := readVar
+	readVar = fn
+	return func() {
+		readVar = origReadVar
+	}
+}
diff --git a/efi/internal/known_secureboot_cas.go b/efi/internal/known_secureboot_cas.go
new file mode 100644
index 00000000..a3a77587
--- /dev/null
+++ b/efi/internal/known_secureboot_cas.go
@@ -0,0 +1,83 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2024 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package internal
+
+import "crypto/x509"
+
+// SecureBootAuthorityIdentity corresponds to the identify of a secure boot
+// authority.
+type SecureBootAuthorityIdentity struct {
+	Subject            []byte
+	SubjectKeyId       []byte
+	PublicKeyAlgorithm x509.PublicKeyAlgorithm
+
+	Issuer             []byte
+	AuthorityKeyId     []byte
+	SignatureAlgorithm x509.SignatureAlgorithm
+}
+
+var (
+	// MSUefiCA2011 corresponds to the 2011 Microsoft UEFI CA
+	MSUefiCA2011 = &SecureBootAuthorityIdentity{
+		// CN=Microsoft Corporation UEFI CA 2011,O=Microsoft Corporation,L=Redmond,ST=Washington,C=US
+		Subject: []byte{
+			0x30, 0x81, 0x81, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55,
+			0x04, 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x13, 0x30, 0x11,
+			0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x0a, 0x57, 0x61, 0x73,
+			0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x31, 0x10, 0x30,
+			0x0e, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x07, 0x52, 0x65,
+			0x64, 0x6d, 0x6f, 0x6e, 0x64, 0x31, 0x1e, 0x30, 0x1c, 0x06,
+			0x03, 0x55, 0x04, 0x0a, 0x13, 0x15, 0x4d, 0x69, 0x63, 0x72,
+			0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x43, 0x6f, 0x72, 0x70,
+			0x6f, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x31, 0x2b, 0x30,
+			0x29, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x22, 0x4d, 0x69,
+			0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x43, 0x6f,
+			0x72, 0x70, 0x6f, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20,
+			0x55, 0x45, 0x46, 0x49, 0x20, 0x43, 0x41, 0x20, 0x32, 0x30,
+			0x31, 0x31,
+		},
+		SubjectKeyId: []byte{
+			0x13, 0xad, 0xbf, 0x43, 0x09, 0xbd, 0x82, 0x70, 0x9c, 0x8c,
+			0xd5, 0x4f, 0x31, 0x6e, 0xd5, 0x22, 0x98, 0x8a, 0x1b, 0xd4,
+		},
+		PublicKeyAlgorithm: x509.RSA,
+	}
+
+	// MSUefiCA2023 corresponds to the 2023 Microsoft UEFI CA, which will eventually
+	// replace the 2011 CA.
+	MSUefiCA2023 = &SecureBootAuthorityIdentity{
+		// CN=Microsoft UEFI CA 2023,O=Microsoft Corporation,C=US
+		Subject: []byte{
+			0x30, 0x4e, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04,
+			0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x1e, 0x30, 0x1c, 0x06,
+			0x03, 0x55, 0x04, 0x0a, 0x13, 0x15, 0x4d, 0x69, 0x63, 0x72,
+			0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x43, 0x6f, 0x72, 0x70,
+			0x6f, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x31, 0x1f, 0x30,
+			0x1d, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x16, 0x4d, 0x69,
+			0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x20, 0x55, 0x45,
+			0x46, 0x49, 0x20, 0x43, 0x41, 0x20, 0x32, 0x30, 0x32, 0x33,
+		},
+		SubjectKeyId: []byte{
+			0x81, 0xaa, 0x6b, 0x32, 0x44, 0xc9, 0x35, 0xbc, 0xe0, 0xd6,
+			0x62, 0x8a, 0xf3, 0x98, 0x27, 0x42, 0x1e, 0x32, 0x49, 0x7d,
+		},
+		PublicKeyAlgorithm: x509.RSA,
+	}
+)
diff --git a/efi/internal/options.go b/efi/internal/options.go
new file mode 100644
index 00000000..3402dac4
--- /dev/null
+++ b/efi/internal/options.go
@@ -0,0 +1,67 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2024 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package internal
+
+import (
+	efi "github.com/canonical/go-efilib"
+	"github.com/canonical/go-tpm2"
+	"github.com/canonical/tcglog-parser"
+)
+
+type InitialVariablesModifier func(VariableSet) error
+
+type PCRProfileOptionVisitor interface {
+	// AddPCRs adds the supplied PCRs to the profile.
+	AddPCRs(pcrs ...tpm2.Handle)
+
+	// SetEnvironment overrides the host environment to the supplied environment.
+	SetEnvironment(env HostEnvironment)
+
+	// AddInitialVariablesModifier adds a function that will be called to allow
+	// the initial variable set for profile generation to be modified.
+	AddInitialVariablesModifier(fn InitialVariablesModifier)
+}
+
+// HostEnvironment is an interface that abstracts out an EFI environment, so that
+// consumers of the API can provide a custom mechanism to read EFI variables or parse
+// the TCG event log. This needs to be kept in sync with [efi.HostEnvironment].
+type HostEnvironment interface {
+	// ReadVar reads the specified EFI variable
+	ReadVar(name string, guid efi.GUID) ([]byte, efi.VariableAttributes, error)
+
+	// ReadEventLog reads the TCG event log
+	ReadEventLog() (*tcglog.Log, error)
+}
+
+// VariableSet corresponds to a set of EFI variables.
+type VariableSet interface {
+	// ReadVar reads the specified EFI variable for this set.
+	ReadVar(name string, guid efi.GUID) ([]byte, efi.VariableAttributes, error)
+
+	// WriteVar updates the specified EFI variable for this set, for
+	// boot components that update variables. Each individual write
+	// creates a new intitial set of variables for which a profile will be
+	// generated against to accommodate interrupted sequences of writes.
+	WriteVar(name string, guid efi.GUID, attrs efi.VariableAttributes, data []byte) error
+
+	// Clone creates a copy of this variable set to make it possible to create
+	// branches by setting variables to different values in each returned set.
+	Clone() VariableSet
+}
diff --git a/efi/internal/tcg_pcrs.go b/efi/internal/tcg_pcrs.go
new file mode 100644
index 00000000..16e786f6
--- /dev/null
+++ b/efi/internal/tcg_pcrs.go
@@ -0,0 +1,39 @@
+// -*- Mode: Go; indent-tabs-mode: t -*-
+
+/*
+ * Copyright (C) 2019 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package internal
+
+import "github.com/canonical/go-tpm2"
+
+const (
+	// PlatformFirmarePCR is the SRTM, POST BIOS, and Embedded Drivers PCR
+	PlatformFirmwarePCR tpm2.Handle = 0
+
+	// HostPlatformConfigPCR is the Host Platform Configuration PCR
+	HostPlatformConfigPCR tpm2.Handle = 1
+
+	// DriversAndAppsPCR is the UEFI Drivers and UEFI Applications PCR
+	DriversAndAppsPCR tpm2.Handle = 2
+
+	// BootManagerCodePCR is the Boot Manager Code and Boot Attempts PCR
+	BootManagerCodePCR tpm2.Handle = 4
+
+	// SecureBootPolicyPCR is the Secure Boot Policy Measurements PCR
+	SecureBootPolicyPCR tpm2.Handle = 7
+)
diff --git a/efi/pcr_branch_context.go b/efi/pcr_branch_context.go
index c993efec..24697241 100644
--- a/efi/pcr_branch_context.go
+++ b/efi/pcr_branch_context.go
@@ -24,6 +24,7 @@ import (
 	"github.com/canonical/go-tpm2"
 	"github.com/canonical/tcglog-parser"
 
+	"github.com/snapcore/secboot/efi/internal"
 	secboot_tpm2 "github.com/snapcore/secboot/tpm2"
 )
 
@@ -97,7 +98,7 @@ func (c *pcrBranchCtx) ResetPCR(pcr tpm2.Handle) {
 func (c *pcrBranchCtx) ResetCRTMPCR(locality uint8) {
 	value := make([]byte, c.PCRAlg().Size())
 	value[len(value)-1] = locality
-	c.branch.AddPCRValue(c.PCRAlg(), int(platformFirmwarePCR), value)
+	c.branch.AddPCRValue(c.PCRAlg(), int(internal.PlatformFirmwarePCR), value)
 }
 
 func (c *pcrBranchCtx) ExtendPCR(pcr tpm2.Handle, digest tpm2.Digest) {
diff --git a/efi/pcr_branch_context_test.go b/efi/pcr_branch_context_test.go
index 8913cb4c..71eb824e 100644
--- a/efi/pcr_branch_context_test.go
+++ b/efi/pcr_branch_context_test.go
@@ -76,7 +76,7 @@ func (s *pcrBranchContextSuite) TestPcrBranchCtxParamsSubBranch(c *C) {
 }
 
 func (s *pcrBranchContextSuite) TestPcrBranchCtxVars(c *C) {
-	vars := NewRootVarsCollector(efitest.NewMockHostEnvironment(efitest.MockVars{
+	vars := NewVariableSetCollector(efitest.NewMockHostEnvironment(efitest.MockVars{
 		{Name: "foo", GUID: efi.GlobalVariable}: {Payload: []byte{1}, Attrs: efi.AttributeNonVolatile | efi.AttributeBootserviceAccess},
 	}, nil)).Next()
 	bc := NewRootPcrBranchCtx(&mockPcrProfileContext{alg: tpm2.HashAlgorithmSHA256}, nil, new(LoadParams), vars)
@@ -96,7 +96,7 @@ func (s *pcrBranchContextSuite) TestPcrBranchCtxVars(c *C) {
 }
 
 func (s *pcrBranchContextSuite) TestPcrBranchCtxVarsSubBranch(c *C) {
-	vars := NewRootVarsCollector(efitest.NewMockHostEnvironment(efitest.MockVars{
+	vars := NewVariableSetCollector(efitest.NewMockHostEnvironment(efitest.MockVars{
 		{Name: "foo", GUID: efi.GlobalVariable}: {Payload: []byte{1}, Attrs: efi.AttributeNonVolatile | efi.AttributeBootserviceAccess},
 	}, nil)).Next()
 	bc := NewRootPcrBranchCtx(&mockPcrProfileContext{alg: tpm2.HashAlgorithmSHA256}, secboot_tpm2.NewPCRProtectionProfile().RootBranch(), new(LoadParams), vars)
diff --git a/efi/pcr_images_measurer_test.go b/efi/pcr_images_measurer_test.go
index f4bafe75..26de687a 100644
--- a/efi/pcr_images_measurer_test.go
+++ b/efi/pcr_images_measurer_test.go
@@ -45,7 +45,7 @@ func (s *pcrImagesMeasurerSuite) TestPcrImagesMeasurerMeasureOneLeaf(c *C) {
 	profile := secboot_tpm2.NewPCRProtectionProfile()
 
 	params := new(LoadParams)
-	vars := NewRootVarsCollector(efitest.NewMockHostEnvironment(efitest.MockVars{}, nil)).Next()
+	vars := NewVariableSetCollector(efitest.NewMockHostEnvironment(efitest.MockVars{}, nil)).Next()
 
 	h := crypto.SHA256.New()
 	io.WriteString(h, "foo")
@@ -94,7 +94,7 @@ func (s *pcrImagesMeasurerSuite) TestPcrImagesMeasurerTwoLeaf(c *C) {
 	profile := secboot_tpm2.NewPCRProtectionProfile()
 
 	params := new(LoadParams)
-	vars := NewRootVarsCollector(efitest.NewMockHostEnvironment(efitest.MockVars{}, nil)).Next()
+	vars := NewVariableSetCollector(efitest.NewMockHostEnvironment(efitest.MockVars{}, nil)).Next()
 
 	h := crypto.SHA256.New()
 	io.WriteString(h, "foo")
@@ -146,7 +146,7 @@ func (s *pcrImagesMeasurerSuite) TestPcrImagesMeasurerNonLeaf(c *C) {
 	profile := secboot_tpm2.NewPCRProtectionProfile()
 
 	params := new(LoadParams)
-	vars := NewRootVarsCollector(efitest.NewMockHostEnvironment(efitest.MockVars{}, nil)).Next()
+	vars := NewVariableSetCollector(efitest.NewMockHostEnvironment(efitest.MockVars{}, nil)).Next()
 
 	h := crypto.SHA256.New()
 	io.WriteString(h, "foo")
@@ -203,7 +203,7 @@ func (s *pcrImagesMeasurerSuite) TestPcrImagesMeasurerTwoNonLeaf(c *C) {
 	profile := secboot_tpm2.NewPCRProtectionProfile()
 
 	params := new(LoadParams)
-	vars := NewRootVarsCollector(efitest.NewMockHostEnvironment(efitest.MockVars{}, nil)).Next()
+	vars := NewVariableSetCollector(efitest.NewMockHostEnvironment(efitest.MockVars{}, nil)).Next()
 
 	h := crypto.SHA256.New()
 	io.WriteString(h, "foo1")
@@ -279,7 +279,7 @@ func (s *pcrImagesMeasurerSuite) TestPcrImagesMeasurerMeasureWithParams(c *C) {
 	profile := secboot_tpm2.NewPCRProtectionProfile()
 
 	params := new(LoadParams)
-	vars := NewRootVarsCollector(efitest.NewMockHostEnvironment(efitest.MockVars{}, nil)).Next()
+	vars := NewVariableSetCollector(efitest.NewMockHostEnvironment(efitest.MockVars{}, nil)).Next()
 
 	h := crypto.SHA256.New()
 	io.WriteString(h, "foo")
@@ -341,7 +341,7 @@ func (s *pcrImagesMeasurerSuite) TestPcrImagesMeasurerMeasureWithInheritedParams
 	profile := secboot_tpm2.NewPCRProtectionProfile()
 
 	params := &LoadParams{SnapModel: model}
-	vars := NewRootVarsCollector(efitest.NewMockHostEnvironment(efitest.MockVars{}, nil)).Next()
+	vars := NewVariableSetCollector(efitest.NewMockHostEnvironment(efitest.MockVars{}, nil)).Next()
 
 	h := crypto.SHA256.New()
 	io.WriteString(h, "foo")
@@ -395,7 +395,7 @@ func (s *pcrImagesMeasurerSuite) TestPcrImagesMeasurerMeasureWithVars(c *C) {
 	profile := secboot_tpm2.NewPCRProtectionProfile()
 
 	params := new(LoadParams)
-	vars := NewRootVarsCollector(efitest.NewMockHostEnvironment(efitest.MockVars{
+	vars := NewVariableSetCollector(efitest.NewMockHostEnvironment(efitest.MockVars{
 		{Name: "foo", GUID: testGuid1}: {Payload: []byte{1}, Attrs: efi.AttributeNonVolatile | efi.AttributeBootserviceAccess},
 	}, nil)).Next()
 
@@ -447,7 +447,7 @@ func (s *pcrImagesMeasurerSuite) TestPcrImagesMeasurerMeasureEnsureVarsAreCopied
 	profile := secboot_tpm2.NewPCRProtectionProfile()
 
 	params := new(LoadParams)
-	vars := NewRootVarsCollector(efitest.NewMockHostEnvironment(efitest.MockVars{
+	vars := NewVariableSetCollector(efitest.NewMockHostEnvironment(efitest.MockVars{
 		{Name: "foo", GUID: testGuid1}: {Payload: []byte{1}, Attrs: efi.AttributeNonVolatile | efi.AttributeBootserviceAccess},
 	}, nil)).Next()
 
@@ -504,7 +504,7 @@ func (s *pcrImagesMeasurerSuite) TestPcrImagesMeasurerMeasureWithFwContext(c *C)
 	profile := secboot_tpm2.NewPCRProtectionProfile()
 
 	params := new(LoadParams)
-	vars := NewRootVarsCollector(efitest.NewMockHostEnvironment(efitest.MockVars{}, nil)).Next()
+	vars := NewVariableSetCollector(efitest.NewMockHostEnvironment(efitest.MockVars{}, nil)).Next()
 
 	h := crypto.SHA256.New()
 	io.WriteString(h, "foo")
@@ -555,7 +555,7 @@ func (s *pcrImagesMeasurerSuite) TestPcrImagesMeasurerMeasureEnsureFwContextIsCo
 	profile := secboot_tpm2.NewPCRProtectionProfile()
 
 	params := new(LoadParams)
-	vars := NewRootVarsCollector(efitest.NewMockHostEnvironment(efitest.MockVars{}, nil)).Next()
+	vars := NewVariableSetCollector(efitest.NewMockHostEnvironment(efitest.MockVars{}, nil)).Next()
 
 	h := crypto.SHA256.New()
 	io.WriteString(h, "foo")
@@ -612,7 +612,7 @@ func (s *pcrImagesMeasurerSuite) TestPcrImagesMeasurerMeasureWithShimContext(c *
 	profile := secboot_tpm2.NewPCRProtectionProfile()
 
 	params := new(LoadParams)
-	vars := NewRootVarsCollector(efitest.NewMockHostEnvironment(efitest.MockVars{}, nil)).Next()
+	vars := NewVariableSetCollector(efitest.NewMockHostEnvironment(efitest.MockVars{}, nil)).Next()
 
 	h := crypto.SHA256.New()
 	io.WriteString(h, "foo")
@@ -663,7 +663,7 @@ func (s *pcrImagesMeasurerSuite) TestPcrImagesMeasurerMeasureEnsureShimContextIs
 	profile := secboot_tpm2.NewPCRProtectionProfile()
 
 	params := new(LoadParams)
-	vars := NewRootVarsCollector(efitest.NewMockHostEnvironment(efitest.MockVars{}, nil)).Next()
+	vars := NewVariableSetCollector(efitest.NewMockHostEnvironment(efitest.MockVars{}, nil)).Next()
 
 	h := crypto.SHA256.New()
 	io.WriteString(h, "foo")
diff --git a/efi/pcr_profile.go b/efi/pcr_profile.go
index 8057245a..f24b6cbf 100644
--- a/efi/pcr_profile.go
+++ b/efi/pcr_profile.go
@@ -21,43 +21,46 @@ package efi
 
 import (
 	"errors"
+	"fmt"
 
 	"github.com/canonical/go-tpm2"
 	"github.com/canonical/tcglog-parser"
+	"github.com/snapcore/secboot/efi/internal"
 	secboot_tpm2 "github.com/snapcore/secboot/tpm2"
 	"golang.org/x/xerrors"
 )
 
 // PCRProfileOption is an option for AddPCRProfile
 type PCRProfileOption interface {
-	applyOptionTo(gen *pcrProfileGenerator)
+	ApplyOptionTo(visitor internal.PCRProfileOptionVisitor) error
 }
 
 // PCRProfileEnablePCRsOption is an option for AddPCRProfile that adds one or more PCRs.
 type PCRProfileEnablePCRsOption interface {
 	PCRProfileOption
-	PCRs() tpm2.HandleList
+	PCRs() (tpm2.HandleList, error)
 }
 
-type pcrProfileSetPcrsOption struct {
+type pcrProfileSetPcrOption struct {
 	PCRProfileOption
-	pcrs pcrFlags
+	pcr tpm2.Handle
 }
 
-func newPcrProfileSetPcrsOption(pcrs pcrFlags) *pcrProfileSetPcrsOption {
-	out := &pcrProfileSetPcrsOption{
-		pcrs: pcrs,
+func newPcrProfileSetPcrOption(pcr tpm2.Handle) *pcrProfileSetPcrOption {
+	out := &pcrProfileSetPcrOption{
+		pcr: pcr,
 	}
 	out.PCRProfileOption = out
 	return out
 }
 
-func (o *pcrProfileSetPcrsOption) applyOptionTo(gen *pcrProfileGenerator) {
-	gen.pcrs |= o.pcrs
+func (o *pcrProfileSetPcrOption) ApplyOptionTo(visitor internal.PCRProfileOptionVisitor) error {
+	visitor.AddPCRs(o.pcr)
+	return nil
 }
 
-func (o *pcrProfileSetPcrsOption) PCRs() tpm2.HandleList {
-	return o.pcrs.PCRs()
+func (o *pcrProfileSetPcrOption) PCRs() (tpm2.HandleList, error) {
+	return tpm2.HandleList{o.pcr}, nil
 }
 
 // WithPlatformFirmwareProfile adds the SRTM, POST BIOS and Embedded Drivers
@@ -68,14 +71,14 @@ func (o *pcrProfileSetPcrsOption) PCRs() tpm2.HandleList {
 // hardware root of trust as opposed to being verified as authentic and prevented
 // from running otherwise.
 func WithPlatformFirmwareProfile() PCRProfileEnablePCRsOption {
-	return newPcrProfileSetPcrsOption(makePcrFlags(platformFirmwarePCR))
+	return newPcrProfileSetPcrOption(internal.PlatformFirmwarePCR)
 }
 
 // WithDriversAndAppsProfile adds the UEFI Drivers and UEFI Applications profile
 // (measured to PCR2). This is copied directly from the current host environment
 // configiguration.
 func WithDriversAndAppsProfile() PCRProfileEnablePCRsOption {
-	return newPcrProfileSetPcrsOption(makePcrFlags(driversAndAppsPCR))
+	return newPcrProfileSetPcrOption(internal.DriversAndAppsPCR)
 }
 
 // WithSecureBootPolicyProfile requests that the UEFI secure boot policy profile is
@@ -135,7 +138,7 @@ func WithDriversAndAppsProfile() PCRProfileEnablePCRsOption {
 // of these makes a policy inherently fragile because it is not possible to pre-generate
 // policy to accomodate updates of these components.
 func WithSecureBootPolicyProfile() PCRProfileEnablePCRsOption {
-	return newPcrProfileSetPcrsOption(makePcrFlags(secureBootPolicyPCR))
+	return newPcrProfileSetPcrOption(internal.SecureBootPolicyPCR)
 }
 
 // WithBootManagerCodeProfile requests that the UEFI boot manager code and boot attempts
@@ -171,7 +174,7 @@ func WithSecureBootPolicyProfile() PCRProfileEnablePCRsOption {
 // fail before performing a successful attempt, even if the images associated with the
 // successful attempt are included in this policy.
 func WithBootManagerCodeProfile() PCRProfileEnablePCRsOption {
-	return newPcrProfileSetPcrsOption(makePcrFlags(bootManagerCodePCR))
+	return newPcrProfileSetPcrOption(internal.BootManagerCodePCR)
 }
 
 // WithKernelConfigProfile adds the kernel config profile. This binds a policy to a
@@ -182,7 +185,7 @@ func WithBootManagerCodeProfile() PCRProfileEnablePCRsOption {
 // Snap models can be injected into the profile with [SnapModelParams]. Note that a model
 // assertion is mandatory for profiles that include a UKI for Ubuntu Core.
 func WithKernelConfigProfile() PCRProfileEnablePCRsOption {
-	return newPcrProfileSetPcrsOption(makePcrFlags(kernelConfigPCR))
+	return newPcrProfileSetPcrOption(kernelConfigPCR)
 }
 
 // AddPCRProfile adds a profile defined by the supplied options to the supplied
@@ -190,7 +193,10 @@ func WithKernelConfigProfile() PCRProfileEnablePCRsOption {
 // for the PCR digest. The generated profile is defined by the supplied load
 // sequences and options.
 func AddPCRProfile(pcrAlg tpm2.HashAlgorithmId, branch *secboot_tpm2.PCRProtectionProfileBranch, loadSequences *ImageLoadSequences, options ...PCRProfileOption) error {
-	gen := newPcrProfileGenerator(pcrAlg, loadSequences, options...)
+	gen, err := newPcrProfileGenerator(pcrAlg, loadSequences, options...)
+	if err != nil {
+		return err
+	}
 
 	if gen.pcrs == 0 {
 		return errors.New("must specify a profile to add")
@@ -224,23 +230,25 @@ type pcrProfileGenerator struct {
 	// of every possible EFI variable starting state, and is used for generating
 	// profiles that incorporate signature database updates and changest to
 	// SbatPolicy.
-	varModifiers []rootVarsModifier
+	varModifiers []internal.InitialVariablesModifier
 
 	// log is the host TCG log, which is read from the associated env.
 	log *tcglog.Log
 }
 
-func newPcrProfileGenerator(pcrAlg tpm2.HashAlgorithmId, loadSequences *ImageLoadSequences, options ...PCRProfileOption) *pcrProfileGenerator {
+func newPcrProfileGenerator(pcrAlg tpm2.HashAlgorithmId, loadSequences *ImageLoadSequences, options ...PCRProfileOption) (*pcrProfileGenerator, error) {
 	gen := &pcrProfileGenerator{
 		pcrAlg:        pcrAlg,
 		loadSequences: loadSequences,
-		env:           defaultEnv,
+		env:           internal.DefaultEnv,
 		handlers:      makeImageLoadHandlerMap(),
 	}
 	for _, opt := range options {
-		opt.applyOptionTo(gen)
+		if err := opt.ApplyOptionTo(gen); err != nil {
+			return nil, err
+		}
 	}
-	return gen
+	return gen, nil
 }
 
 func (g *pcrProfileGenerator) addPCRProfile(branch *secboot_tpm2.PCRProtectionProfileBranch) error {
@@ -255,12 +263,14 @@ func (g *pcrProfileGenerator) addPCRProfile(branch *secboot_tpm2.PCRProtectionPr
 
 	// Collect all of the starting EFI variable states that we need to
 	// generate branches for.
-	collector := newRootVarsCollector(g.env)
+	collector := newVariableSetCollector(g.env)
 
 	// Collect the starting EFI variable states from the supplied options
 	for i, mod := range g.varModifiers {
-		if err := mod(collector); err != nil {
-			return xerrors.Errorf("cannot process host variable modifier %d: %w", i, err)
+		for j, branch := range collector.PeekAll() {
+			if err := mod(branch); err != nil {
+				return fmt.Errorf("cannot process host variable modifier %d for initial branch %d: %w", i, j, err)
+			}
 		}
 	}
 
@@ -311,6 +321,20 @@ func (g *pcrProfileGenerator) addOnePCRProfileBranch(bp *secboot_tpm2.PCRProtect
 	return nil
 }
 
+// AddPCRs implements [internal.PCRProfileOptionVisitor.AddPCRs]
+func (g *pcrProfileGenerator) AddPCRs(pcrs ...tpm2.Handle) {
+	g.pcrs |= makePcrFlags(pcrs...)
+}
+
+// SetEnvironment implements [internal.PCRProfileOptionVisitor.SetEnvironment]
+func (g *pcrProfileGenerator) SetEnvironment(env internal.HostEnvironment) {
+	g.env = env
+}
+
+func (g *pcrProfileGenerator) AddInitialVariablesModifier(fn internal.InitialVariablesModifier) {
+	g.varModifiers = append(g.varModifiers, fn)
+}
+
 // PCRAlg implements pcrProfileContext.PCRAlg.
 func (g *pcrProfileGenerator) PCRAlg() tpm2.HashAlgorithmId {
 	return g.pcrAlg
diff --git a/efi/pcr_profile_test.go b/efi/pcr_profile_test.go
index 9ec6f5e2..b2f578ac 100644
--- a/efi/pcr_profile_test.go
+++ b/efi/pcr_profile_test.go
@@ -34,6 +34,7 @@ import (
 	. "gopkg.in/check.v1"
 
 	. "github.com/snapcore/secboot/efi"
+	"github.com/snapcore/secboot/efi/internal"
 	"github.com/snapcore/secboot/internal/efitest"
 	"github.com/snapcore/secboot/internal/testutil"
 	"github.com/snapcore/secboot/internal/tpm2test"
@@ -75,27 +76,27 @@ func (s *pcrProfileMockedSuite) TearDownSuite(c *C) {
 var _ = Suite(&pcrProfileMockedSuite{})
 
 func (s *pcrProfileMockedSuite) TestPcrProfileGeneratorPCRAlg(c *C) {
-	gen := NewPcrProfileGenerator(tpm2.HashAlgorithmSHA256, NewImageLoadSequences())
+	gen, _ := NewPcrProfileGenerator(tpm2.HashAlgorithmSHA256, NewImageLoadSequences())
 	c.Check(gen.PCRAlg(), Equals, tpm2.HashAlgorithmSHA256)
 }
 
 func (s *pcrProfileMockedSuite) TestPcrProfileGeneratorPCRAlgSHA1(c *C) {
-	gen := NewPcrProfileGenerator(tpm2.HashAlgorithmSHA1, NewImageLoadSequences())
+	gen, _ := NewPcrProfileGenerator(tpm2.HashAlgorithmSHA1, NewImageLoadSequences())
 	c.Check(gen.PCRAlg(), Equals, tpm2.HashAlgorithmSHA1)
 }
 
 func (s *pcrProfileMockedSuite) TestWithSecureBootPolicyProfile(c *C) {
-	gen := NewPcrProfileGenerator(tpm2.HashAlgorithmSHA256, NewImageLoadSequences(), WithSecureBootPolicyProfile())
-	c.Check(gen.PCRs(), Equals, PcrFlags(1<<SecureBootPolicyPCR))
+	gen, _ := NewPcrProfileGenerator(tpm2.HashAlgorithmSHA256, NewImageLoadSequences(), WithSecureBootPolicyProfile())
+	c.Check(gen.PCRs(), Equals, PcrFlags(1<<internal.SecureBootPolicyPCR))
 }
 
 func (s *pcrProfileMockedSuite) TestWithBootManagerCodeProfile(c *C) {
-	gen := NewPcrProfileGenerator(tpm2.HashAlgorithmSHA256, NewImageLoadSequences(), WithBootManagerCodeProfile())
-	c.Check(gen.PCRs(), Equals, PcrFlags(1<<BootManagerCodePCR))
+	gen, _ := NewPcrProfileGenerator(tpm2.HashAlgorithmSHA256, NewImageLoadSequences(), WithBootManagerCodeProfile())
+	c.Check(gen.PCRs(), Equals, PcrFlags(1<<internal.BootManagerCodePCR))
 }
 
 func (s *pcrProfileMockedSuite) TestPcrProfileGeneratorImageLoadHandlers(c *C) {
-	gen := NewPcrProfileGenerator(tpm2.HashAlgorithmSHA256, NewImageLoadSequences())
+	gen, _ := NewPcrProfileGenerator(tpm2.HashAlgorithmSHA256, NewImageLoadSequences())
 	c.Check(gen.ImageLoadHandlerMap(), Equals, s)
 }
 
@@ -520,16 +521,20 @@ func (s *pcrProfileMockedSuite) TestAddPCRProfileWithVariableModifier(c *C) {
 			),
 		),
 	)
+
+	initialVarSets := 0
 	c.Check(AddPCRProfile(tpm2.HashAlgorithmSHA256, profile.RootBranch(), sequences,
 		WithHostEnvironment(efitest.NewMockHostEnvironment(efitest.MockVars{
 			{Name: "foo", GUID: testGuid1}: {Payload: []byte{1}, Attrs: efi.AttributeNonVolatile | efi.AttributeBootserviceAccess},
 		}, new(tcglog.Log))),
 		WithSecureBootPolicyProfile(),
-		WithMockRootVarsModifierOption(func(vars *RootVarsCollector) error {
-			c.Check(vars.PeekAll()[0].WriteVar("foo", testGuid1, efi.AttributeNonVolatile|efi.AttributeBootserviceAccess, []byte{2}), IsNil)
+		WithMockInitialVariablesModifierOption(func(vars internal.VariableSet) error {
+			c.Check(vars.WriteVar("foo", testGuid1, efi.AttributeNonVolatile|efi.AttributeBootserviceAccess, []byte{2}), IsNil)
+			initialVarSets += 1
 			return nil
 		}),
 	), IsNil)
+	c.Check(initialVarSets, Equals, 1)
 
 	c.Check(profile.String(), Equals, fmt.Sprintf(`
  BranchPoint(
@@ -576,10 +581,10 @@ func (s *pcrProfileMockedSuite) TestAddPCRProfileWithVariableModifierErr(c *C) {
 			{Name: "foo", GUID: testGuid1}: {Payload: []byte{1}, Attrs: efi.AttributeNonVolatile | efi.AttributeBootserviceAccess},
 		}, new(tcglog.Log))),
 		WithSecureBootPolicyProfile(),
-		WithMockRootVarsModifierOption(func(vars *RootVarsCollector) error {
+		WithMockInitialVariablesModifierOption(func(vars internal.VariableSet) error {
 			return errors.New("some error")
 		}),
-	), ErrorMatches, `cannot process host variable modifier 0: some error`)
+	), ErrorMatches, `cannot process host variable modifier 0 for initial branch 0: some error`)
 }
 
 type pcrProfileSuite struct {
diff --git a/efi/secureboot.go b/efi/secureboot.go
index 334438ce..346c0c05 100644
--- a/efi/secureboot.go
+++ b/efi/secureboot.go
@@ -23,9 +23,11 @@ import (
 	"bytes"
 	"crypto/x509"
 	"errors"
+	"fmt"
 	"io/ioutil"
 
 	efi "github.com/canonical/go-efilib"
+	"github.com/snapcore/secboot/efi/internal"
 	"golang.org/x/xerrors"
 )
 
@@ -51,25 +53,25 @@ type SignatureDBUpdate struct {
 
 type signatureDBUpdatesOption []*SignatureDBUpdate
 
-func (u signatureDBUpdatesOption) applyOptionTo(gen *pcrProfileGenerator) {
-	gen.varModifiers = append(gen.varModifiers, func(rootVars *rootVarsCollector) error {
-		for _, root := range rootVars.PeekAll() {
-			for _, quirk := range []signatureDBUpdateFirmwareQuirk{
-				signatureDBUpdateNoFirmwareQuirk,
-				signatureDBUpdateFirmwareDedupIgnoresOwner} {
-				// create a branch per quirk by copying the root varBranch
-				branch := *root
-
-				// This creates a root variable instance for each intermediate state.
-				for i, update := range u {
-					if err := applySignatureDBUpdate(&branch, update, quirk); err != nil {
-						return xerrors.Errorf("cannot compute signature database update %d: %w", i, err)
-					}
+func (u signatureDBUpdatesOption) ApplyOptionTo(visitor internal.PCRProfileOptionVisitor) error {
+	visitor.AddInitialVariablesModifier(func(vars internal.VariableSet) error {
+		for _, quirk := range []signatureDBUpdateFirmwareQuirk{
+			signatureDBUpdateNoFirmwareQuirk,
+			signatureDBUpdateFirmwareDedupIgnoresOwner} {
+
+			// Create a branch in the variable set
+			branch := vars.Clone()
+
+			// This creates an initial variable set for each intermediate state.
+			for i, update := range u {
+				if err := applySignatureDBUpdate(branch, update, quirk); err != nil {
+					return fmt.Errorf("cannot compute signature database update %d: %w", i, err)
 				}
 			}
 		}
 		return nil
 	})
+	return nil
 }
 
 // WithSignatureDBUpdates can be supplied to AddPCRProfile to compute the profile
diff --git a/efi/secureboot_namespace_rules.go b/efi/secureboot_namespace_rules.go
index 6d0322a8..73ba06cb 100644
--- a/efi/secureboot_namespace_rules.go
+++ b/efi/secureboot_namespace_rules.go
@@ -23,6 +23,7 @@ import (
 	"bytes"
 	"crypto/x509"
 
+	"github.com/snapcore/secboot/efi/internal"
 	"github.com/snapcore/snapd/snapdenv"
 	"golang.org/x/xerrors"
 )
@@ -44,24 +45,16 @@ type vendorAuthorityGetter interface {
 
 // secureBootAuthorityIdentity corresponds to the identify of a secure boot
 // authority. A secure boot namespace has one or more of these.
-type secureBootAuthorityIdentity struct {
-	subject            []byte
-	subjectKeyId       []byte
-	publicKeyAlgorithm x509.PublicKeyAlgorithm
-
-	issuer             []byte
-	authorityKeyId     []byte
-	signatureAlgorithm x509.SignatureAlgorithm
-}
+type secureBootAuthorityIdentity = internal.SecureBootAuthorityIdentity
 
 // withAuthority adds the specified secure boot authority to a secureBootNamespaceRules.
 // Note that this won't match if the specified authority directly signs things.
 func withAuthority(subject, subjectKeyId []byte, publicKeyAlgorithm x509.PublicKeyAlgorithm) secureBootNamespaceOption {
 	return func(ns *secureBootNamespaceRules) {
 		ns.authorities = append(ns.authorities, &secureBootAuthorityIdentity{
-			subject:            subject,
-			subjectKeyId:       subjectKeyId,
-			publicKeyAlgorithm: publicKeyAlgorithm})
+			Subject:            subject,
+			SubjectKeyId:       subjectKeyId,
+			PublicKeyAlgorithm: publicKeyAlgorithm})
 	}
 }
 
@@ -76,12 +69,12 @@ func withSelfSignedSignerOnlyForTesting(subject, subjectKeyId []byte, publicKeyA
 	}
 	return func(ns *secureBootNamespaceRules) {
 		ns.authorities = append(ns.authorities, &secureBootAuthorityIdentity{
-			subject:            subject,
-			subjectKeyId:       subjectKeyId,
-			publicKeyAlgorithm: publicKeyAlgorithm,
-			issuer:             subject,
-			authorityKeyId:     subjectKeyId,
-			signatureAlgorithm: signatureAlgorithm})
+			Subject:            subject,
+			SubjectKeyId:       subjectKeyId,
+			PublicKeyAlgorithm: publicKeyAlgorithm,
+			Issuer:             subject,
+			AuthorityKeyId:     subjectKeyId,
+			SignatureAlgorithm: signatureAlgorithm})
 	}
 }
 
@@ -130,24 +123,24 @@ func (r *secureBootNamespaceRules) AddAuthorities(certs ...*x509.Certificate) {
 		// have a minimal set of fields populated and we don't try to handle that case.
 		found := false
 		for _, authority := range r.authorities {
-			if bytes.Equal(authority.subject, cert.RawSubject) &&
-				bytes.Equal(authority.subjectKeyId, cert.SubjectKeyId) &&
-				authority.publicKeyAlgorithm == cert.PublicKeyAlgorithm &&
-				bytes.Equal(authority.issuer, cert.RawIssuer) &&
-				bytes.Equal(authority.authorityKeyId, cert.AuthorityKeyId) &&
-				authority.signatureAlgorithm == cert.SignatureAlgorithm {
+			if bytes.Equal(authority.Subject, cert.RawSubject) &&
+				bytes.Equal(authority.SubjectKeyId, cert.SubjectKeyId) &&
+				authority.PublicKeyAlgorithm == cert.PublicKeyAlgorithm &&
+				bytes.Equal(authority.Issuer, cert.RawIssuer) &&
+				bytes.Equal(authority.AuthorityKeyId, cert.AuthorityKeyId) &&
+				authority.SignatureAlgorithm == cert.SignatureAlgorithm {
 				found = true
 				break
 			}
 		}
 		if !found {
 			r.authorities = append(r.authorities, &secureBootAuthorityIdentity{
-				subject:            cert.RawSubject,
-				subjectKeyId:       cert.SubjectKeyId,
-				publicKeyAlgorithm: cert.PublicKeyAlgorithm,
-				issuer:             cert.RawIssuer,
-				authorityKeyId:     cert.AuthorityKeyId,
-				signatureAlgorithm: cert.SignatureAlgorithm,
+				Subject:            cert.RawSubject,
+				SubjectKeyId:       cert.SubjectKeyId,
+				PublicKeyAlgorithm: cert.PublicKeyAlgorithm,
+				Issuer:             cert.RawIssuer,
+				AuthorityKeyId:     cert.AuthorityKeyId,
+				SignatureAlgorithm: cert.SignatureAlgorithm,
 			})
 		}
 	}
@@ -164,12 +157,12 @@ func (r *secureBootNamespaceRules) NewImageLoadHandler(image peImageHandle) (ima
 
 	for _, authority := range r.authorities {
 		cert := &x509.Certificate{
-			RawSubject:         authority.subject,
-			SubjectKeyId:       authority.subjectKeyId,
-			PublicKeyAlgorithm: authority.publicKeyAlgorithm,
-			RawIssuer:          authority.issuer,
-			AuthorityKeyId:     authority.authorityKeyId,
-			SignatureAlgorithm: authority.signatureAlgorithm}
+			RawSubject:         authority.Subject,
+			SubjectKeyId:       authority.SubjectKeyId,
+			PublicKeyAlgorithm: authority.PublicKeyAlgorithm,
+			RawIssuer:          authority.Issuer,
+			AuthorityKeyId:     authority.AuthorityKeyId,
+			SignatureAlgorithm: authority.SignatureAlgorithm}
 		for _, sig := range sigs {
 			if !sig.CertLikelyTrustAnchor(cert) {
 				continue
diff --git a/efi/secureboot_test.go b/efi/secureboot_test.go
index 2e35e257..5589893b 100644
--- a/efi/secureboot_test.go
+++ b/efi/secureboot_test.go
@@ -193,7 +193,7 @@ type testApplySignatureDBUpdateData struct {
 }
 
 func (s *securebootSuite) testApplySignatureDBUpdate(c *C, data *testApplySignatureDBUpdateData) {
-	collector := NewRootVarsCollector(efitest.NewMockHostEnvironment(data.vars, nil))
+	collector := NewVariableSetCollector(efitest.NewMockHostEnvironment(data.vars, nil))
 	vars := collector.Next()
 
 	orig, origAttrs, err := vars.ReadVar(data.update.Name.Name, data.update.Name.GUID)
@@ -412,7 +412,7 @@ func (s *securebootSuite) TestApplySignatureDBUpdatePK(c *C) {
 
 	update := &SignatureDBUpdate{Name: PK, Data: pkAuth}
 
-	collector := NewRootVarsCollector(efitest.NewMockHostEnvironment(makeMockVars(c, withMsSecureBootConfig()), nil))
+	collector := NewVariableSetCollector(efitest.NewMockHostEnvironment(makeMockVars(c, withMsSecureBootConfig()), nil))
 	vars := collector.Next()
 
 	c.Assert(ApplySignatureDBUpdate(vars, update, SignatureDBUpdateNoFirmwareQuirk), IsNil)
@@ -426,3 +426,218 @@ func (s *securebootSuite) TestApplySignatureDBUpdatePK(c *C) {
 
 	c.Check(data, DeepEquals, efitest.MakeVarPayload(c, pk))
 }
+
+type expectedSignatureDBSet struct {
+	pkSha1  []byte
+	kekSha1 []byte
+	dbSha1  []byte
+	dbxSha1 []byte
+}
+
+type testWithSignatureDBUpdatesParams struct {
+	env      HostEnvironment
+	updates  []*SignatureDBUpdate
+	expected []expectedSignatureDBSet
+}
+
+func (s *securebootSuite) testWithSignatureDBUpdates(c *C, params *testWithSignatureDBUpdatesParams) {
+	visitor := new(mockPcrProfileOptionVisitor)
+	opt := WithSignatureDBUpdates(params.updates...)
+	c.Check(opt.ApplyOptionTo(visitor), IsNil)
+
+	c.Assert(visitor.varModifiers, HasLen, 1)
+
+	collector := NewVariableSetCollector(params.env)
+	c.Check(visitor.varModifiers[0](collector.PeekAll()[0]), IsNil)
+
+	logDetails := func(desc efi.VariableDescriptor, data []byte, sha1 []byte) {
+		c.Logf("Variable: %v", desc)
+		db, err := efi.ReadSignatureDatabase(bytes.NewReader(data))
+		c.Assert(err, IsNil)
+		c.Logf("Database: %v", db)
+		c.Logf("SHA1: %#x", sha1)
+	}
+
+	expectedSets := params.expected
+	for collector.More() {
+		c.Assert(expectedSets, Not(HasLen), 0)
+		expected := expectedSets[0]
+		expectedSets = expectedSets[1:]
+
+		vars := collector.Next()
+
+		data, _, err := vars.ReadVar(PK.Name, PK.GUID)
+		c.Check(err, IsNil)
+		h := crypto.SHA1.New()
+		h.Write(data)
+		c.Check(h.Sum(nil), DeepEquals, expected.pkSha1)
+		logDetails(PK, data, h.Sum(nil))
+
+		data, _, err = vars.ReadVar(KEK.Name, KEK.GUID)
+		c.Check(err, IsNil)
+		h = crypto.SHA1.New()
+		h.Write(data)
+		c.Check(h.Sum(nil), DeepEquals, expected.kekSha1)
+		logDetails(KEK, data, h.Sum(nil))
+
+		data, _, err = vars.ReadVar(Db.Name, Db.GUID)
+		c.Check(err, IsNil)
+		h = crypto.SHA1.New()
+		h.Write(data)
+		c.Check(h.Sum(nil), DeepEquals, expected.dbSha1)
+		logDetails(Db, data, h.Sum(nil))
+
+		data, _, err = vars.ReadVar(Dbx.Name, Dbx.GUID)
+		c.Check(err, IsNil)
+		h = crypto.SHA1.New()
+		h.Write(data)
+		c.Check(h.Sum(nil), DeepEquals, expected.dbxSha1)
+		logDetails(Dbx, data, h.Sum(nil))
+	}
+	c.Check(expectedSets, HasLen, 0)
+}
+
+func (s *securebootSuite) TestWithSignatureDBUpdatesMsDbxUpdate1(c *C) {
+	s.testWithSignatureDBUpdates(c, &testWithSignatureDBUpdatesParams{
+		env:     efitest.NewMockHostEnvironment(makeMockVars(c, withMsSecureBootConfig()), nil),
+		updates: []*SignatureDBUpdate{{Name: Dbx, Data: msDbxUpdate1}},
+		expected: []expectedSignatureDBSet{
+			{
+				pkSha1:  testutil.DecodeHexString(c, "ce1354eb31a3ff82cc5e517133b87c209e5b3a5b"),
+				kekSha1: testutil.DecodeHexString(c, "0c7071d32c1a385cca9e07d9252dfc97f21c5ce3"),
+				dbSha1:  testutil.DecodeHexString(c, "0eb693bfd2699c09a4d6e96828d332a79de404bb"),
+				dbxSha1: testutil.DecodeHexString(c, "a922e52bfc71da51714c3765eda70886c3966503"),
+			},
+			{
+				pkSha1:  testutil.DecodeHexString(c, "ce1354eb31a3ff82cc5e517133b87c209e5b3a5b"),
+				kekSha1: testutil.DecodeHexString(c, "0c7071d32c1a385cca9e07d9252dfc97f21c5ce3"),
+				dbSha1:  testutil.DecodeHexString(c, "0eb693bfd2699c09a4d6e96828d332a79de404bb"),
+				dbxSha1: testutil.DecodeHexString(c, "45cd62f8fc2a45e835ce76db192c6db382c83286"),
+			},
+		},
+	})
+}
+
+func (s *securebootSuite) TestWithSignatureDBUpdatesMsDbxUpdate2(c *C) {
+	s.testWithSignatureDBUpdates(c, &testWithSignatureDBUpdatesParams{
+		env:     efitest.NewMockHostEnvironment(makeMockVars(c, withMsSecureBootConfig()), nil),
+		updates: []*SignatureDBUpdate{{Name: Dbx, Data: msDbxUpdate2}},
+		expected: []expectedSignatureDBSet{
+			{
+				pkSha1:  testutil.DecodeHexString(c, "ce1354eb31a3ff82cc5e517133b87c209e5b3a5b"),
+				kekSha1: testutil.DecodeHexString(c, "0c7071d32c1a385cca9e07d9252dfc97f21c5ce3"),
+				dbSha1:  testutil.DecodeHexString(c, "0eb693bfd2699c09a4d6e96828d332a79de404bb"),
+				dbxSha1: testutil.DecodeHexString(c, "a922e52bfc71da51714c3765eda70886c3966503"),
+			},
+			{
+				pkSha1:  testutil.DecodeHexString(c, "ce1354eb31a3ff82cc5e517133b87c209e5b3a5b"),
+				kekSha1: testutil.DecodeHexString(c, "0c7071d32c1a385cca9e07d9252dfc97f21c5ce3"),
+				dbSha1:  testutil.DecodeHexString(c, "0eb693bfd2699c09a4d6e96828d332a79de404bb"),
+				dbxSha1: testutil.DecodeHexString(c, "ba6baeecaa4cad2c2820fdc7fda08269c48afd98"),
+			},
+		},
+	})
+}
+
+func (s *securebootSuite) TestWithSignatureDBUpdatesMsDbxUpdate1And2(c *C) {
+	s.testWithSignatureDBUpdates(c, &testWithSignatureDBUpdatesParams{
+		env: efitest.NewMockHostEnvironment(makeMockVars(c, withMsSecureBootConfig()), nil),
+		updates: []*SignatureDBUpdate{
+			{Name: Dbx, Data: msDbxUpdate1},
+			{Name: Dbx, Data: msDbxUpdate2},
+		},
+		expected: []expectedSignatureDBSet{
+			{
+				pkSha1:  testutil.DecodeHexString(c, "ce1354eb31a3ff82cc5e517133b87c209e5b3a5b"),
+				kekSha1: testutil.DecodeHexString(c, "0c7071d32c1a385cca9e07d9252dfc97f21c5ce3"),
+				dbSha1:  testutil.DecodeHexString(c, "0eb693bfd2699c09a4d6e96828d332a79de404bb"),
+				dbxSha1: testutil.DecodeHexString(c, "a922e52bfc71da51714c3765eda70886c3966503"),
+			},
+			{
+				pkSha1:  testutil.DecodeHexString(c, "ce1354eb31a3ff82cc5e517133b87c209e5b3a5b"),
+				kekSha1: testutil.DecodeHexString(c, "0c7071d32c1a385cca9e07d9252dfc97f21c5ce3"),
+				dbSha1:  testutil.DecodeHexString(c, "0eb693bfd2699c09a4d6e96828d332a79de404bb"),
+				dbxSha1: testutil.DecodeHexString(c, "45cd62f8fc2a45e835ce76db192c6db382c83286"),
+			},
+			{
+				pkSha1:  testutil.DecodeHexString(c, "ce1354eb31a3ff82cc5e517133b87c209e5b3a5b"),
+				kekSha1: testutil.DecodeHexString(c, "0c7071d32c1a385cca9e07d9252dfc97f21c5ce3"),
+				dbSha1:  testutil.DecodeHexString(c, "0eb693bfd2699c09a4d6e96828d332a79de404bb"),
+				dbxSha1: testutil.DecodeHexString(c, "7be4a669cf84c785457bede35b859e4b39f6889e"),
+			},
+		},
+	})
+}
+
+func (s *securebootSuite) TestWithSignatureDBUpdatesTestQuirksBranches(c *C) {
+	// Generate an update with one genuinely new SHA-256 digest and one null SHA-256
+	// digest which exists in the original variable with a different owner, to test
+	// the quirk handling (it should produce 2 branches - one with and one without the
+	// additional null SHA-256 digest).
+	esl := efitest.NewSignatureListNullSHA256(testOwnerGuid)
+	esl.Signatures = append(esl.Signatures, &efi.SignatureData{
+		Owner: testOwnerGuid,
+		Data:  testutil.DecodeHexString(c, "fe266842b938023d45782d831e9f6b528e661790a6914e5f2cc178b20047c15f"),
+	})
+	update := efitest.GenerateSignedVariableUpdate(c,
+		testutil.ParsePKCS1PrivateKey(c, testKEKKey),
+		testutil.ParseCertificate(c, testKEKCert),
+		Dbx.Name, Dbx.GUID,
+		efi.AttributeNonVolatile|efi.AttributeBootserviceAccess|efi.AttributeRuntimeAccess|efi.AttributeTimeBasedAuthenticatedWriteAccess|efi.AttributeAppendWrite,
+		time.Date(2023, 6, 2, 14, 0, 0, 0, time.UTC),
+		efitest.MakeVarPayload(c, esl))
+
+	s.testWithSignatureDBUpdates(c, &testWithSignatureDBUpdatesParams{
+		env:     efitest.NewMockHostEnvironment(makeMockVars(c, withTestSecureBootConfig()), nil),
+		updates: []*SignatureDBUpdate{{Name: Dbx, Data: update}},
+		expected: []expectedSignatureDBSet{
+			{
+				pkSha1:  testutil.DecodeHexString(c, "ce1354eb31a3ff82cc5e517133b87c209e5b3a5b"),
+				kekSha1: testutil.DecodeHexString(c, "006f5be01ec85376d904359afa0d0d55341d7804"),
+				dbSha1:  testutil.DecodeHexString(c, "942f0fab1d9b3b3f23135c89e34cf592ac92e919"),
+				dbxSha1: testutil.DecodeHexString(c, "a922e52bfc71da51714c3765eda70886c3966503"),
+			},
+			{
+				pkSha1:  testutil.DecodeHexString(c, "ce1354eb31a3ff82cc5e517133b87c209e5b3a5b"),
+				kekSha1: testutil.DecodeHexString(c, "006f5be01ec85376d904359afa0d0d55341d7804"),
+				dbSha1:  testutil.DecodeHexString(c, "942f0fab1d9b3b3f23135c89e34cf592ac92e919"),
+				dbxSha1: testutil.DecodeHexString(c, "d358bcaac54e20d680af75d5e576e095a28f59f9"), // contains a new null SHA-256 with a different owner
+			},
+			{
+				pkSha1:  testutil.DecodeHexString(c, "ce1354eb31a3ff82cc5e517133b87c209e5b3a5b"),
+				kekSha1: testutil.DecodeHexString(c, "006f5be01ec85376d904359afa0d0d55341d7804"),
+				dbSha1:  testutil.DecodeHexString(c, "942f0fab1d9b3b3f23135c89e34cf592ac92e919"),
+				dbxSha1: testutil.DecodeHexString(c, "42d302e504898613163e5f8ac42800d83686776a"), // omits the additional null SHA-256 even though it has a different owner
+			},
+		},
+	})
+}
+
+func (s *securebootSuite) TestWithSignatureDBUpdatesAddOneCertToDb(c *C) {
+	// Test applying a single cert to db.
+	update := efitest.GenerateSignedVariableUpdate(c,
+		testutil.ParsePKCS1PrivateKey(c, testKEKKey),
+		testutil.ParseCertificate(c, testKEKCert),
+		Db.Name, Db.GUID,
+		efi.AttributeNonVolatile|efi.AttributeBootserviceAccess|efi.AttributeRuntimeAccess|efi.AttributeTimeBasedAuthenticatedWriteAccess|efi.AttributeAppendWrite,
+		time.Date(2023, 6, 2, 14, 0, 0, 0, time.UTC),
+		efitest.MakeVarPayload(c, testDb2(c)))
+	s.testWithSignatureDBUpdates(c, &testWithSignatureDBUpdatesParams{
+		env:     efitest.NewMockHostEnvironment(makeMockVars(c, withTestSecureBootConfig()), nil),
+		updates: []*SignatureDBUpdate{{Name: Db, Data: update}},
+		expected: []expectedSignatureDBSet{
+			{
+				pkSha1:  testutil.DecodeHexString(c, "ce1354eb31a3ff82cc5e517133b87c209e5b3a5b"),
+				kekSha1: testutil.DecodeHexString(c, "006f5be01ec85376d904359afa0d0d55341d7804"),
+				dbSha1:  testutil.DecodeHexString(c, "942f0fab1d9b3b3f23135c89e34cf592ac92e919"),
+				dbxSha1: testutil.DecodeHexString(c, "a922e52bfc71da51714c3765eda70886c3966503"),
+			},
+			{
+				pkSha1:  testutil.DecodeHexString(c, "ce1354eb31a3ff82cc5e517133b87c209e5b3a5b"),
+				kekSha1: testutil.DecodeHexString(c, "006f5be01ec85376d904359afa0d0d55341d7804"),
+				dbSha1:  testutil.DecodeHexString(c, "6f940f3c622885caa5a334fc9da3e74ea4f55400"),
+				dbxSha1: testutil.DecodeHexString(c, "a922e52bfc71da51714c3765eda70886c3966503"),
+			},
+		},
+	})
+}
diff --git a/efi/shim.go b/efi/shim.go
index fcf7d9eb..ba2ab177 100644
--- a/efi/shim.go
+++ b/efi/shim.go
@@ -32,6 +32,7 @@ import (
 	"strconv"
 
 	efi "github.com/canonical/go-efilib"
+	"github.com/snapcore/secboot/efi/internal"
 	"golang.org/x/crypto/cryptobyte"
 	cryptobyte_asn1 "golang.org/x/crypto/cryptobyte/asn1"
 	"golang.org/x/xerrors"
@@ -102,18 +103,17 @@ func WithShimSbatPolicyLatest() PCRProfileOption {
 	return shimSbatPolicyLatestOption{}
 }
 
-func (shimSbatPolicyLatestOption) applyOptionTo(gen *pcrProfileGenerator) {
-	gen.varModifiers = append(gen.varModifiers, func(rootVars *rootVarsCollector) error {
-		for _, root := range rootVars.PeekAll() {
-			if err := root.WriteVar(
-				shimSbatPolicyName, shimGuid,
-				efi.AttributeNonVolatile|efi.AttributeBootserviceAccess|efi.AttributeRuntimeAccess,
-				[]byte{uint8(shimSbatPolicyLatest)}); err != nil {
-				return err
-			}
+func (shimSbatPolicyLatestOption) ApplyOptionTo(visitor internal.PCRProfileOptionVisitor) error {
+	visitor.AddInitialVariablesModifier(func(vars internal.VariableSet) error {
+		if err := vars.WriteVar(
+			shimSbatPolicyName, shimGuid,
+			efi.AttributeNonVolatile|efi.AttributeBootserviceAccess|efi.AttributeRuntimeAccess,
+			[]byte{uint8(shimSbatPolicyLatest)}); err != nil {
+			return err
 		}
 		return nil
 	})
+	return nil
 }
 
 // newestSbatLevel returns the newest SBAT revocation level from one or
diff --git a/efi/shim_load_handler.go b/efi/shim_load_handler.go
index a1dc8f99..8d061535 100644
--- a/efi/shim_load_handler.go
+++ b/efi/shim_load_handler.go
@@ -26,6 +26,7 @@ import (
 
 	efi "github.com/canonical/go-efilib"
 	"github.com/canonical/tcglog-parser"
+	"github.com/snapcore/secboot/efi/internal"
 	"golang.org/x/xerrors"
 )
 
@@ -176,7 +177,7 @@ func (h *shimLoadHandler) MeasureImageStart(ctx pcrBranchContext) error {
 	ctx.ShimContext().Flags = h.Flags
 	ctx.ShimContext().VendorDb = h.VendorDb
 
-	if !ctx.PCRs().Contains(secureBootPolicyPCR) {
+	if !ctx.PCRs().Contains(internal.SecureBootPolicyPCR) {
 		// We're not generating secure boot policy
 		return nil
 	}
@@ -234,7 +235,7 @@ func (h *shimLoadHandler) MeasureImageStart(ctx pcrBranchContext) error {
 	}
 
 	// Measure SbatLevel
-	ctx.MeasureVariable(secureBootPolicyPCR, shimGuid, shimSbatLevelName, sbatLevel)
+	ctx.MeasureVariable(internal.SecureBootPolicyPCR, shimGuid, shimSbatLevelName, sbatLevel)
 
 	if !bytes.Equal(sbatLevel, hostSbatLevel) {
 		// This branch applies a new SBAT update
@@ -275,7 +276,7 @@ func (m *shimImageLoadMeasurer) measurePEImageDigest() error {
 	if err != nil {
 		return xerrors.Errorf("cannot compute PE digest: %w", err)
 	}
-	m.ExtendPCR(bootManagerCodePCR, digest)
+	m.ExtendPCR(internal.BootManagerCodePCR, digest)
 	return nil
 }
 
@@ -318,18 +319,18 @@ func (m *shimImageLoadMeasurer) measureVerification() error {
 		return nil
 	}
 	sc.AppendVerificationEvent(digest)
-	m.ExtendPCR(secureBootPolicyPCR, digest)
+	m.ExtendPCR(internal.SecureBootPolicyPCR, digest)
 	return nil
 }
 
 func (m *shimImageLoadMeasurer) measure() error {
-	if m.PCRs().Contains(secureBootPolicyPCR) {
+	if m.PCRs().Contains(internal.SecureBootPolicyPCR) {
 		if err := m.measureVerification(); err != nil {
 			return xerrors.Errorf("cannot measure secure boot event: %w", err)
 		}
 	}
 
-	if m.PCRs().Contains(bootManagerCodePCR) {
+	if m.PCRs().Contains(internal.BootManagerCodePCR) {
 		if err := m.measurePEImageDigest(); err != nil {
 			return xerrors.Errorf("cannot measure boot manager code event: %w", err)
 		}
diff --git a/efi/shim_load_handler_test.go b/efi/shim_load_handler_test.go
index 40eb769d..068ad1f0 100644
--- a/efi/shim_load_handler_test.go
+++ b/efi/shim_load_handler_test.go
@@ -27,6 +27,7 @@ import (
 	. "gopkg.in/check.v1"
 
 	. "github.com/snapcore/secboot/efi"
+	"github.com/snapcore/secboot/efi/internal"
 	"github.com/snapcore/secboot/internal/efitest"
 	"github.com/snapcore/secboot/internal/testutil"
 )
@@ -239,8 +240,8 @@ type testShimMeasureImageStartData struct {
 	expectedEvents []*mockPcrBranchEvent
 }
 
-func (s *shimLoadHandlerSuite) testMeasureImageStart(c *C, data *testShimMeasureImageStartData) (PcrBranchContext, *RootVarsCollector) {
-	collector := NewRootVarsCollector(efitest.NewMockHostEnvironment(data.vars, nil))
+func (s *shimLoadHandlerSuite) testMeasureImageStart(c *C, data *testShimMeasureImageStartData) (PcrBranchContext, *VariableSetCollector) {
+	collector := NewVariableSetCollector(efitest.NewMockHostEnvironment(data.vars, nil))
 	ctx := newMockPcrBranchContext(&mockPcrProfileContext{alg: data.alg, pcrs: data.pcrs}, nil, collector.Next())
 
 	handler := &ShimLoadHandler{
@@ -259,7 +260,7 @@ func (s *shimLoadHandlerSuite) testMeasureImageStart(c *C, data *testShimMeasure
 func (s *shimLoadHandlerSuite) TestMeasureImageStartSecureBootPolicyProfile15_6(c *C) {
 	_, collector := s.testMeasureImageStart(c, &testShimMeasureImageStartData{
 		alg:       tpm2.HashAlgorithmSHA256,
-		pcrs:      MakePcrFlags(SecureBootPolicyPCR),
+		pcrs:      MakePcrFlags(internal.SecureBootPolicyPCR),
 		vars:      makeMockVars(c, withMsSecureBootConfig(), withSbatLevel([]byte("sbat,1,2021030218\n"))),
 		shimFlags: ShimHasSbatVerification | ShimFixVariableAuthorityEventsMatchSpec | ShimHasSbatRevocationManagement,
 		vendorDb: &SecureBootDB{
@@ -280,7 +281,7 @@ func (s *shimLoadHandlerSuite) TestMeasureImageStartSecureBootPolicyProfileApply
 	// the profile with.
 	ctx, collector := s.testMeasureImageStart(c, &testShimMeasureImageStartData{
 		alg:       tpm2.HashAlgorithmSHA256,
-		pcrs:      MakePcrFlags(SecureBootPolicyPCR),
+		pcrs:      MakePcrFlags(internal.SecureBootPolicyPCR),
 		vars:      makeMockVars(c, withMsSecureBootConfig(), withSbatLevel([]byte("sbat,1,2021030218\n")), withSbatPolicy(ShimSbatPolicyLatest)),
 		shimFlags: ShimHasSbatVerification | ShimFixVariableAuthorityEventsMatchSpec | ShimHasSbatRevocationManagement,
 		vendorDb: &SecureBootDB{
@@ -330,7 +331,7 @@ func (s *shimLoadHandlerSuite) TestMeasureImageStartSecureBootPolicyProfileUpgra
 	// and verify that we get new sets of initial variables to rerun the profile with.
 	ctx, collector := s.testMeasureImageStart(c, &testShimMeasureImageStartData{
 		alg:       tpm2.HashAlgorithmSHA256,
-		pcrs:      MakePcrFlags(SecureBootPolicyPCR),
+		pcrs:      MakePcrFlags(internal.SecureBootPolicyPCR),
 		vars:      makeMockVars(c, withMsSecureBootConfig(), withSbatLevel([]byte("sbat,1,2021030218\n"))),
 		shimFlags: ShimHasSbatVerification | ShimFixVariableAuthorityEventsMatchSpec | ShimVendorCertContainsDb | ShimHasSbatRevocationManagement,
 		vendorDb: &SecureBootDB{
@@ -364,7 +365,7 @@ func (s *shimLoadHandlerSuite) TestMeasureImageStartSecureBootPolicyProfile15_7T
 	// current SbatLevel.
 	_, collector := s.testMeasureImageStart(c, &testShimMeasureImageStartData{
 		alg:       tpm2.HashAlgorithmSHA256,
-		pcrs:      MakePcrFlags(SecureBootPolicyPCR),
+		pcrs:      MakePcrFlags(internal.SecureBootPolicyPCR),
 		vars:      makeMockVars(c, withMsSecureBootConfig(), withSbatLevel([]byte("sbat,1,2022052400\ngrub,2\n"))),
 		shimFlags: ShimHasSbatVerification | ShimFixVariableAuthorityEventsMatchSpec,
 		vendorDb: &SecureBootDB{
@@ -383,7 +384,7 @@ func (s *shimLoadHandlerSuite) TestMeasureImageStartSecureBootPolicyProfile15_2(
 	// Test MeasureImageStart on a pre-SBAT shim
 	_, collector := s.testMeasureImageStart(c, &testShimMeasureImageStartData{
 		alg:  tpm2.HashAlgorithmSHA256,
-		pcrs: MakePcrFlags(SecureBootPolicyPCR),
+		pcrs: MakePcrFlags(internal.SecureBootPolicyPCR),
 		vars: makeMockVars(c, withMsSecureBootConfig()),
 		vendorDb: &SecureBootDB{
 			Name:     efi.VariableDescriptor{Name: "Shim", GUID: ShimGuid},
@@ -398,7 +399,7 @@ func (s *shimLoadHandlerSuite) TestMeasureImageStartSecureBootPolicyProfile15_2T
 	// and verify we get new sets of initial variables to rerun the profile with.
 	ctx, collector := s.testMeasureImageStart(c, &testShimMeasureImageStartData{
 		alg:       tpm2.HashAlgorithmSHA256,
-		pcrs:      MakePcrFlags(SecureBootPolicyPCR),
+		pcrs:      MakePcrFlags(internal.SecureBootPolicyPCR),
 		vars:      makeMockVars(c, withMsSecureBootConfig()),
 		shimFlags: ShimHasSbatVerification | ShimFixVariableAuthorityEventsMatchSpec | ShimHasSbatRevocationManagement,
 		vendorDb: &SecureBootDB{
@@ -430,7 +431,7 @@ func (s *shimLoadHandlerSuite) TestMeasureImageStartSecureBootPolicyProfile15_2T
 func (s *shimLoadHandlerSuite) TestMeasureImageStartBootManagerCodeProfile(c *C) {
 	_, collector := s.testMeasureImageStart(c, &testShimMeasureImageStartData{
 		alg:       tpm2.HashAlgorithmSHA256,
-		pcrs:      MakePcrFlags(BootManagerCodePCR),
+		pcrs:      MakePcrFlags(internal.BootManagerCodePCR),
 		vars:      makeMockVars(c, withMsSecureBootConfig()),
 		shimFlags: ShimHasSbatVerification | ShimFixVariableAuthorityEventsMatchSpec | ShimHasSbatRevocationManagement,
 		vendorDb: &SecureBootDB{
@@ -486,7 +487,7 @@ func (s *shimLoadHandlerSuite) TestMeasureImageLoadSecureBootPolicyProfile15_7(c
 
 	s.testMeasureImageLoad(c, &testShimMeasureImageLoadData{
 		alg:       tpm2.HashAlgorithmSHA256,
-		pcrs:      MakePcrFlags(SecureBootPolicyPCR),
+		pcrs:      MakePcrFlags(internal.SecureBootPolicyPCR),
 		db:        msDb(c),
 		shimFlags: ShimHasSbatVerification | ShimFixVariableAuthorityEventsMatchSpec | ShimVendorCertContainsDb | ShimHasSbatRevocationManagement,
 		vendorDb: &SecureBootDB{
@@ -506,7 +507,7 @@ func (s *shimLoadHandlerSuite) TestMeasureImageLoadSecureBootPolicyProfile15_6(c
 
 	s.testMeasureImageLoad(c, &testShimMeasureImageLoadData{
 		alg:       tpm2.HashAlgorithmSHA256,
-		pcrs:      MakePcrFlags(SecureBootPolicyPCR),
+		pcrs:      MakePcrFlags(internal.SecureBootPolicyPCR),
 		db:        msDb(c),
 		shimFlags: ShimHasSbatVerification | ShimFixVariableAuthorityEventsMatchSpec | ShimHasSbatRevocationManagement,
 		vendorDb: &SecureBootDB{
@@ -526,7 +527,7 @@ func (s *shimLoadHandlerSuite) TestMeasureImageLoadSecureBootPolicyProfileVendor
 
 	s.testMeasureImageLoad(c, &testShimMeasureImageLoadData{
 		alg:       tpm2.HashAlgorithmSHA256,
-		pcrs:      MakePcrFlags(SecureBootPolicyPCR),
+		pcrs:      MakePcrFlags(internal.SecureBootPolicyPCR),
 		db:        msDb(c),
 		shimFlags: ShimHasSbatVerification | ShimFixVariableAuthorityEventsMatchSpec | ShimVendorCertContainsDb | ShimHasSbatRevocationManagement,
 		vendorDb: &SecureBootDB{
@@ -546,7 +547,7 @@ func (s *shimLoadHandlerSuite) TestMeasureImageLoadSecureBootPolicyProfileVerify
 
 	s.testMeasureImageLoad(c, &testShimMeasureImageLoadData{
 		alg:       tpm2.HashAlgorithmSHA256,
-		pcrs:      MakePcrFlags(SecureBootPolicyPCR),
+		pcrs:      MakePcrFlags(internal.SecureBootPolicyPCR),
 		db:        msDb(c),
 		shimFlags: ShimHasSbatVerification | ShimFixVariableAuthorityEventsMatchSpec | ShimHasSbatRevocationManagement,
 		vendorDb: &SecureBootDB{
@@ -566,7 +567,7 @@ func (s *shimLoadHandlerSuite) TestMeasureImageLoadSecureBootPolicyProfileVerify
 
 	s.testMeasureImageLoad(c, &testShimMeasureImageLoadData{
 		alg:  tpm2.HashAlgorithmSHA256,
-		pcrs: MakePcrFlags(SecureBootPolicyPCR),
+		pcrs: MakePcrFlags(internal.SecureBootPolicyPCR),
 		db:   msDb(c),
 		vendorDb: &SecureBootDB{
 			Name:     efi.VariableDescriptor{Name: "Shim", GUID: ShimGuid},
@@ -583,7 +584,7 @@ func (s *shimLoadHandlerSuite) TestMeasureImageLoadSecureBootPolicyProfileVerify
 func (s *shimLoadHandlerSuite) TestMeasureImageLoadBootManagerCodeProfile1(c *C) {
 	s.testMeasureImageLoad(c, &testShimMeasureImageLoadData{
 		alg:   tpm2.HashAlgorithmSHA256,
-		pcrs:  MakePcrFlags(BootManagerCodePCR),
+		pcrs:  MakePcrFlags(internal.BootManagerCodePCR),
 		image: newMockImage().appendSignatures(efitest.ReadWinCertificateAuthenticodeDetached(c, grubUbuntuSig3)),
 		expectedEvents: []*mockPcrBranchEvent{
 			{pcr: 4, eventType: mockPcrBranchExtendEvent, digest: testutil.DecodeHexString(c, "3709c5a882490fa5b9b7a471f3466341da4267060419491954324d3bfb6aa0c6")},
@@ -594,7 +595,7 @@ func (s *shimLoadHandlerSuite) TestMeasureImageLoadBootManagerCodeProfile1(c *C)
 func (s *shimLoadHandlerSuite) TestMeasureImageLoadBootManagerCodeProfile2(c *C) {
 	s.testMeasureImageLoad(c, &testShimMeasureImageLoadData{
 		alg:   tpm2.HashAlgorithmSHA256,
-		pcrs:  MakePcrFlags(BootManagerCodePCR),
+		pcrs:  MakePcrFlags(internal.BootManagerCodePCR),
 		image: newMockImage().appendSignatures(efitest.ReadWinCertificateAuthenticodeDetached(c, grubUbuntuSig2)),
 		expectedEvents: []*mockPcrBranchEvent{
 			{pcr: 4, eventType: mockPcrBranchExtendEvent, digest: testutil.DecodeHexString(c, "6f007fb8b3a8397bbbe5aa4d64ad2624c2cfb7cd5fa18d51bfbb0f27d1d62b89")},
diff --git a/efi/shim_test.go b/efi/shim_test.go
index 2b140462..3fba7798 100644
--- a/efi/shim_test.go
+++ b/efi/shim_test.go
@@ -392,3 +392,75 @@ func (s *shimSuite) TestShimImageHandleHasSbatLevelSectionFalse(c *C) {
 	shimImage := NewShimImageHandle(image)
 	c.Check(shimImage.HasSbatLevelSection(), Not(testutil.IsTrue))
 }
+
+func (s *shimSuite) TestShimSbatPolicyLatestUnset(c *C) {
+	visitor := new(mockPcrProfileOptionVisitor)
+	opt := WithShimSbatPolicyLatest()
+	c.Check(opt.ApplyOptionTo(visitor), IsNil)
+
+	c.Assert(visitor.varModifiers, HasLen, 1)
+
+	collector := NewVariableSetCollector(efitest.NewMockHostEnvironment(nil, nil))
+	c.Check(visitor.varModifiers[0](collector.PeekAll()[0]), IsNil)
+
+	c.Assert(collector.More(), testutil.IsTrue)
+	vars := collector.Next()
+	_, _, err := vars.ReadVar("SbatPolicy", ShimGuid)
+	c.Check(err, Equals, efi.ErrVarNotExist)
+
+	c.Assert(collector.More(), testutil.IsTrue)
+	vars = collector.Next()
+	data, attrs, err := vars.ReadVar("SbatPolicy", ShimGuid)
+	c.Check(err, IsNil)
+	c.Check(attrs, Equals, efi.AttributeNonVolatile|efi.AttributeBootserviceAccess|efi.AttributeRuntimeAccess)
+	c.Check(data, DeepEquals, []byte{0x1})
+
+	c.Check(collector.More(), testutil.IsFalse)
+}
+
+func (s *shimSuite) TestShimSbatPolicyLatestFromPrevious(c *C) {
+	visitor := new(mockPcrProfileOptionVisitor)
+	opt := WithShimSbatPolicyLatest()
+	c.Check(opt.ApplyOptionTo(visitor), IsNil)
+
+	c.Assert(visitor.varModifiers, HasLen, 1)
+
+	collector := NewVariableSetCollector(efitest.NewMockHostEnvironment(efitest.MakeMockVars().Set("SbatPolicy", ShimGuid, efi.AttributeNonVolatile|efi.AttributeBootserviceAccess|efi.AttributeRuntimeAccess, []byte{0x2}), nil))
+	c.Check(visitor.varModifiers[0](collector.PeekAll()[0]), IsNil)
+
+	c.Assert(collector.More(), testutil.IsTrue)
+	vars := collector.Next()
+	data, attrs, err := vars.ReadVar("SbatPolicy", ShimGuid)
+	c.Check(err, IsNil)
+	c.Check(attrs, Equals, efi.AttributeNonVolatile|efi.AttributeBootserviceAccess|efi.AttributeRuntimeAccess)
+	c.Check(data, DeepEquals, []byte{0x2})
+
+	c.Assert(collector.More(), testutil.IsTrue)
+	vars = collector.Next()
+	data, attrs, err = vars.ReadVar("SbatPolicy", ShimGuid)
+	c.Check(err, IsNil)
+	c.Check(attrs, Equals, efi.AttributeNonVolatile|efi.AttributeBootserviceAccess|efi.AttributeRuntimeAccess)
+	c.Check(data, DeepEquals, []byte{0x1})
+
+	c.Check(collector.More(), testutil.IsFalse)
+}
+
+func (s *shimSuite) TestShimSbatPolicyLatestFromLatest(c *C) {
+	visitor := new(mockPcrProfileOptionVisitor)
+	opt := WithShimSbatPolicyLatest()
+	c.Check(opt.ApplyOptionTo(visitor), IsNil)
+
+	c.Assert(visitor.varModifiers, HasLen, 1)
+
+	collector := NewVariableSetCollector(efitest.NewMockHostEnvironment(efitest.MakeMockVars().Set("SbatPolicy", ShimGuid, efi.AttributeNonVolatile|efi.AttributeBootserviceAccess|efi.AttributeRuntimeAccess, []byte{0x1}), nil))
+	c.Check(visitor.varModifiers[0](collector.PeekAll()[0]), IsNil)
+
+	c.Assert(collector.More(), testutil.IsTrue)
+	vars := collector.Next()
+	data, attrs, err := vars.ReadVar("SbatPolicy", ShimGuid)
+	c.Check(err, IsNil)
+	c.Check(attrs, Equals, efi.AttributeNonVolatile|efi.AttributeBootserviceAccess|efi.AttributeRuntimeAccess)
+	c.Check(data, DeepEquals, []byte{0x1})
+
+	c.Check(collector.More(), testutil.IsFalse)
+}