api/firmware/device: info use device status fields

Return struct containing REQ_INFO response data from device.info().
Amongst the already existing fields that were previously returned by
info() as a tuple, also add the initialized status to the struct that is
returned after firmware version 9.20.0. In case the device does not
respond with the initialized status byte yet it will be nil. Otherwise
true/false depending on the initialized status (seeded and backup
created) of the device.

Also use the information from device.info to set the device.status
earlier to avoid showing the password video if the device is not
initialized.

Author: NicolaLS

api/firmware/device.go

@@ -114,6 +114,19 @@ type DeviceInfo struct {
 	SecurechipModel string `json:"securechipModel"`
 }
 
+// DeviceInfoREQ_INFO is the data returned from the REQ_INFO api call.
+type DeviceInfoREQ_INFO struct {
+	// Device firmware version. REQ_INFO is supported since v4.3.0 which means this field will
+	// always be at least v4.3.0.
+	version *semver.SemVer
+	// Device Platform/Edition e.g. "bitbox02-btconly".
+	product common.Product
+	// Device unlocked status, true if device is unlocked.
+	unlocked bool
+	// Device initialized status, true if device is seeded and backup has been stored.
+	initialized *bool
+}
+
 // NewDevice creates a new instance of Device.
 // version:
 //
@@ -143,26 +156,26 @@ func NewDevice(
 	}
 }
 
-// info uses the opInfo api endpoint to learn about the version, platform/edition, and unlock
-// status (true if unlocked).
-func (device *Device) info() (*semver.SemVer, common.Product, bool, error) {
+// info uses the opInfo api endpoint to learn about the version, platform/edition, unlock
+// status (true if unlocked), and initialized status (true if device can be unlocked/is unlocked).
+func (device *Device) info() (*DeviceInfoREQ_INFO, error) {
 
 	// CAREFUL: hwwInfo is called on the raw transport, not on device.rawQuery, which behaves
 	// differently depending on the firmware version. Reason: the version is not
 	// available (this call is used to get the version), so it must work for all firmware versions.
 	response, err := device.communication.Query([]byte(hwwInfo))
 	if err != nil {
-		return nil, "", false, err
+		return nil, err
 	}
 
-	if len(response) < 4 {
-		return nil, "", false, errp.New("unexpected response")
+	if len(response) < 5 {
+		return nil, errp.New("unexpected response")
 	}
 	versionStrLen, response := int(response[0]), response[1:]
 	versionBytes, response := response[:versionStrLen], response[versionStrLen:]
 	version, err := semver.NewSemVerFromString(string(versionBytes))
 	if err != nil {
-		return nil, "", false, err
+		return nil, err
 	}
 	platformByte, response := response[0], response[1:]
 	editionByte, response := response[0], response[1:]
@@ -175,24 +188,40 @@ func (device *Device) info() (*semver.SemVer, common.Product, bool, error) {
 	}
 	editions, ok := products[platformByte]
 	if !ok {
-		return nil, "", false, errp.Newf("unrecognized platform: %v", platformByte)
+		return nil, errp.Newf("unrecognized platform: %v", platformByte)
 	}
 	product, ok := editions[editionByte]
 	if !ok {
-		return nil, "", false, errp.Newf("unrecognized platform/edition: %v/%v", platformByte, editionByte)
+		return nil, errp.Newf("unrecognized platform/edition: %v/%v", platformByte, editionByte)
 	}
 
 	var unlocked bool
-	unlockedByte := response[0]
+	unlockedByte, response := response[0], response[1:]
 	switch unlockedByte {
 	case 0x00:
 		unlocked = false
 	case 0x01:
 		unlocked = true
 	default:
-		return nil, "", false, errp.New("unexpected reply")
+		return nil, errp.New("unexpected reply")
+	}
+
+	deviceInfo := DeviceInfoREQ_INFO{
+		version:  version,
+		product:  product,
+		unlocked: unlocked,
 	}
-	return version, product, unlocked, nil
+
+	// Since 9.20.0 REQ_INFO responds with a byte for the initialized status.
+	if version.AtLeast(semver.NewSemVer(9, 20, 0)) {
+		initialized := response[0] == 0x01
+		if response[0] != 0x00 && response[0] != 0x01 {
+			return nil, errp.New("unexpected reply")
+		}
+		deviceInfo.initialized = &initialized
+	}
+
+	return &deviceInfo, nil
 }
 
 // Version returns the firmware version.
@@ -206,25 +235,13 @@ func (device *Device) Version() *semver.SemVer {
 // inferVersionAndProduct either sets the version and product by using OP_INFO if they were not
 // provided. In this case, the firmware is assumed to be >=v4.3.0, before that OP_INFO was not
 // available.
-func (device *Device) inferVersionAndProduct() error {
+func (device *Device) inferVersionAndProduct(version *semver.SemVer, product common.Product) {
 	// The version has not been provided, so we try to get it from OP_INFO.
 	if device.version == nil {
-		version, product, _, err := device.info()
-		if err != nil {
-			return errp.New(
-				"OP_INFO unavailable; need to provide version and product via the USB HID descriptor")
-		}
 		device.log.Info(fmt.Sprintf("OP_INFO: version=%s, product=%s", version, product))
-
-		// sanity check
-		if !version.AtLeast(semver.NewSemVer(4, 3, 0)) {
-			return errp.New("OP_INFO is not supposed to exist below v4.3.0")
-		}
-
 		device.version = version
 		device.product = &product
 	}
-	return nil
 }
 
 // Init initializes the device. It changes the status to StatusRequireAppUpgrade if needed,
@@ -241,11 +258,23 @@ func (device *Device) Init() error {
 	device.channelHashDeviceVerified = false
 	device.sendCipher = nil
 	device.receiveCipher = nil
-	device.changeStatus(StatusConnected)
 
-	if err := device.inferVersionAndProduct(); err != nil {
-		return err
+	if device.version == nil || device.version.AtLeast(semver.NewSemVer(4, 3, 0)) {
+		deviceInfo, err := device.info()
+		if err != nil {
+			return errp.New(
+				"OP_INFO unavailable; need to provide version and product via the USB HID descriptor")
+		}
+		// Does nothing if device.version == nil
+		device.inferVersionAndProduct(deviceInfo.version, deviceInfo.product)
+
+		if deviceInfo.unlocked || (deviceInfo.initialized != nil && *deviceInfo.initialized) {
+			device.changeStatus(StatusInitialized)
+		} else {
+			device.changeStatus(StatusUninitialized)
+		}
 	}
+
 	if device.version.AtLeast(lowestNonSupportedFirmwareVersion) {
 		device.changeStatus(StatusRequireAppUpgrade)
 		return nil

api/firmware/status.go

@@ -39,8 +39,7 @@ const (
 	// device. Use CreateBackup() to move to StatusInitialized.
 	StatusSeeded Status = "seeded"
 
-	// StatusInitialized means the device is seeded and the backup was created, and the device is
-	// unlocked. The keystore is ready to use.
+	// StatusInitialized means the device is seeded and the backup was created.
 	StatusInitialized Status = "initialized"
 
 	// StatusRequireFirmwareUpgrade means that the a firmware upgrade is required before being able