api/device_info: add ble fw version

Author: benma

messages/bitbox02_system.proto

@@ -29,6 +29,8 @@ message DeviceInfoResponse {
   message Bluetooth {
     // Hash of the currently active Bluetooth firmware on the device.
     bytes firmware_hash = 1;
+    // Firmware version, formated as "major.minor.patch".
+    string firmware_version = 2;
   }
   string name = 1;
   bool initialized = 2;

py/bitbox02/bitbox02/bitbox02/bitbox02.py

@@ -177,7 +177,8 @@ def device_info(self) -> Dict[str, Any]:
             result["securechip_model"] = response.device_info.securechip_model
         if response.device_info.bluetooth is not None:
             result["bluetooth"] = {
-                "firwmare_hash": response.device_info.bluetooth.firmware_hash,
+                "firmware_hash": response.device_info.bluetooth.firmware_hash,
+                "firmware_version": response.device_info.bluetooth.firmware_version,
             }
         else:
             result["bluetooth"] = None

py/bitbox02/bitbox02/communication/generated/bitbox02_system_pb2.py

@@ -39,14 +39,19 @@ class DeviceInfoResponse(google.protobuf.message.Message):
     class Bluetooth(google.protobuf.message.Message):
         DESCRIPTOR: google.protobuf.descriptor.Descriptor
         FIRMWARE_HASH_FIELD_NUMBER: builtins.int
+        FIRMWARE_VERSION_FIELD_NUMBER: builtins.int
         firmware_hash: builtins.bytes
         """Hash of the currently active Bluetooth firmware on the device."""
 
+        firmware_version: typing.Text
+        """Firmware version, formated as "major.minor.patch"."""
+
         def __init__(self,
             *,
             firmware_hash: builtins.bytes = ...,
+            firmware_version: typing.Text = ...,
             ) -> None: ...
-        def ClearField(self, field_name: typing_extensions.Literal["firmware_hash",b"firmware_hash"]) -> None: ...
+        def ClearField(self, field_name: typing_extensions.Literal["firmware_hash",b"firmware_hash","firmware_version",b"firmware_version"]) -> None: ...
 
     NAME_FIELD_NUMBER: builtins.int
     INITIALIZED_FIELD_NUMBER: builtins.int

py/bitbox02/bitbox02/communication/generated/bitbox02_system_pb2.pyi

@@ -17,14 +17,16 @@ use crate::pb;
 
 use pb::response::Response;
 
-use bitbox02::{memory, securechip};
+use bitbox02::{memory, securechip, spi_mem};
 
 pub fn process() -> Result<Response, Error> {
     let bluetooth = match memory::get_platform().map_err(|_| Error::Memory)? {
         memory::Platform::BitBox02Plus => {
             let ble_metadata = memory::get_ble_metadata();
             Some(pb::device_info_response::Bluetooth {
                 firmware_hash: ble_metadata.allowed_firmware_hash.to_vec(),
+                firmware_version: spi_mem::get_active_ble_firmware_version()
+                    .map_err(|_| Error::Memory)?,
             })
         }
         memory::Platform::BitBox02 => None,

src/rust/bitbox02-rust/src/hww/api/device_info.rs

@@ -138,6 +138,9 @@ pub mod device_info_response {
         /// Hash of the currently active Bluetooth firmware on the device.
         #[prost(bytes = "vec", tag = "1")]
         pub firmware_hash: ::prost::alloc::vec::Vec<u8>,
+        /// Firmware version, formated as "major.minor.patch".
+        #[prost(string, tag = "2")]
+        pub firmware_version: ::prost::alloc::string::String,
     }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]

src/rust/bitbox02-rust/src/shiftcrypto.bitbox02.rs

@@ -108,6 +108,7 @@ const ALLOWLIST_FNS: &[&str] = &[
     "memory_get_ble_metadata",
     "memory_set_ble_metadata",
     "memory_get_platform",
+    "memory_spi_get_active_ble_firmware_version",
     "spi_mem_write",
     "menu_create",
     "mock_memory_factoryreset",

src/rust/bitbox02-sys/build.rs

@@ -18,9 +18,31 @@ pub use bitbox02_sys::MEMORY_SPI_BLE_FIRMWARE_1_ADDR as BLE_FIRMWARE_1_ADDR;
 pub use bitbox02_sys::MEMORY_SPI_BLE_FIRMWARE_2_ADDR as BLE_FIRMWARE_2_ADDR;
 pub use bitbox02_sys::MEMORY_SPI_BLE_FIRMWARE_MAX_SIZE as BLE_FIRMWARE_MAX_SIZE;
 
+use alloc::string::String;
+
 pub fn write(address: u32, data: &[u8]) -> Result<(), ()> {
     match unsafe { bitbox02_sys::spi_mem_write(address, data.as_ptr(), data.len()) } {
         true => Ok(()),
         false => Err(()),
     }
 }
+
+pub fn get_active_ble_firmware_version() -> Result<String, ()> {
+    let mut ble_fw_version = core::mem::MaybeUninit::uninit();
+    unsafe {
+        match bitbox02_sys::memory_spi_get_active_ble_firmware_version(ble_fw_version.as_mut_ptr())
+        {
+            true => {
+                let ble_fw_version = ble_fw_version.assume_init();
+                // Copy to avoid taking references to unaligned struct fields.
+                let (major, minor, patch) = (
+                    ble_fw_version.major,
+                    ble_fw_version.minor,
+                    ble_fw_version.patch,
+                );
+                Ok(format!("{}.{}.{}", major, minor, patch))
+            }
+            false => Err(()),
+        }
+    }
+}