many: add reprovision API

Author: valentindavid

boot/assets.go

@@ -329,6 +329,14 @@ func (b *bootAssetsImpl) UpdateBootEntry() error {
 	return doUpdateBootEntry(b.bootLoader, b.updatedAssets)
 }
 
+func GetTrustedAssetsFromModeenv(m *Modeenv) BootAssets {
+	return &bootAssetsImpl{
+		trackedAssets:         m.CurrentTrustedBootAssets,
+		trackedRecoveryAssets: m.CurrentTrustedRecoveryBootAssets,
+		// No update of boot entry for now
+	}
+}
+
 type trustedAssetsInstallObserverImpl struct {
 	model     *asserts.Model
 	gadgetDir string

daemon/api_systems.go

@@ -54,7 +54,7 @@ var systemsCmd = &Command{
 	// this command, so we need to set the POST for this command to essentially
 	// forward to that one
 	POST:        postSystemsAction,
-	Actions:     []string{"reboot", "create", "install", "fix-encryption-support", "generate-recovery-key"},
+	Actions:     []string{"reboot", "create", "install", "reprovision", "fix-encryption-support", "generate-recovery-key"},
 	WriteAccess: rootAccess{},
 }
 
@@ -217,6 +217,7 @@ var (
 	devicestateRemoveRecoverySystem           = devicestate.RemoveRecoverySystem
 	devicestateGeneratePreInstallRecoveryKey  = devicestate.GeneratePreInstallRecoveryKey
 	devicestateGenerateReprovisionRecoveryKey = devicestate.GenerateReprovisionRecoveryKey
+	devicestateReprovision                    = devicestate.Reprovision
 )
 
 func getSystemDetails(c *Command, r *http.Request, user *auth.UserState) Response {
@@ -352,6 +353,11 @@ func postSystemsActionJSON(c *Command, r *http.Request) Response {
 		return postSystemActionCheckPINQuality(c, systemLabel, &req)
 	case "fix-encryption-support":
 		return postSystemActionFixEncryptionSupport(c, systemLabel, &req)
+	case "reprovision":
+		if systemLabel != "" {
+			return BadRequest("label should not be provided for reprovision action")
+		}
+		return postSystemActionReprovision(c, &req)
 	case "generate-recovery-key":
 		if systemLabel != "" {
 			// SD201 says that generate-recovery-key should be an action for installation... but it is a step
@@ -849,6 +855,20 @@ func postSystemActionFixEncryptionSupport(c *Command, systemLabel string, req *s
 	return SyncResponse(*details)
 }
 
+func postSystemActionReprovision(c *Command, req *systemActionRequest) Response {
+	st := c.d.overlord.State()
+	st.Lock()
+	defer st.Unlock()
+
+	chg, err := devicestateReprovision(st)
+	if err != nil {
+		return BadRequest("unexpected error: %s", err)
+	}
+	ensureStateSoon(st)
+
+	return AsyncResponse(nil, chg.ID())
+}
+
 func postSystemActionGenerateRecoveryKey(c *Command, req *systemActionRequest) Response {
 	st := c.d.overlord.State()
 	st.Lock()

daemon/api_systems_test.go

@@ -3464,6 +3464,66 @@ func (s *systemsCreateSuite) TestCreateSystemActionOfflineJustValidationSets(c *
 	c.Check(st.Change(res.Change), check.NotNil)
 }
 
+func (s *systemsSuite) TestSystemActionReprovision(c *check.C) {
+	s.mockSystemSeeds(c)
+	s.daemon(c)
+	s.expectRootAccess()
+
+	defer daemon.MockDevicestateReprovision(func(st *state.State) (*state.Change, error) {
+		return st.NewChange("reprovision", "..."), nil
+	})()
+	soon := 0
+	_, restore := daemon.MockEnsureStateSoon(func(st *state.State) {
+		soon++
+	})
+	defer restore()
+
+	body := map[string]any{
+		"action": "reprovision",
+	}
+
+	b, err := json.Marshal(body)
+	c.Assert(err, check.IsNil)
+	buf := bytes.NewBuffer(b)
+
+	req, err := http.NewRequest("POST", "/v2/systems", buf)
+	c.Assert(err, check.IsNil)
+
+	rsp := s.asyncReq(c, req, nil, actionIsExpected)
+	c.Check(soon, check.Equals, 1)
+	c.Check(rsp.Status, check.Equals, 202)
+}
+
+func (s *systemsSuite) TestSystemActionReprovisionError(c *check.C) {
+	s.mockSystemSeeds(c)
+	s.daemon(c)
+	s.expectRootAccess()
+
+	defer daemon.MockDevicestateReprovision(func(st *state.State) (*state.Change, error) {
+		return nil, fmt.Errorf("foo")
+	})()
+	soon := 0
+	_, restore := daemon.MockEnsureStateSoon(func(st *state.State) {
+		soon++
+	})
+	defer restore()
+
+	body := map[string]any{
+		"action": "reprovision",
+	}
+
+	b, err := json.Marshal(body)
+	c.Assert(err, check.IsNil)
+	buf := bytes.NewBuffer(b)
+
+	req, err := http.NewRequest("POST", "/v2/systems", buf)
+	c.Assert(err, check.IsNil)
+
+	rsp := s.errorReq(c, req, nil, actionIsExpected)
+	c.Check(soon, check.Equals, 0)
+	c.Check(rsp.Status, check.Equals, 400)
+}
+
 func (s *systemsSuite) TestSystemCurrentSystemGenerateRecoveryKey(c *check.C) {
 	if (keys.RecoveryKey{}).String() == "not-implemented" {
 		c.Skip("needs working secboot recovery key")

daemon/export_test.go

@@ -463,3 +463,7 @@ func ResetBuildIDDetection() {
 	buildIDOnce = sync.Once{}
 	buildID = "unknown"
 }
+
+func MockDevicestateReprovision(f func(st *state.State) (*state.Change, error)) (restore func()) {
+	return testutil.Mock(&devicestateReprovision, f)
+}

overlord/devicestate/devicemgr.go

@@ -304,6 +304,8 @@ func Manager(s *state.State, hookManager *hookstate.HookManager, runner *state.T
 	runner.AddBlocked(gadgetUpdateBlocked)
 	runner.AddBlocked(removeRecoverySystemBlocked)
 
+	runner.AddHandler("reprovision", m.doReprovision, nil)
+
 	// wire FDE kernel hook support into boot
 	boot.HookKeyProtectorFactory = m.hookKeyProtectorFactory
 	hookManager.Register(regexp.MustCompile("^fde-setup$"), newFdeSetupHandler)

overlord/devicestate/devicestate.go

@@ -78,6 +78,7 @@ var (
 	installStepFinishChangeKind                 = swfeats.RegisterChangeKind("install-step-finish")
 	installStepSetupStorageEncryptionChangeKind = swfeats.RegisterChangeKind("install-step-setup-storage-encryption")
 	installStepTargetPreseedChangeKind          = swfeats.RegisterChangeKind("install-step-preseed")
+	reprovisionKind                             = swfeats.RegisterChangeKind("reprovision")
 )
 
 // findModel returns the device model assertion.
@@ -2697,3 +2698,11 @@ func checkInstallChangeConflict(st *state.State) error {
 	}
 	return nil
 }
+
+func Reprovision(st *state.State) (*state.Change, error) {
+	chg := st.NewChange(reprovisionKind, fmt.Sprintf("Reprovision"))
+	reprovisionTask := st.NewTask("reprovision", fmt.Sprintf("Reprovision"))
+	chg.AddTask(reprovisionTask)
+
+	return chg, nil
+}

overlord/devicestate/export_test.go

@@ -37,6 +37,7 @@ import (
 	"github.com/snapcore/snapd/osutil/keyboard"
 	"github.com/snapcore/snapd/osutil/user"
 	"github.com/snapcore/snapd/overlord/fdestate"
+	fdeBackend "github.com/snapcore/snapd/overlord/fdestate/backend"
 	"github.com/snapcore/snapd/overlord/snapstate"
 	"github.com/snapcore/snapd/overlord/state"
 	"github.com/snapcore/snapd/overlord/storecontext"
@@ -775,3 +776,78 @@ type ReprovisionSetupDataType = reprovisionSetupData
 func GetCachedReprovisionRecoveryKey(data *ReprovisionSetupDataType) *keys.RecoveryKey {
 	return data.recoveryKey
 }
+
+func MakeReprovisionSetupData(rkey *keys.RecoveryKey, checkContext *secboot.PreinstallCheckContext) *ReprovisionSetupDataType {
+	return &reprovisionSetupData{
+		recoveryKey:  rkey,
+		checkContext: checkContext,
+	}
+}
+
+func MockFdestateGetEncryptedContainers(f func(st *state.State) ([]fdeBackend.EncryptedContainer, error)) (restore func()) {
+	old := fdestateGetEncryptedContainers
+	fdestateGetEncryptedContainers = f
+	return func() {
+		fdestateGetEncryptedContainers = old
+	}
+}
+
+func DoReprovision(m *DeviceManager, t *state.Task) error {
+	return m.doReprovision(t, nil)
+}
+
+func MockSecbootListContainerUnlockKeyNames(f func(disk string) ([]string, error)) (restore func()) {
+	return testutil.Mock(&secbootListContainerUnlockKeyNames, f)
+}
+
+func MockSecbootTestProtectorKey(f func(ctx context.Context, disk string, keyName string, key []byte) (bool, error)) (restore func()) {
+	return testutil.Mock(&secbootTestProtectorKey, f)
+}
+
+func MockSecbootRenameContainerKey(f func(disk string, from, to string) error) (restore func()) {
+	return testutil.Mock(&secbootRenameContainerKey, f)
+}
+
+func MockSecbootGetPCRHandleFromToken(f func(disk string, name string) (uint32, error)) (restore func()) {
+	return testutil.Mock(&secbootGetPCRHandleFromToken, f)
+}
+
+func MockSecbootReleasePCRResourceHandle(f func(nv uint32) error) (restore func()) {
+	return testutil.Mock(&secbootReleasePCRResourceHandle, f)
+}
+
+func MockSecbootDeleteContainerKey(f func(disk string, name string) error) (restore func()) {
+	return testutil.Mock(&secbootDeleteContainerKey, f)
+}
+
+func MockBootMakeRunnableReprovision(f func(model *asserts.Model, protector secboot.KeyProtectorFactory, encryption *boot.EncryptionSetup) error) (restore func()) {
+	return testutil.Mock(&bootMakeRunnableReprovision, f)
+}
+
+func MockSecbootListContainerRecoveryKeyNames(f func(disk string) ([]string, error)) (restore func()) {
+	return testutil.Mock(&secbootListContainerRecoveryKeyNames, f)
+}
+
+func MockSecbootSaveCheckResult(f func(pcc *secboot.PreinstallCheckContext, filename string) error) (restore func()) {
+	return testutil.Mock(&secbootSaveCheckResult, f)
+}
+
+func MockSecbootCheckResult(f func(pcc *secboot.PreinstallCheckContext) (*secboot.PreinstallCheckResult, error)) (restore func()) {
+	return testutil.Mock(&secbootCheckResult, f)
+}
+
+func MockSnapstateKernelInfo(f func(st *state.State, deviceCtx snapstate.DeviceContext) (*snap.Info, error)) (restore func()) {
+	return testutil.Mock(&snapstateKernelInfo, f)
+}
+
+func MockKeysNewProtectorKey(f func() (keys.ProtectorKey, error)) (restore func()) {
+	return testutil.Mock(&keysNewProtectorKey, f)
+}
+
+func MockKeysCreateProtectedKey(f func(k keys.ProtectorKey, primaryKey []byte) (*keys.PlainKey, []byte, []byte, error)) (restore func()) {
+	return testutil.Mock(&keysCreateProtectedKey, f)
+}
+
+func MockKeysPlainKeyWrite(f func(key *keys.PlainKey, writer keys.KeyDataWriter) error) (restore func()) {
+	return testutil.Mock(&keysPlainKeyWrite, f)
+}