Rpc: StorageInfo, StorageRename, SystemReboot, SystemDeviceInfo (bonus: +FuriHalInfo) (#862)

* Rpc: update protobuf sources
* Rpc: rename Status to System
* Rpc: implement StorageInfoRequest
* Rpc: implement StorageRenameRequest
* Rpc: implement SystemRebootRequest
* FuriHal: introduce FuriHalInfo, refactor device_info
* Rpc: implement DeviceInfoRequest
* Rpc: use strdup where it suites the best.
* Make: add do not page align data to linker flag.

Co-authored-by: あく <alleteam@gmail.com>

applications/cli/cli_commands.c

@@ -1,166 +1,22 @@
 #include "cli_commands.h"
 #include <furi-hal.h>
 #include <furi-hal-gpio.h>
+#include <furi-hal-info.h>
 #include <rtc.h>
 #include <task-control-block.h>
 #include <time.h>
 #include <notification/notification-messages.h>
-#include <shci.h>
 
-#define ENCLAVE_SIGNATURE_KEY_SLOTS 10
-#define ENCLAVE_SIGNATURE_SIZE 16
-
-static const uint8_t enclave_signature_iv[ENCLAVE_SIGNATURE_KEY_SLOTS][16] = {
-    {0xac, 0x5d, 0x68, 0xb8, 0x79, 0x74, 0xfc, 0x7f, 0x45, 0x02, 0x82, 0xf1, 0x48, 0x7e, 0x75, 0x8a},
-    {0x38, 0xe6, 0x6a, 0x90, 0x5e, 0x5b, 0x8a, 0xa6, 0x70, 0x30, 0x04, 0x72, 0xc2, 0x42, 0xea, 0xaf},
-    {0x73, 0xd5, 0x8e, 0xfb, 0x0f, 0x4b, 0xa9, 0x79, 0x0f, 0xde, 0x0e, 0x53, 0x44, 0x7d, 0xaa, 0xfd},
-    {0x3c, 0x9a, 0xf4, 0x43, 0x2b, 0xfe, 0xea, 0xae, 0x8c, 0xc6, 0xd1, 0x60, 0xd2, 0x96, 0x64, 0xa9},
-    {0x10, 0xac, 0x7b, 0x63, 0x03, 0x7f, 0x43, 0x18, 0xec, 0x9d, 0x9c, 0xc4, 0x01, 0xdc, 0x35, 0xa7},
-    {0x26, 0x21, 0x64, 0xe6, 0xd0, 0xf2, 0x47, 0x49, 0xdc, 0x36, 0xcd, 0x68, 0x0c, 0x91, 0x03, 0x44},
-    {0x7a, 0xbd, 0xce, 0x9c, 0x24, 0x7a, 0x2a, 0xb1, 0x3c, 0x4f, 0x5a, 0x7d, 0x80, 0x3e, 0xfc, 0x0d},
-    {0xcd, 0xdd, 0xd3, 0x02, 0x85, 0x65, 0x43, 0x83, 0xf9, 0xac, 0x75, 0x2f, 0x21, 0xef, 0x28, 0x6b},
-    {0xab, 0x73, 0x70, 0xe8, 0xe2, 0x56, 0x0f, 0x58, 0xab, 0x29, 0xa5, 0xb1, 0x13, 0x47, 0x5e, 0xe8},
-    {0x4f, 0x3c, 0x43, 0x77, 0xde, 0xed, 0x79, 0xa1, 0x8d, 0x4c, 0x1f, 0xfd, 0xdb, 0x96, 0x87, 0x2e},
-};
-
-static const uint8_t enclave_signature_input[ENCLAVE_SIGNATURE_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
-    {0x9f, 0x5c, 0xb1, 0x43, 0x17, 0x53, 0x18, 0x8c, 0x66, 0x3d, 0x39, 0x45, 0x90, 0x13, 0xa9, 0xde},
-    {0xc5, 0x98, 0xe9, 0x17, 0xb8, 0x97, 0x9e, 0x03, 0x33, 0x14, 0x13, 0x8f, 0xce, 0x74, 0x0d, 0x54},
-    {0x34, 0xba, 0x99, 0x59, 0x9f, 0x70, 0x67, 0xe9, 0x09, 0xee, 0x64, 0x0e, 0xb3, 0xba, 0xfb, 0x75},
-    {0xdc, 0xfa, 0x6c, 0x9a, 0x6f, 0x0a, 0x3e, 0xdc, 0x42, 0xf6, 0xae, 0x0d, 0x3c, 0xf7, 0x83, 0xaf},
-    {0xea, 0x2d, 0xe3, 0x1f, 0x02, 0x99, 0x1a, 0x7e, 0x6d, 0x93, 0x4c, 0xb5, 0x42, 0xf0, 0x7a, 0x9b},
-    {0x53, 0x5e, 0x04, 0xa2, 0x49, 0xa0, 0x73, 0x49, 0x56, 0xb0, 0x88, 0x8c, 0x12, 0xa0, 0xe4, 0x18},
-    {0x7d, 0xa7, 0xc5, 0x21, 0x7f, 0x12, 0x95, 0xdd, 0x4d, 0x77, 0x01, 0xfa, 0x71, 0x88, 0x2b, 0x7f},
-    {0xdc, 0x9b, 0xc5, 0xa7, 0x6b, 0x84, 0x5c, 0x37, 0x7c, 0xec, 0x05, 0xa1, 0x9f, 0x91, 0x17, 0x3b},
-    {0xea, 0xcf, 0xd9, 0x9b, 0x86, 0xcd, 0x2b, 0x43, 0x54, 0x45, 0x82, 0xc6, 0xfe, 0x73, 0x1a, 0x1a},
-    {0x77, 0xb8, 0x1b, 0x90, 0xb4, 0xb7, 0x32, 0x76, 0x8f, 0x8a, 0x57, 0x06, 0xc7, 0xdd, 0x08, 0x90},
-};
-
-static const uint8_t enclave_signature_expected[ENCLAVE_SIGNATURE_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
-    {0xe9, 0x9a, 0xce, 0xe9, 0x4d, 0xe1, 0x7f, 0x55, 0xcb, 0x8a, 0xbf, 0xf2, 0x4d, 0x98, 0x27, 0x67},
-    {0x34, 0x27, 0xa7, 0xea, 0xa8, 0x98, 0x66, 0x9b, 0xed, 0x43, 0xd3, 0x93, 0xb5, 0xa2, 0x87, 0x8e},
-    {0x6c, 0xf3, 0x01, 0x78, 0x53, 0x1b, 0x11, 0x32, 0xf0, 0x27, 0x2f, 0xe3, 0x7d, 0xa6, 0xe2, 0xfd},
-    {0xdf, 0x7f, 0x37, 0x65, 0x2f, 0xdb, 0x7c, 0xcf, 0x5b, 0xb6, 0xe4, 0x9c, 0x63, 0xc5, 0x0f, 0xe0},
-    {0x9b, 0x5c, 0xee, 0x44, 0x0e, 0xd1, 0xcb, 0x5f, 0x28, 0x9f, 0x12, 0x17, 0x59, 0x64, 0x40, 0xbb},
-    {0x94, 0xc2, 0x09, 0x98, 0x62, 0xa7, 0x2b, 0x93, 0xed, 0x36, 0x1f, 0x10, 0xbc, 0x26, 0xbd, 0x41},
-    {0x4d, 0xb2, 0x2b, 0xc5, 0x96, 0x47, 0x61, 0xf4, 0x16, 0xe0, 0x81, 0xc3, 0x8e, 0xb9, 0x9c, 0x9b},
-    {0xc3, 0x6b, 0x83, 0x55, 0x90, 0x38, 0x0f, 0xea, 0xd1, 0x65, 0xbf, 0x32, 0x4f, 0x8e, 0x62, 0x5b},
-    {0x8d, 0x5e, 0x27, 0xbc, 0x14, 0x4f, 0x08, 0xa8, 0x2b, 0x14, 0x89, 0x5e, 0xdf, 0x77, 0x04, 0x31},
-    {0xc9, 0xf7, 0x03, 0xf1, 0x6c, 0x65, 0xad, 0x49, 0x74, 0xbe, 0x00, 0x54, 0xfd, 0xa6, 0x9c, 0x32},
-};
+void cli_command_device_info_callback(const char* key, const char* value, bool last, void* context) {
+    printf("%-24s: %s\r\n", key, value);
+}
 
 /* 
  * Device Info Command
- * This command is intended to be used by humans and machines
- * Keys and values format MUST NOT BE changed
+ * This command is intended to be used by humans
  */
 void cli_command_device_info(Cli* cli, string_t args, void* context) {
-    // Device Info version
-    printf("device_info_major       : %d\r\n", 2);
-    printf("device_info_minor       : %d\r\n", 0);
-    // Model name
-    printf("hardware_model          : %s\r\n", furi_hal_version_get_model_name());
-
-    // Unique ID
-    printf("hardware_uid            : ");
-    const uint8_t* uid = furi_hal_version_uid();
-    for(size_t i = 0; i < furi_hal_version_uid_size(); i++) {
-        printf("%02X", uid[i]);
-    }
-    printf("\r\n");
-
-    // OTP Revision
-    printf("hardware_otp_ver        : %d\r\n", furi_hal_version_get_otp_version());
-    printf("hardware_timestamp      : %lu\r\n", furi_hal_version_get_hw_timestamp());
-
-    // Board Revision
-    printf("hardware_ver            : %d\r\n", furi_hal_version_get_hw_version());
-    printf("hardware_target         : %d\r\n", furi_hal_version_get_hw_target());
-    printf("hardware_body           : %d\r\n", furi_hal_version_get_hw_body());
-    printf("hardware_connect        : %d\r\n", furi_hal_version_get_hw_connect());
-    printf("hardware_display        : %d\r\n", furi_hal_version_get_hw_display());
-
-    // Board Personification
-    printf("hardware_color          : %d\r\n", furi_hal_version_get_hw_color());
-    printf("hardware_region         : %d\r\n", furi_hal_version_get_hw_region());
-    const char* name = furi_hal_version_get_name_ptr();
-    if(name) {
-        printf("hardware_name           : %s\r\n", name);
-    }
-
-    // Bootloader Version
-    const Version* bootloader_version = furi_hal_version_get_bootloader_version();
-    if(bootloader_version) {
-        printf("bootloader_commit       : %s\r\n", version_get_githash(bootloader_version));
-        printf("bootloader_branch       : %s\r\n", version_get_gitbranch(bootloader_version));
-        printf("bootloader_branch_num   : %s\r\n", version_get_gitbranchnum(bootloader_version));
-        printf("bootloader_version      : %s\r\n", version_get_version(bootloader_version));
-        printf("bootloader_build_date   : %s\r\n", version_get_builddate(bootloader_version));
-        printf("bootloader_target       : %d\r\n", version_get_target(bootloader_version));
-    }
-
-    // Firmware version
-    const Version* firmware_version = furi_hal_version_get_firmware_version();
-    if(firmware_version) {
-        printf("firmware_commit         : %s\r\n", version_get_githash(firmware_version));
-        printf("firmware_branch         : %s\r\n", version_get_gitbranch(firmware_version));
-        printf("firmware_branch_num     : %s\r\n", version_get_gitbranchnum(firmware_version));
-        printf("firmware_version        : %s\r\n", version_get_version(firmware_version));
-        printf("firmware_build_date     : %s\r\n", version_get_builddate(firmware_version));
-        printf("firmware_target         : %d\r\n", version_get_target(firmware_version));
-    }
-
-    WirelessFwInfo_t pWirelessInfo;
-    if(furi_hal_bt_is_alive() && SHCI_GetWirelessFwInfo(&pWirelessInfo) == SHCI_Success) {
-        printf("radio_alive             : true\r\n");
-        // FUS Info
-        printf("radio_fus_major         : %d\r\n", pWirelessInfo.FusVersionMajor);
-        printf("radio_fus_minor         : %d\r\n", pWirelessInfo.FusVersionMinor);
-        printf("radio_fus_sub           : %d\r\n", pWirelessInfo.FusVersionSub);
-        printf("radio_fus_sram2b        : %dK\r\n", pWirelessInfo.FusMemorySizeSram2B);
-        printf("radio_fus_sram2a        : %dK\r\n", pWirelessInfo.FusMemorySizeSram2A);
-        printf("radio_fus_flash         : %dK\r\n", pWirelessInfo.FusMemorySizeFlash * 4);
-        // Stack Info
-        printf("radio_stack_type        : %d\r\n", pWirelessInfo.StackType);
-        printf("radio_stack_major       : %d\r\n", pWirelessInfo.VersionMajor);
-        printf("radio_stack_minor       : %d\r\n", pWirelessInfo.VersionMinor);
-        printf("radio_stack_sub         : %d\r\n", pWirelessInfo.VersionSub);
-        printf("radio_stack_branch      : %d\r\n", pWirelessInfo.VersionBranch);
-        printf("radio_stack_release     : %d\r\n", pWirelessInfo.VersionReleaseType);
-        printf("radio_stack_sram2b      : %dK\r\n", pWirelessInfo.MemorySizeSram2B);
-        printf("radio_stack_sram2a      : %dK\r\n", pWirelessInfo.MemorySizeSram2A);
-        printf("radio_stack_sram1       : %dK\r\n", pWirelessInfo.MemorySizeSram1);
-        printf("radio_stack_flash       : %dK\r\n", pWirelessInfo.MemorySizeFlash * 4);
-        // Mac address
-        printf("radio_ble_mac           : ");
-        const uint8_t* ble_mac = furi_hal_version_get_ble_mac();
-        for(size_t i = 0; i < 6; i++) {
-            printf("%02X", ble_mac[i]);
-        }
-        printf("\r\n");
-
-        // Signature verification
-        uint8_t buffer[ENCLAVE_SIGNATURE_SIZE];
-        size_t enclave_valid_keys = 0;
-        for(size_t key_slot = 0; key_slot < ENCLAVE_SIGNATURE_KEY_SLOTS; key_slot++) {
-            if(furi_hal_crypto_store_load_key(key_slot + 1, enclave_signature_iv[key_slot])) {
-                if(furi_hal_crypto_encrypt(
-                       enclave_signature_input[key_slot], buffer, ENCLAVE_SIGNATURE_SIZE)) {
-                    enclave_valid_keys += memcmp(
-                                              buffer,
-                                              enclave_signature_expected[key_slot],
-                                              ENCLAVE_SIGNATURE_SIZE) == 0;
-                }
-                furi_hal_crypto_store_unload_key(key_slot + 1);
-            }
-        }
-        printf("enclave_valid_keys      : %d\r\n", enclave_valid_keys);
-        printf(
-            "enclave_valid           : %s\r\n",
-            (enclave_valid_keys == ENCLAVE_SIGNATURE_KEY_SLOTS) ? "true" : "false");
-    } else {
-        printf("radio_alive             : false\r\n");
-    }
+    furi_hal_info_get(cli_command_device_info_callback, context);
 }
 
 void cli_command_help(Cli* cli, string_t args, void* context) {

applications/rpc/rpc.c

@@ -33,7 +33,7 @@ typedef struct {
 
 static RpcSystemCallbacks rpc_systems[] = {
     {
-        .alloc = rpc_system_status_alloc,
+        .alloc = rpc_system_system_alloc,
         .free = NULL,
     },
     {
@@ -203,12 +203,23 @@ void rpc_print_message(const PB_Main* message) {
         }
         break;
     }
-    case PB_Main_ping_request_tag:
+    case PB_Main_system_ping_request_tag:
         string_cat_printf(str, "\tping_request {\r\n");
         break;
-    case PB_Main_ping_response_tag:
+    case PB_Main_system_ping_response_tag:
         string_cat_printf(str, "\tping_response {\r\n");
         break;
+    case PB_Main_system_device_info_request_tag:
+        string_cat_printf(str, "\tdevice_info_request {\r\n");
+        break;
+    case PB_Main_system_device_info_response_tag:
+        string_cat_printf(str, "\tdevice_info_response {\r\n");
+        string_cat_printf(
+            str,
+            "\t\t%s: %s\r\n",
+            message->content.system_device_info_response.key,
+            message->content.system_device_info_response.value);
+        break;
     case PB_Main_storage_mkdir_request_tag:
         string_cat_printf(str, "\tmkdir {\r\n");
         break;
@@ -223,6 +234,38 @@ void rpc_print_message(const PB_Main* message) {
     case PB_Main_empty_tag:
         string_cat_printf(str, "\tempty {\r\n");
         break;
+    case PB_Main_storage_info_request_tag: {
+        string_cat_printf(str, "\tinfo_request {\r\n");
+        const char* path = message->content.storage_info_request.path;
+        if(path) {
+            string_cat_printf(str, "\t\tpath: %s\r\n", path);
+        }
+        break;
+    }
+    case PB_Main_storage_info_response_tag: {
+        string_cat_printf(str, "\tinfo_response {\r\n");
+        string_cat_printf(
+            str, "\t\ttotal_space: %lu\r\n", message->content.storage_info_response.total_space);
+        string_cat_printf(
+            str, "\t\tfree_space: %lu\r\n", message->content.storage_info_response.free_space);
+        break;
+    }
+    case PB_Main_storage_stat_request_tag: {
+        string_cat_printf(str, "\tstat_request {\r\n");
+        const char* path = message->content.storage_stat_request.path;
+        if(path) {
+            string_cat_printf(str, "\t\tpath: %s\r\n", path);
+        }
+        break;
+    }
+    case PB_Main_storage_stat_response_tag: {
+        string_cat_printf(str, "\tstat_response {\r\n");
+        if(message->content.storage_stat_response.has_file) {
+            const PB_Storage_File* msg_file = &message->content.storage_stat_response.file;
+            rpc_sprintf_msg_file(str, "\t\t\t", msg_file, 1);
+        }
+        break;
+    }
     case PB_Main_storage_list_request_tag: {
         string_cat_printf(str, "\tlist_request {\r\n");
         const char* path = message->content.storage_list_request.path;
@@ -265,6 +308,14 @@ void rpc_print_message(const PB_Main* message) {
         rpc_sprintf_msg_file(str, "\t\t", msg_file, msg_file_count);
         break;
     }
+    case PB_Main_storage_rename_request_tag: {
+        string_cat_printf(str, "\trename_request {\r\n");
+        string_cat_printf(
+            str, "\t\told_path: %s\r\n", message->content.storage_rename_request.old_path);
+        string_cat_printf(
+            str, "\t\tnew_path: %s\r\n", message->content.storage_rename_request.new_path);
+        break;
+    }
     case PB_Main_gui_start_screen_stream_request_tag:
         string_cat_printf(str, "\tstart_screen_stream {\r\n");
         break;

applications/rpc/rpc_i.h

@@ -21,7 +21,7 @@ void rpc_send_and_release(Rpc* rpc, PB_Main* main_message);
 void rpc_send_and_release_empty(Rpc* rpc, uint32_t command_id, PB_CommandStatus status);
 void rpc_add_handler(Rpc* rpc, pb_size_t message_tag, RpcHandler* handler);
 
-void* rpc_system_status_alloc(Rpc* rpc);
+void* rpc_system_system_alloc(Rpc* rpc);
 void* rpc_system_storage_alloc(Rpc* rpc);
 void rpc_system_storage_free(void* ctx);
 void* rpc_system_app_alloc(Rpc* rpc);

applications/rpc/rpc_status.c

@@ -1,39 +0,0 @@
-#include "flipper.pb.h"
-#include "rpc_i.h"
-#include "status.pb.h"
-
-void rpc_system_status_ping_process(const PB_Main* msg_request, void* context) {
-    if(msg_request->has_next) {
-        rpc_send_and_release_empty(
-            context, msg_request->command_id, PB_CommandStatus_ERROR_INVALID_PARAMETERS);
-        return;
-    }
-
-    PB_Main msg_response = PB_Main_init_default;
-    msg_response.has_next = false;
-    msg_response.command_status = PB_CommandStatus_OK;
-    msg_response.command_id = msg_request->command_id;
-    msg_response.which_content = PB_Main_ping_response_tag;
-
-    const PB_Status_PingRequest* request = &msg_request->content.ping_request;
-    PB_Status_PingResponse* response = &msg_response.content.ping_response;
-    if(request->data && (request->data->size > 0)) {
-        response->data = furi_alloc(PB_BYTES_ARRAY_T_ALLOCSIZE(request->data->size));
-        memcpy(response->data->bytes, request->data->bytes, request->data->size);
-        response->data->size = request->data->size;
-    }
-
-    rpc_send_and_release(context, &msg_response);
-}
-
-void* rpc_system_status_alloc(Rpc* rpc) {
-    RpcHandler rpc_handler = {
-        .message_handler = rpc_system_status_ping_process,
-        .decode_submessage = NULL,
-        .context = rpc,
-    };
-
-    rpc_add_handler(rpc, PB_Main_ping_request_tag, &rpc_handler);
-
-    return NULL;
-}

applications/rpc/rpc_storage.c

@@ -96,6 +96,37 @@ static PB_CommandStatus rpc_system_storage_get_file_error(File* file) {
     return rpc_system_storage_get_error(storage_file_get_error(file));
 }
 
+static void rpc_system_storage_info_process(const PB_Main* request, void* context) {
+    furi_assert(request);
+    furi_assert(context);
+    furi_assert(request->which_content == PB_Main_storage_info_request_tag);
+
+    RpcStorageSystem* rpc_storage = context;
+    rpc_system_storage_reset_state(rpc_storage, true);
+
+    PB_Main* response = furi_alloc(sizeof(PB_Main));
+    response->command_id = request->command_id;
+
+    Storage* fs_api = furi_record_open("storage");
+
+    FS_Error error = storage_common_fs_info(
+        fs_api,
+        request->content.storage_info_request.path,
+        &response->content.storage_info_response.total_space,
+        &response->content.storage_info_response.free_space);
+
+    response->command_status = rpc_system_storage_get_error(error);
+    if(error == FSE_OK) {
+        response->which_content = PB_Main_storage_info_response_tag;
+    } else {
+        response->which_content = PB_Main_empty_tag;
+    }
+
+    rpc_send_and_release(rpc_storage->rpc, response);
+    free(response);
+    furi_record_close("storage");
+}
+
 static void rpc_system_storage_stat_process(const PB_Main* request, void* context) {
     furi_assert(request);
     furi_assert(context);
@@ -388,6 +419,7 @@ static void rpc_system_storage_mkdir_process(const PB_Main* request, void* conte
     } else {
         status = PB_CommandStatus_ERROR_INVALID_PARAMETERS;
     }
+    furi_record_close("storage");
     rpc_send_and_release_empty(rpc_storage->rpc, request->command_id, status);
 }
 
@@ -453,6 +485,26 @@ static void rpc_system_storage_md5sum_process(const PB_Main* request, void* cont
     furi_record_close("storage");
 }
 
+static void rpc_system_storage_rename_process(const PB_Main* request, void* context) {
+    furi_assert(request);
+    furi_assert(request->which_content == PB_Main_storage_rename_request_tag);
+    furi_assert(context);
+    RpcStorageSystem* rpc_storage = context;
+    PB_CommandStatus status;
+    rpc_system_storage_reset_state(rpc_storage, true);
+
+    Storage* fs_api = furi_record_open("storage");
+
+    FS_Error error = storage_common_rename(
+        fs_api,
+        request->content.storage_rename_request.old_path,
+        request->content.storage_rename_request.new_path);
+    status = rpc_system_storage_get_error(error);
+
+    furi_record_close("storage");
+    rpc_send_and_release_empty(rpc_storage->rpc, request->command_id, status);
+}
+
 void* rpc_system_storage_alloc(Rpc* rpc) {
     furi_assert(rpc);
 
@@ -467,6 +519,9 @@ void* rpc_system_storage_alloc(Rpc* rpc) {
         .context = rpc_storage,
     };
 
+    rpc_handler.message_handler = rpc_system_storage_info_process;
+    rpc_add_handler(rpc, PB_Main_storage_info_request_tag, &rpc_handler);
+
     rpc_handler.message_handler = rpc_system_storage_stat_process;
     rpc_add_handler(rpc, PB_Main_storage_stat_request_tag, &rpc_handler);
 
@@ -488,6 +543,9 @@ void* rpc_system_storage_alloc(Rpc* rpc) {
     rpc_handler.message_handler = rpc_system_storage_md5sum_process;
     rpc_add_handler(rpc, PB_Main_storage_md5sum_request_tag, &rpc_handler);
 
+    rpc_handler.message_handler = rpc_system_storage_rename_process;
+    rpc_add_handler(rpc, PB_Main_storage_rename_request_tag, &rpc_handler);
+
     return rpc_storage;
 }
 

applications/rpc/rpc_system.c

@@ -0,0 +1,118 @@
+#include "flipper.pb.h"
+#include "rpc_i.h"
+#include "status.pb.h"
+
+#include <furi-hal-info.h>
+#include <power/power_service/power.h>
+
+void rpc_system_system_ping_process(const PB_Main* msg_request, void* context) {
+    furi_assert(msg_request);
+    furi_assert(msg_request->which_content == PB_Main_system_ping_request_tag);
+    furi_assert(context);
+    Rpc* rpc = context;
+
+    if(msg_request->has_next) {
+        rpc_send_and_release_empty(
+            rpc, msg_request->command_id, PB_CommandStatus_ERROR_INVALID_PARAMETERS);
+        return;
+    }
+
+    PB_Main msg_response = PB_Main_init_default;
+    msg_response.has_next = false;
+    msg_response.command_status = PB_CommandStatus_OK;
+    msg_response.command_id = msg_request->command_id;
+    msg_response.which_content = PB_Main_system_ping_response_tag;
+
+    const PB_System_PingRequest* request = &msg_request->content.system_ping_request;
+    PB_System_PingResponse* response = &msg_response.content.system_ping_response;
+    if(request->data && (request->data->size > 0)) {
+        response->data = furi_alloc(PB_BYTES_ARRAY_T_ALLOCSIZE(request->data->size));
+        memcpy(response->data->bytes, request->data->bytes, request->data->size);
+        response->data->size = request->data->size;
+    }
+
+    rpc_send_and_release(rpc, &msg_response);
+}
+
+void rpc_system_system_reboot_process(const PB_Main* request, void* context) {
+    furi_assert(request);
+    furi_assert(request->which_content == PB_Main_system_reboot_request_tag);
+    furi_assert(context);
+    Rpc* rpc = context;
+
+    const int mode = request->content.system_reboot_request.mode;
+
+    if(mode == PB_System_RebootRequest_RebootMode_OS) {
+        power_reboot(PowerBootModeNormal);
+    } else if(mode == PB_System_RebootRequest_RebootMode_DFU) {
+        power_reboot(PowerBootModeDfu);
+    } else {
+        rpc_send_and_release_empty(
+            rpc, request->command_id, PB_CommandStatus_ERROR_INVALID_PARAMETERS);
+    }
+}
+
+typedef struct {
+    Rpc* rpc;
+    PB_Main* response;
+} RpcSystemSystemDeviceInfoContext;
+
+void rpc_system_system_device_info_callback(
+    const char* key,
+    const char* value,
+    bool last,
+    void* context) {
+    furi_assert(key);
+    furi_assert(value);
+    furi_assert(context);
+    RpcSystemSystemDeviceInfoContext* ctx = context;
+
+    char* str_key = strdup(key);
+    char* str_value = strdup(value);
+
+    ctx->response->has_next = !last;
+    ctx->response->content.system_device_info_response.key = str_key;
+    ctx->response->content.system_device_info_response.value = str_value;
+
+    rpc_send_and_release(ctx->rpc, ctx->response);
+}
+
+void rpc_system_system_device_info_process(const PB_Main* request, void* context) {
+    furi_assert(request);
+    furi_assert(request->which_content == PB_Main_system_device_info_request_tag);
+    furi_assert(context);
+    Rpc* rpc = context;
+
+    PB_Main* response = furi_alloc(sizeof(PB_Main));
+    response->command_id = request->command_id;
+    response->which_content = PB_Main_system_device_info_response_tag;
+    response->command_status = PB_CommandStatus_OK;
+
+    RpcSystemSystemDeviceInfoContext device_info_context = {
+        .rpc = rpc,
+        .response = response,
+    };
+
+    furi_hal_info_get(rpc_system_system_device_info_callback, &device_info_context);
+
+    free(response);
+}
+
+void* rpc_system_system_alloc(Rpc* rpc) {
+    RpcHandler rpc_handler = {
+        .message_handler = NULL,
+        .decode_submessage = NULL,
+        .context = rpc,
+    };
+
+    rpc_handler.message_handler = rpc_system_system_ping_process;
+    rpc_add_handler(rpc, PB_Main_system_ping_request_tag, &rpc_handler);
+
+    rpc_handler.message_handler = rpc_system_system_reboot_process;
+    rpc_add_handler(rpc, PB_Main_system_reboot_request_tag, &rpc_handler);
+
+    rpc_handler.message_handler = rpc_system_system_device_info_process;
+    rpc_add_handler(rpc, PB_Main_system_device_info_request_tag, &rpc_handler);
+
+    return NULL;
+}

applications/tests/rpc/rpc_test.c

@@ -196,8 +196,8 @@ static void test_rpc_add_ping_to_list(MsgList_t msg_list, bool request, uint32_t
     response->command_status = PB_CommandStatus_OK;
     response->cb_content.funcs.encode = NULL;
     response->has_next = false;
-    response->which_content = (request == PING_REQUEST) ? PB_Main_ping_request_tag :
-                                                          PB_Main_ping_response_tag;
+    response->which_content = (request == PING_REQUEST) ? PB_Main_system_ping_request_tag :
+                                                          PB_Main_system_ping_response_tag;
 }
 
 static void test_rpc_create_simple_message(
@@ -209,8 +209,7 @@ static void test_rpc_create_simple_message(
 
     char* str_copy = NULL;
     if(str) {
-        str_copy = furi_alloc(strlen(str) + 1);
-        strcpy(str_copy, str);
+        str_copy = strdup(str);
     }
     message->command_id = command_id;
     message->command_status = PB_CommandStatus_OK;
@@ -218,6 +217,9 @@ static void test_rpc_create_simple_message(
     message->which_content = tag;
     message->has_next = false;
     switch(tag) {
+    case PB_Main_storage_info_request_tag:
+        message->content.storage_info_request.path = str_copy;
+        break;
     case PB_Main_storage_stat_request_tag:
         message->content.storage_stat_request.path = str_copy;
         break;
@@ -268,9 +270,7 @@ static void test_rpc_add_read_or_write_to_list(
         request->command_status = PB_CommandStatus_OK;
 
         if(write == WRITE_REQUEST) {
-            size_t path_size = strlen(path) + 1;
-            request->content.storage_write_request.path = furi_alloc(path_size);
-            strncpy(request->content.storage_write_request.path, path, path_size);
+            request->content.storage_write_request.path = strdup(path);
             request->which_content = PB_Main_storage_write_request_tag;
             request->content.storage_write_request.has_file = true;
             msg_file = &request->content.storage_write_request.file;
@@ -353,10 +353,10 @@ static void test_rpc_compare_messages(PB_Main* result, PB_Main* expected) {
 
     switch(result->which_content) {
     case PB_Main_empty_tag:
-    case PB_Main_ping_response_tag:
+    case PB_Main_system_ping_response_tag:
         /* nothing to check */
         break;
-    case PB_Main_ping_request_tag:
+    case PB_Main_system_ping_request_tag:
     case PB_Main_storage_list_request_tag:
     case PB_Main_storage_read_request_tag:
     case PB_Main_storage_write_request_tag:
@@ -372,6 +372,15 @@ static void test_rpc_compare_messages(PB_Main* result, PB_Main* expected) {
         mu_check(result_locked == expected_locked);
         break;
     }
+    case PB_Main_storage_info_response_tag: {
+        uint64_t result_total_space = result->content.storage_info_response.total_space;
+        uint64_t expected_total_space = expected->content.storage_info_response.total_space;
+        mu_check(result_total_space == expected_total_space);
+
+        uint64_t result_free_space = result->content.storage_info_response.free_space;
+        uint64_t expected_free_space = expected->content.storage_info_response.free_space;
+        mu_check(result_free_space == expected_free_space);
+    } break;
     case PB_Main_storage_stat_response_tag: {
         bool result_has_msg_file = result->content.storage_stat_response.has_file;
         bool expected_has_msg_file = expected->content.storage_stat_response.has_file;
@@ -701,6 +710,38 @@ static void test_create_file(const char* path, size_t size) {
     furi_check(test_is_exists(path));
 }
 
+static void test_rpc_storage_info_run(const char* path, uint32_t command_id) {
+    PB_Main request;
+    MsgList_t expected_msg_list;
+    MsgList_init(expected_msg_list);
+
+    test_rpc_create_simple_message(&request, PB_Main_storage_info_request_tag, path, command_id);
+
+    PB_Main* response = MsgList_push_new(expected_msg_list);
+    response->command_id = command_id;
+
+    Storage* fs_api = furi_record_open("storage");
+
+    FS_Error error = storage_common_fs_info(
+        fs_api,
+        path,
+        &response->content.storage_info_response.total_space,
+        &response->content.storage_info_response.free_space);
+
+    response->command_status = rpc_system_storage_get_error(error);
+    if(error == FSE_OK) {
+        response->which_content = PB_Main_storage_info_response_tag;
+    } else {
+        response->which_content = PB_Main_empty_tag;
+    }
+
+    test_rpc_encode_and_feed_one(&request);
+    test_rpc_decode_and_compare(expected_msg_list);
+
+    pb_release(&PB_Main_msg, &request);
+    test_rpc_free_msg_list(expected_msg_list);
+}
+
 static void test_rpc_storage_stat_run(const char* path, uint32_t command_id) {
     PB_Main request;
     MsgList_t expected_msg_list;
@@ -735,6 +776,12 @@ static void test_rpc_storage_stat_run(const char* path, uint32_t command_id) {
     test_rpc_free_msg_list(expected_msg_list);
 }
 
+MU_TEST(test_storage_info) {
+    test_rpc_storage_info_run("/any", ++command_id);
+    test_rpc_storage_info_run("/int", ++command_id);
+    test_rpc_storage_info_run("/ext", ++command_id);
+}
+
 #define TEST_DIR_STAT_NAME TEST_DIR "stat_dir"
 #define TEST_DIR_STAT TEST_DIR_STAT_NAME "/"
 MU_TEST(test_storage_stat) {
@@ -928,7 +975,7 @@ MU_TEST(test_storage_interrupt_continuous_another_system) {
         .command_status = PB_CommandStatus_OK,
         .cb_content.funcs.encode = NULL,
         .has_next = false,
-        .which_content = PB_Main_ping_request_tag,
+        .which_content = PB_Main_system_ping_request_tag,
     };
 
     MsgList_it_t it;
@@ -1162,6 +1209,54 @@ MU_TEST(test_storage_md5sum) {
     test_storage_md5sum_run(TEST_DIR "file2.txt", ++command_id, md5sum2, PB_CommandStatus_OK);
 }
 
+static void test_rpc_storage_rename_run(
+    const char* old_path,
+    const char* new_path,
+    uint32_t command_id,
+    PB_CommandStatus status) {
+    PB_Main request;
+    MsgList_t expected_msg_list;
+    MsgList_init(expected_msg_list);
+
+    char* str_old_path = strdup(old_path);
+    char* str_new_path = strdup(new_path);
+
+    request.command_id = command_id;
+    request.command_status = PB_CommandStatus_OK;
+    request.cb_content.funcs.encode = NULL;
+    request.which_content = PB_Main_storage_rename_request_tag;
+    request.has_next = false;
+    request.content.storage_rename_request.old_path = str_old_path;
+    request.content.storage_rename_request.new_path = str_new_path;
+
+    test_rpc_add_empty_to_list(expected_msg_list, status, command_id);
+
+    test_rpc_encode_and_feed_one(&request);
+    test_rpc_decode_and_compare(expected_msg_list);
+
+    pb_release(&PB_Main_msg, &request);
+    test_rpc_free_msg_list(expected_msg_list);
+}
+
+MU_TEST(test_storage_rename) {
+    test_rpc_storage_rename_run(
+        NULL, NULL, ++command_id, PB_CommandStatus_ERROR_STORAGE_INVALID_NAME);
+
+    furi_check(!test_is_exists(TEST_DIR "empty.txt"));
+    test_create_file(TEST_DIR "empty.txt", 0);
+    test_rpc_storage_rename_run(
+        TEST_DIR "empty.txt", TEST_DIR "empty2.txt", ++command_id, PB_CommandStatus_OK);
+    mu_check(!test_is_exists(TEST_DIR "empty.txt"));
+    mu_check(test_is_exists(TEST_DIR "empty2.txt"));
+
+    furi_check(!test_is_exists(TEST_DIR "dir1"));
+    test_create_dir(TEST_DIR "dir1");
+    test_rpc_storage_rename_run(
+        TEST_DIR "dir1", TEST_DIR "dir2", ++command_id, PB_CommandStatus_OK);
+    mu_check(!test_is_exists(TEST_DIR "dir1"));
+    mu_check(test_is_exists(TEST_DIR "dir2"));
+}
+
 MU_TEST(test_ping) {
     MsgList_t input_msg_list;
     MsgList_init(input_msg_list);
@@ -1196,7 +1291,7 @@ MU_TEST(test_ping) {
 //       3) test for one push of several packets
 //       4) test for fill buffer till end (great varint) and close connection
 
-MU_TEST_SUITE(test_rpc_status) {
+MU_TEST_SUITE(test_rpc_system) {
     MU_SUITE_CONFIGURE(&test_rpc_setup, &test_rpc_teardown);
 
     MU_RUN_TEST(test_ping);
@@ -1205,6 +1300,7 @@ MU_TEST_SUITE(test_rpc_status) {
 MU_TEST_SUITE(test_rpc_storage) {
     MU_SUITE_CONFIGURE(&test_rpc_storage_setup, &test_rpc_storage_teardown);
 
+    MU_RUN_TEST(test_storage_info);
     MU_RUN_TEST(test_storage_stat);
     MU_RUN_TEST(test_storage_list);
     MU_RUN_TEST(test_storage_read);
@@ -1214,6 +1310,7 @@ MU_TEST_SUITE(test_rpc_storage) {
     MU_RUN_TEST(test_storage_delete_recursive);
     MU_RUN_TEST(test_storage_mkdir);
     MU_RUN_TEST(test_storage_md5sum);
+    MU_RUN_TEST(test_storage_rename);
     MU_RUN_TEST(test_storage_interrupt_continuous_same_system);
     MU_RUN_TEST(test_storage_interrupt_continuous_another_system);
 }
@@ -1230,16 +1327,14 @@ static void test_app_create_request(
     request->has_next = false;
 
     if(app_name) {
-        char* msg_app_name = furi_alloc(strlen(app_name) + 1);
-        strcpy(msg_app_name, app_name);
+        char* msg_app_name = strdup(app_name);
         request->content.app_start_request.name = msg_app_name;
     } else {
         request->content.app_start_request.name = NULL;
     }
 
     if(app_args) {
-        char* msg_app_args = furi_alloc(strlen(app_args) + 1);
-        strcpy(msg_app_args, app_args);
+        char* msg_app_args = strdup(app_args);
         request->content.app_start_request.args = msg_app_args;
     } else {
         request->content.app_start_request.args = NULL;
@@ -1339,7 +1434,7 @@ int run_minunit_test_rpc() {
         MU_RUN_SUITE(test_rpc_storage);
     }
 
-    MU_RUN_SUITE(test_rpc_status);
+    MU_RUN_SUITE(test_rpc_system);
     MU_RUN_SUITE(test_rpc_app);
 
     return MU_EXIT_CODE;

assets/assets.mk

@@ -13,7 +13,7 @@ PROTOBUF_SOURCES		:= $(shell find $(PROTOBUF_SOURCE_DIR) -type f -iname '*.proto
 #PROTOBUF_FILENAMES		:= $(notdir $(PROTOBUF))
 PROTOBUF_FILENAMES		:= $(notdir $(addsuffix .pb.c,$(basename $(PROTOBUF_SOURCES))))
 PROTOBUF				:= $(addprefix $(PROTOBUF_COMPILED_DIR)/,$(PROTOBUF_FILENAMES))
-PROTOBUF_CFLAGS			+= -DPB_ENABLE_MALLOC -DPB_WITHOUT_64BIT
+PROTOBUF_CFLAGS			+= -DPB_ENABLE_MALLOC
 
 CFLAGS				+= -I$(ASSETS_COMPILED_DIR) $(PROTOBUF_CFLAGS)
 C_SOURCES			+= $(wildcard $(ASSETS_COMPILED_DIR)/*.c)

assets/compiled/flipper.pb.h

@@ -5,7 +5,7 @@
 #define PB_PB_FLIPPER_PB_H_INCLUDED
 #include <pb.h>
 #include "storage.pb.h"
-#include "status.pb.h"
+#include "system.pb.h"
 #include "application.pb.h"
 #include "gui.pb.h"
 
@@ -62,8 +62,8 @@ typedef struct _PB_Main {
     pb_size_t which_content;
     union {
         PB_Empty empty;
-        PB_Status_PingRequest ping_request;
-        PB_Status_PingResponse ping_response;
+        PB_System_PingRequest system_ping_request;
+        PB_System_PingResponse system_ping_response;
         PB_Storage_ListRequest storage_list_request;
         PB_Storage_ListResponse storage_list_response;
         PB_Storage_ReadRequest storage_read_request;
@@ -85,6 +85,12 @@ typedef struct _PB_Main {
         PB_Storage_StatResponse storage_stat_response;
         PB_Gui_StartVirtualDisplayRequest gui_start_virtual_display_request;
         PB_Gui_StopVirtualDisplayRequest gui_stop_virtual_display_request;
+        PB_Storage_InfoRequest storage_info_request;
+        PB_Storage_InfoResponse storage_info_response;
+        PB_Storage_RenameRequest storage_rename_request;
+        PB_System_RebootRequest system_reboot_request;
+        PB_System_DeviceInfoRequest system_device_info_request;
+        PB_System_DeviceInfoResponse system_device_info_response;
     } content; 
 } PB_Main;
 
@@ -112,8 +118,8 @@ extern "C" {
 #define PB_Main_command_status_tag               2
 #define PB_Main_has_next_tag                     3
 #define PB_Main_empty_tag                        4
-#define PB_Main_ping_request_tag                 5
-#define PB_Main_ping_response_tag                6
+#define PB_Main_system_ping_request_tag          5
+#define PB_Main_system_ping_response_tag         6
 #define PB_Main_storage_list_request_tag         7
 #define PB_Main_storage_list_response_tag        8
 #define PB_Main_storage_read_request_tag         9
@@ -135,6 +141,12 @@ extern "C" {
 #define PB_Main_storage_stat_response_tag        25
 #define PB_Main_gui_start_virtual_display_request_tag 26
 #define PB_Main_gui_stop_virtual_display_request_tag 27
+#define PB_Main_storage_info_request_tag         28
+#define PB_Main_storage_info_response_tag        29
+#define PB_Main_storage_rename_request_tag       30
+#define PB_Main_system_reboot_request_tag        31
+#define PB_Main_system_device_info_request_tag   32
+#define PB_Main_system_device_info_response_tag  33
 
 /* Struct field encoding specification for nanopb */
 #define PB_Empty_FIELDLIST(X, a) \
@@ -152,8 +164,8 @@ X(a, STATIC,   SINGULAR, UINT32,   command_id,        1) \
 X(a, STATIC,   SINGULAR, UENUM,    command_status,    2) \
 X(a, STATIC,   SINGULAR, BOOL,     has_next,          3) \
 X(a, STATIC,   ONEOF,    MSG_W_CB, (content,empty,content.empty),   4) \
-X(a, STATIC,   ONEOF,    MSG_W_CB, (content,ping_request,content.ping_request),   5) \
-X(a, STATIC,   ONEOF,    MSG_W_CB, (content,ping_response,content.ping_response),   6) \
+X(a, STATIC,   ONEOF,    MSG_W_CB, (content,system_ping_request,content.system_ping_request),   5) \
+X(a, STATIC,   ONEOF,    MSG_W_CB, (content,system_ping_response,content.system_ping_response),   6) \
 X(a, STATIC,   ONEOF,    MSG_W_CB, (content,storage_list_request,content.storage_list_request),   7) \
 X(a, STATIC,   ONEOF,    MSG_W_CB, (content,storage_list_response,content.storage_list_response),   8) \
 X(a, STATIC,   ONEOF,    MSG_W_CB, (content,storage_read_request,content.storage_read_request),   9) \
@@ -174,12 +186,18 @@ X(a, STATIC,   ONEOF,    MSG_W_CB, (content,gui_send_input_event_request,content
 X(a, STATIC,   ONEOF,    MSG_W_CB, (content,storage_stat_request,content.storage_stat_request),  24) \
 X(a, STATIC,   ONEOF,    MSG_W_CB, (content,storage_stat_response,content.storage_stat_response),  25) \
 X(a, STATIC,   ONEOF,    MSG_W_CB, (content,gui_start_virtual_display_request,content.gui_start_virtual_display_request),  26) \
-X(a, STATIC,   ONEOF,    MSG_W_CB, (content,gui_stop_virtual_display_request,content.gui_stop_virtual_display_request),  27)
+X(a, STATIC,   ONEOF,    MSG_W_CB, (content,gui_stop_virtual_display_request,content.gui_stop_virtual_display_request),  27) \
+X(a, STATIC,   ONEOF,    MSG_W_CB, (content,storage_info_request,content.storage_info_request),  28) \
+X(a, STATIC,   ONEOF,    MSG_W_CB, (content,storage_info_response,content.storage_info_response),  29) \
+X(a, STATIC,   ONEOF,    MSG_W_CB, (content,storage_rename_request,content.storage_rename_request),  30) \
+X(a, STATIC,   ONEOF,    MSG_W_CB, (content,system_reboot_request,content.system_reboot_request),  31) \
+X(a, STATIC,   ONEOF,    MSG_W_CB, (content,system_device_info_request,content.system_device_info_request),  32) \
+X(a, STATIC,   ONEOF,    MSG_W_CB, (content,system_device_info_response,content.system_device_info_response),  33)
 #define PB_Main_CALLBACK NULL
 #define PB_Main_DEFAULT NULL
 #define PB_Main_content_empty_MSGTYPE PB_Empty
-#define PB_Main_content_ping_request_MSGTYPE PB_Status_PingRequest
-#define PB_Main_content_ping_response_MSGTYPE PB_Status_PingResponse
+#define PB_Main_content_system_ping_request_MSGTYPE PB_System_PingRequest
+#define PB_Main_content_system_ping_response_MSGTYPE PB_System_PingResponse
 #define PB_Main_content_storage_list_request_MSGTYPE PB_Storage_ListRequest
 #define PB_Main_content_storage_list_response_MSGTYPE PB_Storage_ListResponse
 #define PB_Main_content_storage_read_request_MSGTYPE PB_Storage_ReadRequest
@@ -201,6 +219,12 @@ X(a, STATIC,   ONEOF,    MSG_W_CB, (content,gui_stop_virtual_display_request,con
 #define PB_Main_content_storage_stat_response_MSGTYPE PB_Storage_StatResponse
 #define PB_Main_content_gui_start_virtual_display_request_MSGTYPE PB_Gui_StartVirtualDisplayRequest
 #define PB_Main_content_gui_stop_virtual_display_request_MSGTYPE PB_Gui_StopVirtualDisplayRequest
+#define PB_Main_content_storage_info_request_MSGTYPE PB_Storage_InfoRequest
+#define PB_Main_content_storage_info_response_MSGTYPE PB_Storage_InfoResponse
+#define PB_Main_content_storage_rename_request_MSGTYPE PB_Storage_RenameRequest
+#define PB_Main_content_system_reboot_request_MSGTYPE PB_System_RebootRequest
+#define PB_Main_content_system_device_info_request_MSGTYPE PB_System_DeviceInfoRequest
+#define PB_Main_content_system_device_info_response_MSGTYPE PB_System_DeviceInfoResponse
 
 extern const pb_msgdesc_t PB_Empty_msg;
 extern const pb_msgdesc_t PB_StopSession_msg;
@@ -214,9 +238,9 @@ extern const pb_msgdesc_t PB_Main_msg;
 /* Maximum encoded size of messages (where known) */
 #define PB_Empty_size                            0
 #define PB_StopSession_size                      0
-#if defined(PB_Status_PingRequest_size) && defined(PB_Status_PingResponse_size) && defined(PB_Storage_ListRequest_size) && defined(PB_Storage_ListResponse_size) && defined(PB_Storage_ReadRequest_size) && defined(PB_Storage_ReadResponse_size) && defined(PB_Storage_WriteRequest_size) && defined(PB_Storage_DeleteRequest_size) && defined(PB_Storage_MkdirRequest_size) && defined(PB_Storage_Md5sumRequest_size) && defined(PB_App_StartRequest_size) && defined(PB_Gui_ScreenFrame_size) && defined(PB_Storage_StatRequest_size) && defined(PB_Storage_StatResponse_size)
+#if defined(PB_System_PingRequest_size) && defined(PB_System_PingResponse_size) && defined(PB_Storage_ListRequest_size) && defined(PB_Storage_ListResponse_size) && defined(PB_Storage_ReadRequest_size) && defined(PB_Storage_ReadResponse_size) && defined(PB_Storage_WriteRequest_size) && defined(PB_Storage_DeleteRequest_size) && defined(PB_Storage_MkdirRequest_size) && defined(PB_Storage_Md5sumRequest_size) && defined(PB_App_StartRequest_size) && defined(PB_Gui_ScreenFrame_size) && defined(PB_Storage_StatRequest_size) && defined(PB_Storage_StatResponse_size) && defined(PB_Storage_InfoRequest_size) && defined(PB_Storage_RenameRequest_size) && defined(PB_System_DeviceInfoResponse_size)
 #define PB_Main_size                             (10 + sizeof(union PB_Main_content_size_union))
-union PB_Main_content_size_union {char f5[(6 + PB_Status_PingRequest_size)]; char f6[(6 + PB_Status_PingResponse_size)]; char f7[(6 + PB_Storage_ListRequest_size)]; char f8[(6 + PB_Storage_ListResponse_size)]; char f9[(6 + PB_Storage_ReadRequest_size)]; char f10[(6 + PB_Storage_ReadResponse_size)]; char f11[(6 + PB_Storage_WriteRequest_size)]; char f12[(6 + PB_Storage_DeleteRequest_size)]; char f13[(6 + PB_Storage_MkdirRequest_size)]; char f14[(6 + PB_Storage_Md5sumRequest_size)]; char f16[(7 + PB_App_StartRequest_size)]; char f22[(7 + PB_Gui_ScreenFrame_size)]; char f24[(7 + PB_Storage_StatRequest_size)]; char f25[(7 + PB_Storage_StatResponse_size)]; char f0[36];};
+union PB_Main_content_size_union {char f5[(6 + PB_System_PingRequest_size)]; char f6[(6 + PB_System_PingResponse_size)]; char f7[(6 + PB_Storage_ListRequest_size)]; char f8[(6 + PB_Storage_ListResponse_size)]; char f9[(6 + PB_Storage_ReadRequest_size)]; char f10[(6 + PB_Storage_ReadResponse_size)]; char f11[(6 + PB_Storage_WriteRequest_size)]; char f12[(6 + PB_Storage_DeleteRequest_size)]; char f13[(6 + PB_Storage_MkdirRequest_size)]; char f14[(6 + PB_Storage_Md5sumRequest_size)]; char f16[(7 + PB_App_StartRequest_size)]; char f22[(7 + PB_Gui_ScreenFrame_size)]; char f24[(7 + PB_Storage_StatRequest_size)]; char f25[(7 + PB_Storage_StatResponse_size)]; char f28[(7 + PB_Storage_InfoRequest_size)]; char f30[(7 + PB_Storage_RenameRequest_size)]; char f33[(7 + PB_System_DeviceInfoResponse_size)]; char f0[36];};
 #endif
 
 #ifdef __cplusplus

assets/compiled/storage.pb.c

@@ -9,6 +9,12 @@
 PB_BIND(PB_Storage_File, PB_Storage_File, AUTO)
 
 
+PB_BIND(PB_Storage_InfoRequest, PB_Storage_InfoRequest, AUTO)
+
+
+PB_BIND(PB_Storage_InfoResponse, PB_Storage_InfoResponse, AUTO)
+
+
 PB_BIND(PB_Storage_StatRequest, PB_Storage_StatRequest, AUTO)
 
 
@@ -42,5 +48,8 @@ PB_BIND(PB_Storage_Md5sumRequest, PB_Storage_Md5sumRequest, AUTO)
 PB_BIND(PB_Storage_Md5sumResponse, PB_Storage_Md5sumResponse, AUTO)
 
 
+PB_BIND(PB_Storage_RenameRequest, PB_Storage_RenameRequest, AUTO)
+
+
 
 

assets/compiled/storage.pb.h

@@ -16,6 +16,10 @@ typedef enum _PB_Storage_File_FileType {
 } PB_Storage_File_FileType;
 
 /* Struct definitions */
+typedef struct _PB_Storage_InfoRequest { 
+    char *path; 
+} PB_Storage_InfoRequest;
+
 typedef struct _PB_Storage_ListRequest { 
     char *path; 
 } PB_Storage_ListRequest;
@@ -32,6 +36,11 @@ typedef struct _PB_Storage_ReadRequest {
     char *path; 
 } PB_Storage_ReadRequest;
 
+typedef struct _PB_Storage_RenameRequest { 
+    char *old_path; 
+    char *new_path; 
+} PB_Storage_RenameRequest;
+
 typedef struct _PB_Storage_StatRequest { 
     char *path; 
 } PB_Storage_StatRequest;
@@ -48,6 +57,11 @@ typedef struct _PB_Storage_File {
     pb_bytes_array_t *data; 
 } PB_Storage_File;
 
+typedef struct _PB_Storage_InfoResponse { 
+    uint64_t total_space; 
+    uint64_t free_space; 
+} PB_Storage_InfoResponse;
+
 typedef struct _PB_Storage_Md5sumResponse { 
     char md5sum[33]; 
 } PB_Storage_Md5sumResponse;
@@ -86,6 +100,8 @@ extern "C" {
 
 /* Initializer values for message structs */
 #define PB_Storage_File_init_default             {_PB_Storage_File_FileType_MIN, NULL, 0, NULL}
+#define PB_Storage_InfoRequest_init_default      {NULL}
+#define PB_Storage_InfoResponse_init_default     {0, 0}
 #define PB_Storage_StatRequest_init_default      {NULL}
 #define PB_Storage_StatResponse_init_default     {false, PB_Storage_File_init_default}
 #define PB_Storage_ListRequest_init_default      {NULL}
@@ -97,7 +113,10 @@ extern "C" {
 #define PB_Storage_MkdirRequest_init_default     {NULL}
 #define PB_Storage_Md5sumRequest_init_default    {NULL}
 #define PB_Storage_Md5sumResponse_init_default   {""}
+#define PB_Storage_RenameRequest_init_default    {NULL, NULL}
 #define PB_Storage_File_init_zero                {_PB_Storage_File_FileType_MIN, NULL, 0, NULL}
+#define PB_Storage_InfoRequest_init_zero         {NULL}
+#define PB_Storage_InfoResponse_init_zero        {0, 0}
 #define PB_Storage_StatRequest_init_zero         {NULL}
 #define PB_Storage_StatResponse_init_zero        {false, PB_Storage_File_init_zero}
 #define PB_Storage_ListRequest_init_zero         {NULL}
@@ -109,12 +128,16 @@ extern "C" {
 #define PB_Storage_MkdirRequest_init_zero        {NULL}
 #define PB_Storage_Md5sumRequest_init_zero       {NULL}
 #define PB_Storage_Md5sumResponse_init_zero      {""}
+#define PB_Storage_RenameRequest_init_zero       {NULL, NULL}
 
 /* Field tags (for use in manual encoding/decoding) */
+#define PB_Storage_InfoRequest_path_tag          1
 #define PB_Storage_ListRequest_path_tag          1
 #define PB_Storage_Md5sumRequest_path_tag        1
 #define PB_Storage_MkdirRequest_path_tag         1
 #define PB_Storage_ReadRequest_path_tag          1
+#define PB_Storage_RenameRequest_old_path_tag    1
+#define PB_Storage_RenameRequest_new_path_tag    2
 #define PB_Storage_StatRequest_path_tag          1
 #define PB_Storage_DeleteRequest_path_tag        1
 #define PB_Storage_DeleteRequest_recursive_tag   2
@@ -122,6 +145,8 @@ extern "C" {
 #define PB_Storage_File_name_tag                 2
 #define PB_Storage_File_size_tag                 3
 #define PB_Storage_File_data_tag                 4
+#define PB_Storage_InfoResponse_total_space_tag  1
+#define PB_Storage_InfoResponse_free_space_tag   2
 #define PB_Storage_Md5sumResponse_md5sum_tag     1
 #define PB_Storage_ListResponse_file_tag         1
 #define PB_Storage_ReadResponse_file_tag         1
@@ -138,6 +163,17 @@ X(a, POINTER,  SINGULAR, BYTES,    data,              4)
 #define PB_Storage_File_CALLBACK NULL
 #define PB_Storage_File_DEFAULT NULL
 
+#define PB_Storage_InfoRequest_FIELDLIST(X, a) \
+X(a, POINTER,  SINGULAR, STRING,   path,              1)
+#define PB_Storage_InfoRequest_CALLBACK NULL
+#define PB_Storage_InfoRequest_DEFAULT NULL
+
+#define PB_Storage_InfoResponse_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT64,   total_space,       1) \
+X(a, STATIC,   SINGULAR, UINT64,   free_space,        2)
+#define PB_Storage_InfoResponse_CALLBACK NULL
+#define PB_Storage_InfoResponse_DEFAULT NULL
+
 #define PB_Storage_StatRequest_FIELDLIST(X, a) \
 X(a, POINTER,  SINGULAR, STRING,   path,              1)
 #define PB_Storage_StatRequest_CALLBACK NULL
@@ -199,7 +235,15 @@ X(a, STATIC,   SINGULAR, STRING,   md5sum,            1)
 #define PB_Storage_Md5sumResponse_CALLBACK NULL
 #define PB_Storage_Md5sumResponse_DEFAULT NULL
 
+#define PB_Storage_RenameRequest_FIELDLIST(X, a) \
+X(a, POINTER,  SINGULAR, STRING,   old_path,          1) \
+X(a, POINTER,  SINGULAR, STRING,   new_path,          2)
+#define PB_Storage_RenameRequest_CALLBACK NULL
+#define PB_Storage_RenameRequest_DEFAULT NULL
+
 extern const pb_msgdesc_t PB_Storage_File_msg;
+extern const pb_msgdesc_t PB_Storage_InfoRequest_msg;
+extern const pb_msgdesc_t PB_Storage_InfoResponse_msg;
 extern const pb_msgdesc_t PB_Storage_StatRequest_msg;
 extern const pb_msgdesc_t PB_Storage_StatResponse_msg;
 extern const pb_msgdesc_t PB_Storage_ListRequest_msg;
@@ -211,9 +255,12 @@ extern const pb_msgdesc_t PB_Storage_DeleteRequest_msg;
 extern const pb_msgdesc_t PB_Storage_MkdirRequest_msg;
 extern const pb_msgdesc_t PB_Storage_Md5sumRequest_msg;
 extern const pb_msgdesc_t PB_Storage_Md5sumResponse_msg;
+extern const pb_msgdesc_t PB_Storage_RenameRequest_msg;
 
 /* Defines for backwards compatibility with code written before nanopb-0.4.0 */
 #define PB_Storage_File_fields &PB_Storage_File_msg
+#define PB_Storage_InfoRequest_fields &PB_Storage_InfoRequest_msg
+#define PB_Storage_InfoResponse_fields &PB_Storage_InfoResponse_msg
 #define PB_Storage_StatRequest_fields &PB_Storage_StatRequest_msg
 #define PB_Storage_StatResponse_fields &PB_Storage_StatResponse_msg
 #define PB_Storage_ListRequest_fields &PB_Storage_ListRequest_msg
@@ -225,9 +272,11 @@ extern const pb_msgdesc_t PB_Storage_Md5sumResponse_msg;
 #define PB_Storage_MkdirRequest_fields &PB_Storage_MkdirRequest_msg
 #define PB_Storage_Md5sumRequest_fields &PB_Storage_Md5sumRequest_msg
 #define PB_Storage_Md5sumResponse_fields &PB_Storage_Md5sumResponse_msg
+#define PB_Storage_RenameRequest_fields &PB_Storage_RenameRequest_msg
 
 /* Maximum encoded size of messages (where known) */
 /* PB_Storage_File_size depends on runtime parameters */
+/* PB_Storage_InfoRequest_size depends on runtime parameters */
 /* PB_Storage_StatRequest_size depends on runtime parameters */
 /* PB_Storage_StatResponse_size depends on runtime parameters */
 /* PB_Storage_ListRequest_size depends on runtime parameters */
@@ -238,6 +287,8 @@ extern const pb_msgdesc_t PB_Storage_Md5sumResponse_msg;
 /* PB_Storage_DeleteRequest_size depends on runtime parameters */
 /* PB_Storage_MkdirRequest_size depends on runtime parameters */
 /* PB_Storage_Md5sumRequest_size depends on runtime parameters */
+/* PB_Storage_RenameRequest_size depends on runtime parameters */
+#define PB_Storage_InfoResponse_size             22
 #define PB_Storage_Md5sumResponse_size           34
 
 #ifdef __cplusplus

assets/compiled/system.pb.c

@@ -0,0 +1,25 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.5 */
+
+#include "system.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(PB_System_PingRequest, PB_System_PingRequest, AUTO)
+
+
+PB_BIND(PB_System_PingResponse, PB_System_PingResponse, AUTO)
+
+
+PB_BIND(PB_System_RebootRequest, PB_System_RebootRequest, AUTO)
+
+
+PB_BIND(PB_System_DeviceInfoRequest, PB_System_DeviceInfoRequest, AUTO)
+
+
+PB_BIND(PB_System_DeviceInfoResponse, PB_System_DeviceInfoResponse, AUTO)
+
+
+
+

assets/compiled/system.pb.h

@@ -0,0 +1,121 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.5 */
+
+#ifndef PB_PB_SYSTEM_SYSTEM_PB_H_INCLUDED
+#define PB_PB_SYSTEM_SYSTEM_PB_H_INCLUDED
+#include <pb.h>
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Enum definitions */
+typedef enum _PB_System_RebootRequest_RebootMode { 
+    PB_System_RebootRequest_RebootMode_OS = 0, 
+    PB_System_RebootRequest_RebootMode_DFU = 1 
+} PB_System_RebootRequest_RebootMode;
+
+/* Struct definitions */
+typedef struct _PB_System_DeviceInfoRequest { 
+    char dummy_field;
+} PB_System_DeviceInfoRequest;
+
+typedef struct _PB_System_DeviceInfoResponse { 
+    char *key; 
+    char *value; 
+} PB_System_DeviceInfoResponse;
+
+typedef struct _PB_System_PingRequest { 
+    pb_bytes_array_t *data; 
+} PB_System_PingRequest;
+
+typedef struct _PB_System_PingResponse { 
+    pb_bytes_array_t *data; 
+} PB_System_PingResponse;
+
+typedef struct _PB_System_RebootRequest { 
+    PB_System_RebootRequest_RebootMode mode; 
+} PB_System_RebootRequest;
+
+
+/* Helper constants for enums */
+#define _PB_System_RebootRequest_RebootMode_MIN PB_System_RebootRequest_RebootMode_OS
+#define _PB_System_RebootRequest_RebootMode_MAX PB_System_RebootRequest_RebootMode_DFU
+#define _PB_System_RebootRequest_RebootMode_ARRAYSIZE ((PB_System_RebootRequest_RebootMode)(PB_System_RebootRequest_RebootMode_DFU+1))
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define PB_System_PingRequest_init_default       {NULL}
+#define PB_System_PingResponse_init_default      {NULL}
+#define PB_System_RebootRequest_init_default     {_PB_System_RebootRequest_RebootMode_MIN}
+#define PB_System_DeviceInfoRequest_init_default {0}
+#define PB_System_DeviceInfoResponse_init_default {NULL, NULL}
+#define PB_System_PingRequest_init_zero          {NULL}
+#define PB_System_PingResponse_init_zero         {NULL}
+#define PB_System_RebootRequest_init_zero        {_PB_System_RebootRequest_RebootMode_MIN}
+#define PB_System_DeviceInfoRequest_init_zero    {0}
+#define PB_System_DeviceInfoResponse_init_zero   {NULL, NULL}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define PB_System_DeviceInfoResponse_key_tag     1
+#define PB_System_DeviceInfoResponse_value_tag   2
+#define PB_System_PingRequest_data_tag           1
+#define PB_System_PingResponse_data_tag          1
+#define PB_System_RebootRequest_mode_tag         1
+
+/* Struct field encoding specification for nanopb */
+#define PB_System_PingRequest_FIELDLIST(X, a) \
+X(a, POINTER,  SINGULAR, BYTES,    data,              1)
+#define PB_System_PingRequest_CALLBACK NULL
+#define PB_System_PingRequest_DEFAULT NULL
+
+#define PB_System_PingResponse_FIELDLIST(X, a) \
+X(a, POINTER,  SINGULAR, BYTES,    data,              1)
+#define PB_System_PingResponse_CALLBACK NULL
+#define PB_System_PingResponse_DEFAULT NULL
+
+#define PB_System_RebootRequest_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UENUM,    mode,              1)
+#define PB_System_RebootRequest_CALLBACK NULL
+#define PB_System_RebootRequest_DEFAULT NULL
+
+#define PB_System_DeviceInfoRequest_FIELDLIST(X, a) \
+
+#define PB_System_DeviceInfoRequest_CALLBACK NULL
+#define PB_System_DeviceInfoRequest_DEFAULT NULL
+
+#define PB_System_DeviceInfoResponse_FIELDLIST(X, a) \
+X(a, POINTER,  SINGULAR, STRING,   key,               1) \
+X(a, POINTER,  SINGULAR, STRING,   value,             2)
+#define PB_System_DeviceInfoResponse_CALLBACK NULL
+#define PB_System_DeviceInfoResponse_DEFAULT NULL
+
+extern const pb_msgdesc_t PB_System_PingRequest_msg;
+extern const pb_msgdesc_t PB_System_PingResponse_msg;
+extern const pb_msgdesc_t PB_System_RebootRequest_msg;
+extern const pb_msgdesc_t PB_System_DeviceInfoRequest_msg;
+extern const pb_msgdesc_t PB_System_DeviceInfoResponse_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define PB_System_PingRequest_fields &PB_System_PingRequest_msg
+#define PB_System_PingResponse_fields &PB_System_PingResponse_msg
+#define PB_System_RebootRequest_fields &PB_System_RebootRequest_msg
+#define PB_System_DeviceInfoRequest_fields &PB_System_DeviceInfoRequest_msg
+#define PB_System_DeviceInfoResponse_fields &PB_System_DeviceInfoResponse_msg
+
+/* Maximum encoded size of messages (where known) */
+/* PB_System_PingRequest_size depends on runtime parameters */
+/* PB_System_PingResponse_size depends on runtime parameters */
+/* PB_System_DeviceInfoResponse_size depends on runtime parameters */
+#define PB_System_DeviceInfoRequest_size         0
+#define PB_System_RebootRequest_size             2
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

assets/protobuf

@@ -1 +1 @@
-Subproject commit 060aead10b80622975b14a077420354d26e0be38
+Subproject commit 5761a23786b4729303bfa49142effea51870e549

firmware/targets/f6/furi-hal/furi-hal-info.c

@@ -0,0 +1,189 @@
+#include <furi-hal-info.h>
+#include <furi-hal.h>
+#include <shci.h>
+
+#define ENCLAVE_SIGNATURE_KEY_SLOTS 10
+#define ENCLAVE_SIGNATURE_SIZE 16
+
+static const uint8_t enclave_signature_iv[ENCLAVE_SIGNATURE_KEY_SLOTS][16] = {
+    {0xac, 0x5d, 0x68, 0xb8, 0x79, 0x74, 0xfc, 0x7f, 0x45, 0x02, 0x82, 0xf1, 0x48, 0x7e, 0x75, 0x8a},
+    {0x38, 0xe6, 0x6a, 0x90, 0x5e, 0x5b, 0x8a, 0xa6, 0x70, 0x30, 0x04, 0x72, 0xc2, 0x42, 0xea, 0xaf},
+    {0x73, 0xd5, 0x8e, 0xfb, 0x0f, 0x4b, 0xa9, 0x79, 0x0f, 0xde, 0x0e, 0x53, 0x44, 0x7d, 0xaa, 0xfd},
+    {0x3c, 0x9a, 0xf4, 0x43, 0x2b, 0xfe, 0xea, 0xae, 0x8c, 0xc6, 0xd1, 0x60, 0xd2, 0x96, 0x64, 0xa9},
+    {0x10, 0xac, 0x7b, 0x63, 0x03, 0x7f, 0x43, 0x18, 0xec, 0x9d, 0x9c, 0xc4, 0x01, 0xdc, 0x35, 0xa7},
+    {0x26, 0x21, 0x64, 0xe6, 0xd0, 0xf2, 0x47, 0x49, 0xdc, 0x36, 0xcd, 0x68, 0x0c, 0x91, 0x03, 0x44},
+    {0x7a, 0xbd, 0xce, 0x9c, 0x24, 0x7a, 0x2a, 0xb1, 0x3c, 0x4f, 0x5a, 0x7d, 0x80, 0x3e, 0xfc, 0x0d},
+    {0xcd, 0xdd, 0xd3, 0x02, 0x85, 0x65, 0x43, 0x83, 0xf9, 0xac, 0x75, 0x2f, 0x21, 0xef, 0x28, 0x6b},
+    {0xab, 0x73, 0x70, 0xe8, 0xe2, 0x56, 0x0f, 0x58, 0xab, 0x29, 0xa5, 0xb1, 0x13, 0x47, 0x5e, 0xe8},
+    {0x4f, 0x3c, 0x43, 0x77, 0xde, 0xed, 0x79, 0xa1, 0x8d, 0x4c, 0x1f, 0xfd, 0xdb, 0x96, 0x87, 0x2e},
+};
+
+static const uint8_t enclave_signature_input[ENCLAVE_SIGNATURE_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
+    {0x9f, 0x5c, 0xb1, 0x43, 0x17, 0x53, 0x18, 0x8c, 0x66, 0x3d, 0x39, 0x45, 0x90, 0x13, 0xa9, 0xde},
+    {0xc5, 0x98, 0xe9, 0x17, 0xb8, 0x97, 0x9e, 0x03, 0x33, 0x14, 0x13, 0x8f, 0xce, 0x74, 0x0d, 0x54},
+    {0x34, 0xba, 0x99, 0x59, 0x9f, 0x70, 0x67, 0xe9, 0x09, 0xee, 0x64, 0x0e, 0xb3, 0xba, 0xfb, 0x75},
+    {0xdc, 0xfa, 0x6c, 0x9a, 0x6f, 0x0a, 0x3e, 0xdc, 0x42, 0xf6, 0xae, 0x0d, 0x3c, 0xf7, 0x83, 0xaf},
+    {0xea, 0x2d, 0xe3, 0x1f, 0x02, 0x99, 0x1a, 0x7e, 0x6d, 0x93, 0x4c, 0xb5, 0x42, 0xf0, 0x7a, 0x9b},
+    {0x53, 0x5e, 0x04, 0xa2, 0x49, 0xa0, 0x73, 0x49, 0x56, 0xb0, 0x88, 0x8c, 0x12, 0xa0, 0xe4, 0x18},
+    {0x7d, 0xa7, 0xc5, 0x21, 0x7f, 0x12, 0x95, 0xdd, 0x4d, 0x77, 0x01, 0xfa, 0x71, 0x88, 0x2b, 0x7f},
+    {0xdc, 0x9b, 0xc5, 0xa7, 0x6b, 0x84, 0x5c, 0x37, 0x7c, 0xec, 0x05, 0xa1, 0x9f, 0x91, 0x17, 0x3b},
+    {0xea, 0xcf, 0xd9, 0x9b, 0x86, 0xcd, 0x2b, 0x43, 0x54, 0x45, 0x82, 0xc6, 0xfe, 0x73, 0x1a, 0x1a},
+    {0x77, 0xb8, 0x1b, 0x90, 0xb4, 0xb7, 0x32, 0x76, 0x8f, 0x8a, 0x57, 0x06, 0xc7, 0xdd, 0x08, 0x90},
+};
+
+static const uint8_t enclave_signature_expected[ENCLAVE_SIGNATURE_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
+    {0xe9, 0x9a, 0xce, 0xe9, 0x4d, 0xe1, 0x7f, 0x55, 0xcb, 0x8a, 0xbf, 0xf2, 0x4d, 0x98, 0x27, 0x67},
+    {0x34, 0x27, 0xa7, 0xea, 0xa8, 0x98, 0x66, 0x9b, 0xed, 0x43, 0xd3, 0x93, 0xb5, 0xa2, 0x87, 0x8e},
+    {0x6c, 0xf3, 0x01, 0x78, 0x53, 0x1b, 0x11, 0x32, 0xf0, 0x27, 0x2f, 0xe3, 0x7d, 0xa6, 0xe2, 0xfd},
+    {0xdf, 0x7f, 0x37, 0x65, 0x2f, 0xdb, 0x7c, 0xcf, 0x5b, 0xb6, 0xe4, 0x9c, 0x63, 0xc5, 0x0f, 0xe0},
+    {0x9b, 0x5c, 0xee, 0x44, 0x0e, 0xd1, 0xcb, 0x5f, 0x28, 0x9f, 0x12, 0x17, 0x59, 0x64, 0x40, 0xbb},
+    {0x94, 0xc2, 0x09, 0x98, 0x62, 0xa7, 0x2b, 0x93, 0xed, 0x36, 0x1f, 0x10, 0xbc, 0x26, 0xbd, 0x41},
+    {0x4d, 0xb2, 0x2b, 0xc5, 0x96, 0x47, 0x61, 0xf4, 0x16, 0xe0, 0x81, 0xc3, 0x8e, 0xb9, 0x9c, 0x9b},
+    {0xc3, 0x6b, 0x83, 0x55, 0x90, 0x38, 0x0f, 0xea, 0xd1, 0x65, 0xbf, 0x32, 0x4f, 0x8e, 0x62, 0x5b},
+    {0x8d, 0x5e, 0x27, 0xbc, 0x14, 0x4f, 0x08, 0xa8, 0x2b, 0x14, 0x89, 0x5e, 0xdf, 0x77, 0x04, 0x31},
+    {0xc9, 0xf7, 0x03, 0xf1, 0x6c, 0x65, 0xad, 0x49, 0x74, 0xbe, 0x00, 0x54, 0xfd, 0xa6, 0x9c, 0x32},
+};
+
+void furi_hal_info_get(FuriHalInfoValueCallback out, void* context) {
+    string_t value;
+    string_init(value);
+
+    // Device Info version
+    out("device_info_major", "2", false, context);
+    out("device_info_minor", "0", false, context);
+
+    // Model name
+    out("hardware_model", furi_hal_version_get_model_name(), false, context);
+
+    // Unique ID
+    string_reset(value);
+    const uint8_t* uid = furi_hal_version_uid();
+    for(size_t i = 0; i < furi_hal_version_uid_size(); i++) {
+        string_cat_printf(value, "%02X", uid[i]);
+    }
+    out("hardware_uid", string_get_cstr(value), false, context);
+
+    // OTP Revision
+    string_printf(value, "%d", furi_hal_version_get_otp_version());
+    out("hardware_otp_ver", string_get_cstr(value), false, context);
+    string_printf(value, "%lu", furi_hal_version_get_hw_timestamp());
+    out("hardware_timestamp", string_get_cstr(value), false, context);
+
+    // Board Revision
+    string_printf(value, "%d", furi_hal_version_get_hw_version());
+    out("hardware_ver", string_get_cstr(value), false, context);
+    string_printf(value, "%d", furi_hal_version_get_hw_target());
+    out("hardware_target", string_get_cstr(value), false, context);
+    string_printf(value, "%d", furi_hal_version_get_hw_body());
+    out("hardware_body", string_get_cstr(value), false, context);
+    string_printf(value, "%d", furi_hal_version_get_hw_connect());
+    out("hardware_connect", string_get_cstr(value), false, context);
+    string_printf(value, "%d", furi_hal_version_get_hw_display());
+    out("hardware_display", string_get_cstr(value), false, context);
+
+    // Board Personification
+    string_printf(value, "%d", furi_hal_version_get_hw_color());
+    out("hardware_color", string_get_cstr(value), false, context);
+    string_printf(value, "%d", furi_hal_version_get_hw_region());
+    out("hardware_region", string_get_cstr(value), false, context);
+    const char* name = furi_hal_version_get_name_ptr();
+    if(name) {
+        out("hardware_name", name, false, context);
+    }
+
+    // Bootloader Version
+    const Version* bootloader_version = furi_hal_version_get_bootloader_version();
+    if(bootloader_version) {
+        out("bootloader_commit", version_get_githash(bootloader_version), false, context);
+        out("bootloader_branch", version_get_gitbranch(bootloader_version), false, context);
+        out("bootloader_branch_num", version_get_gitbranchnum(bootloader_version), false, context);
+        out("bootloader_version", version_get_version(bootloader_version), false, context);
+        out("bootloader_build_date", version_get_builddate(bootloader_version), false, context);
+        string_printf(value, "%d", version_get_target(bootloader_version));
+        out("bootloader_target", string_get_cstr(value), false, context);
+    }
+
+    // Firmware version
+    const Version* firmware_version = furi_hal_version_get_firmware_version();
+    if(firmware_version) {
+        out("firmware_commit", version_get_githash(firmware_version), false, context);
+        out("firmware_branch", version_get_gitbranch(firmware_version), false, context);
+        out("firmware_branch_num", version_get_gitbranchnum(firmware_version), false, context);
+        out("firmware_version", version_get_version(firmware_version), false, context);
+        out("firmware_build_date", version_get_builddate(firmware_version), false, context);
+        string_printf(value, "%d", version_get_target(firmware_version));
+        out("firmware_target", string_get_cstr(value), false, context);
+    }
+
+    WirelessFwInfo_t pWirelessInfo;
+    if(furi_hal_bt_is_alive() && SHCI_GetWirelessFwInfo(&pWirelessInfo) == SHCI_Success) {
+        out("radio_alive", "true", false, context);
+
+        // FUS Info
+        string_printf(value, "%d", pWirelessInfo.FusVersionMajor);
+        out("radio_fus_major", string_get_cstr(value), false, context);
+        string_printf(value, "%d", pWirelessInfo.FusVersionMinor);
+        out("radio_fus_minor", string_get_cstr(value), false, context);
+        string_printf(value, "%d", pWirelessInfo.FusVersionSub);
+        out("radio_fus_sub", string_get_cstr(value), false, context);
+        string_printf(value, "%dK", pWirelessInfo.FusMemorySizeSram2B);
+        out("radio_fus_sram2b", string_get_cstr(value), false, context);
+        string_printf(value, "%dK", pWirelessInfo.FusMemorySizeSram2A);
+        out("radio_fus_sram2a", string_get_cstr(value), false, context);
+        string_printf(value, "%dK", pWirelessInfo.FusMemorySizeFlash * 4);
+        out("radio_fus_flash", string_get_cstr(value), false, context);
+
+        // Stack Info
+        string_printf(value, "%d", pWirelessInfo.StackType);
+        out("radio_stack_type", string_get_cstr(value), false, context);
+        string_printf(value, "%d", pWirelessInfo.VersionMajor);
+        out("radio_stack_major", string_get_cstr(value), false, context);
+        string_printf(value, "%d", pWirelessInfo.VersionMinor);
+        out("radio_stack_minor", string_get_cstr(value), false, context);
+        string_printf(value, "%d", pWirelessInfo.VersionSub);
+        out("radio_stack_sub", string_get_cstr(value), false, context);
+        string_printf(value, "%d", pWirelessInfo.VersionBranch);
+        out("radio_stack_branch", string_get_cstr(value), false, context);
+        string_printf(value, "%d", pWirelessInfo.VersionReleaseType);
+        out("radio_stack_release", string_get_cstr(value), false, context);
+        string_printf(value, "%dK", pWirelessInfo.MemorySizeSram2B);
+        out("radio_stack_sram2b", string_get_cstr(value), false, context);
+        string_printf(value, "%dK", pWirelessInfo.MemorySizeSram2A);
+        out("radio_stack_sram2a", string_get_cstr(value), false, context);
+        string_printf(value, "%dK", pWirelessInfo.MemorySizeSram1);
+        out("radio_stack_sram1", string_get_cstr(value), false, context);
+        string_printf(value, "%dK", pWirelessInfo.MemorySizeFlash * 4);
+        out("radio_stack_flash", string_get_cstr(value), false, context);
+
+        // Mac address
+        string_reset(value);
+        const uint8_t* ble_mac = furi_hal_version_get_ble_mac();
+        for(size_t i = 0; i < 6; i++) {
+            string_cat_printf(value, "%02X", ble_mac[i]);
+        }
+        out("radio_ble_mac", string_get_cstr(value), false, context);
+
+        // Signature verification
+        uint8_t buffer[ENCLAVE_SIGNATURE_SIZE];
+        size_t enclave_valid_keys = 0;
+        for(size_t key_slot = 0; key_slot < ENCLAVE_SIGNATURE_KEY_SLOTS; key_slot++) {
+            if(furi_hal_crypto_store_load_key(key_slot + 1, enclave_signature_iv[key_slot])) {
+                if(furi_hal_crypto_encrypt(
+                       enclave_signature_input[key_slot], buffer, ENCLAVE_SIGNATURE_SIZE)) {
+                    enclave_valid_keys += memcmp(
+                                              buffer,
+                                              enclave_signature_expected[key_slot],
+                                              ENCLAVE_SIGNATURE_SIZE) == 0;
+                }
+                furi_hal_crypto_store_unload_key(key_slot + 1);
+            }
+        }
+        string_printf(value, "%d", enclave_valid_keys);
+        out("enclave_valid_keys", string_get_cstr(value), false, context);
+        out("enclave_valid", (enclave_valid_keys == ENCLAVE_SIGNATURE_KEY_SLOTS) ? "true" : "false", true, context);
+    } else {
+        out("radio_alive", "false", true, context);
+    }
+
+    string_clear(value);
+}

firmware/targets/f7/furi-hal/furi-hal-info.c

@@ -0,0 +1,189 @@
+#include <furi-hal-info.h>
+#include <furi-hal.h>
+#include <shci.h>
+
+#define ENCLAVE_SIGNATURE_KEY_SLOTS 10
+#define ENCLAVE_SIGNATURE_SIZE 16
+
+static const uint8_t enclave_signature_iv[ENCLAVE_SIGNATURE_KEY_SLOTS][16] = {
+    {0xac, 0x5d, 0x68, 0xb8, 0x79, 0x74, 0xfc, 0x7f, 0x45, 0x02, 0x82, 0xf1, 0x48, 0x7e, 0x75, 0x8a},
+    {0x38, 0xe6, 0x6a, 0x90, 0x5e, 0x5b, 0x8a, 0xa6, 0x70, 0x30, 0x04, 0x72, 0xc2, 0x42, 0xea, 0xaf},
+    {0x73, 0xd5, 0x8e, 0xfb, 0x0f, 0x4b, 0xa9, 0x79, 0x0f, 0xde, 0x0e, 0x53, 0x44, 0x7d, 0xaa, 0xfd},
+    {0x3c, 0x9a, 0xf4, 0x43, 0x2b, 0xfe, 0xea, 0xae, 0x8c, 0xc6, 0xd1, 0x60, 0xd2, 0x96, 0x64, 0xa9},
+    {0x10, 0xac, 0x7b, 0x63, 0x03, 0x7f, 0x43, 0x18, 0xec, 0x9d, 0x9c, 0xc4, 0x01, 0xdc, 0x35, 0xa7},
+    {0x26, 0x21, 0x64, 0xe6, 0xd0, 0xf2, 0x47, 0x49, 0xdc, 0x36, 0xcd, 0x68, 0x0c, 0x91, 0x03, 0x44},
+    {0x7a, 0xbd, 0xce, 0x9c, 0x24, 0x7a, 0x2a, 0xb1, 0x3c, 0x4f, 0x5a, 0x7d, 0x80, 0x3e, 0xfc, 0x0d},
+    {0xcd, 0xdd, 0xd3, 0x02, 0x85, 0x65, 0x43, 0x83, 0xf9, 0xac, 0x75, 0x2f, 0x21, 0xef, 0x28, 0x6b},
+    {0xab, 0x73, 0x70, 0xe8, 0xe2, 0x56, 0x0f, 0x58, 0xab, 0x29, 0xa5, 0xb1, 0x13, 0x47, 0x5e, 0xe8},
+    {0x4f, 0x3c, 0x43, 0x77, 0xde, 0xed, 0x79, 0xa1, 0x8d, 0x4c, 0x1f, 0xfd, 0xdb, 0x96, 0x87, 0x2e},
+};
+
+static const uint8_t enclave_signature_input[ENCLAVE_SIGNATURE_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
+    {0x9f, 0x5c, 0xb1, 0x43, 0x17, 0x53, 0x18, 0x8c, 0x66, 0x3d, 0x39, 0x45, 0x90, 0x13, 0xa9, 0xde},
+    {0xc5, 0x98, 0xe9, 0x17, 0xb8, 0x97, 0x9e, 0x03, 0x33, 0x14, 0x13, 0x8f, 0xce, 0x74, 0x0d, 0x54},
+    {0x34, 0xba, 0x99, 0x59, 0x9f, 0x70, 0x67, 0xe9, 0x09, 0xee, 0x64, 0x0e, 0xb3, 0xba, 0xfb, 0x75},
+    {0xdc, 0xfa, 0x6c, 0x9a, 0x6f, 0x0a, 0x3e, 0xdc, 0x42, 0xf6, 0xae, 0x0d, 0x3c, 0xf7, 0x83, 0xaf},
+    {0xea, 0x2d, 0xe3, 0x1f, 0x02, 0x99, 0x1a, 0x7e, 0x6d, 0x93, 0x4c, 0xb5, 0x42, 0xf0, 0x7a, 0x9b},
+    {0x53, 0x5e, 0x04, 0xa2, 0x49, 0xa0, 0x73, 0x49, 0x56, 0xb0, 0x88, 0x8c, 0x12, 0xa0, 0xe4, 0x18},
+    {0x7d, 0xa7, 0xc5, 0x21, 0x7f, 0x12, 0x95, 0xdd, 0x4d, 0x77, 0x01, 0xfa, 0x71, 0x88, 0x2b, 0x7f},
+    {0xdc, 0x9b, 0xc5, 0xa7, 0x6b, 0x84, 0x5c, 0x37, 0x7c, 0xec, 0x05, 0xa1, 0x9f, 0x91, 0x17, 0x3b},
+    {0xea, 0xcf, 0xd9, 0x9b, 0x86, 0xcd, 0x2b, 0x43, 0x54, 0x45, 0x82, 0xc6, 0xfe, 0x73, 0x1a, 0x1a},
+    {0x77, 0xb8, 0x1b, 0x90, 0xb4, 0xb7, 0x32, 0x76, 0x8f, 0x8a, 0x57, 0x06, 0xc7, 0xdd, 0x08, 0x90},
+};
+
+static const uint8_t enclave_signature_expected[ENCLAVE_SIGNATURE_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
+    {0xe9, 0x9a, 0xce, 0xe9, 0x4d, 0xe1, 0x7f, 0x55, 0xcb, 0x8a, 0xbf, 0xf2, 0x4d, 0x98, 0x27, 0x67},
+    {0x34, 0x27, 0xa7, 0xea, 0xa8, 0x98, 0x66, 0x9b, 0xed, 0x43, 0xd3, 0x93, 0xb5, 0xa2, 0x87, 0x8e},
+    {0x6c, 0xf3, 0x01, 0x78, 0x53, 0x1b, 0x11, 0x32, 0xf0, 0x27, 0x2f, 0xe3, 0x7d, 0xa6, 0xe2, 0xfd},
+    {0xdf, 0x7f, 0x37, 0x65, 0x2f, 0xdb, 0x7c, 0xcf, 0x5b, 0xb6, 0xe4, 0x9c, 0x63, 0xc5, 0x0f, 0xe0},
+    {0x9b, 0x5c, 0xee, 0x44, 0x0e, 0xd1, 0xcb, 0x5f, 0x28, 0x9f, 0x12, 0x17, 0x59, 0x64, 0x40, 0xbb},
+    {0x94, 0xc2, 0x09, 0x98, 0x62, 0xa7, 0x2b, 0x93, 0xed, 0x36, 0x1f, 0x10, 0xbc, 0x26, 0xbd, 0x41},
+    {0x4d, 0xb2, 0x2b, 0xc5, 0x96, 0x47, 0x61, 0xf4, 0x16, 0xe0, 0x81, 0xc3, 0x8e, 0xb9, 0x9c, 0x9b},
+    {0xc3, 0x6b, 0x83, 0x55, 0x90, 0x38, 0x0f, 0xea, 0xd1, 0x65, 0xbf, 0x32, 0x4f, 0x8e, 0x62, 0x5b},
+    {0x8d, 0x5e, 0x27, 0xbc, 0x14, 0x4f, 0x08, 0xa8, 0x2b, 0x14, 0x89, 0x5e, 0xdf, 0x77, 0x04, 0x31},
+    {0xc9, 0xf7, 0x03, 0xf1, 0x6c, 0x65, 0xad, 0x49, 0x74, 0xbe, 0x00, 0x54, 0xfd, 0xa6, 0x9c, 0x32},
+};
+
+void furi_hal_info_get(FuriHalInfoValueCallback out, void* context) {
+    string_t value;
+    string_init(value);
+
+    // Device Info version
+    out("device_info_major", "2", false, context);
+    out("device_info_minor", "0", false, context);
+
+    // Model name
+    out("hardware_model", furi_hal_version_get_model_name(), false, context);
+
+    // Unique ID
+    string_reset(value);
+    const uint8_t* uid = furi_hal_version_uid();
+    for(size_t i = 0; i < furi_hal_version_uid_size(); i++) {
+        string_cat_printf(value, "%02X", uid[i]);
+    }
+    out("hardware_uid", string_get_cstr(value), false, context);
+
+    // OTP Revision
+    string_printf(value, "%d", furi_hal_version_get_otp_version());
+    out("hardware_otp_ver", string_get_cstr(value), false, context);
+    string_printf(value, "%lu", furi_hal_version_get_hw_timestamp());
+    out("hardware_timestamp", string_get_cstr(value), false, context);
+
+    // Board Revision
+    string_printf(value, "%d", furi_hal_version_get_hw_version());
+    out("hardware_ver", string_get_cstr(value), false, context);
+    string_printf(value, "%d", furi_hal_version_get_hw_target());
+    out("hardware_target", string_get_cstr(value), false, context);
+    string_printf(value, "%d", furi_hal_version_get_hw_body());
+    out("hardware_body", string_get_cstr(value), false, context);
+    string_printf(value, "%d", furi_hal_version_get_hw_connect());
+    out("hardware_connect", string_get_cstr(value), false, context);
+    string_printf(value, "%d", furi_hal_version_get_hw_display());
+    out("hardware_display", string_get_cstr(value), false, context);
+
+    // Board Personification
+    string_printf(value, "%d", furi_hal_version_get_hw_color());
+    out("hardware_color", string_get_cstr(value), false, context);
+    string_printf(value, "%d", furi_hal_version_get_hw_region());
+    out("hardware_region", string_get_cstr(value), false, context);
+    const char* name = furi_hal_version_get_name_ptr();
+    if(name) {
+        out("hardware_name", name, false, context);
+    }
+
+    // Bootloader Version
+    const Version* bootloader_version = furi_hal_version_get_bootloader_version();
+    if(bootloader_version) {
+        out("bootloader_commit", version_get_githash(bootloader_version), false, context);
+        out("bootloader_branch", version_get_gitbranch(bootloader_version), false, context);
+        out("bootloader_branch_num", version_get_gitbranchnum(bootloader_version), false, context);
+        out("bootloader_version", version_get_version(bootloader_version), false, context);
+        out("bootloader_build_date", version_get_builddate(bootloader_version), false, context);
+        string_printf(value, "%d", version_get_target(bootloader_version));
+        out("bootloader_target", string_get_cstr(value), false, context);
+    }
+
+    // Firmware version
+    const Version* firmware_version = furi_hal_version_get_firmware_version();
+    if(firmware_version) {
+        out("firmware_commit", version_get_githash(firmware_version), false, context);
+        out("firmware_branch", version_get_gitbranch(firmware_version), false, context);
+        out("firmware_branch_num", version_get_gitbranchnum(firmware_version), false, context);
+        out("firmware_version", version_get_version(firmware_version), false, context);
+        out("firmware_build_date", version_get_builddate(firmware_version), false, context);
+        string_printf(value, "%d", version_get_target(firmware_version));
+        out("firmware_target", string_get_cstr(value), false, context);
+    }
+
+    WirelessFwInfo_t pWirelessInfo;
+    if(furi_hal_bt_is_alive() && SHCI_GetWirelessFwInfo(&pWirelessInfo) == SHCI_Success) {
+        out("radio_alive", "true", false, context);
+
+        // FUS Info
+        string_printf(value, "%d", pWirelessInfo.FusVersionMajor);
+        out("radio_fus_major", string_get_cstr(value), false, context);
+        string_printf(value, "%d", pWirelessInfo.FusVersionMinor);
+        out("radio_fus_minor", string_get_cstr(value), false, context);
+        string_printf(value, "%d", pWirelessInfo.FusVersionSub);
+        out("radio_fus_sub", string_get_cstr(value), false, context);
+        string_printf(value, "%dK", pWirelessInfo.FusMemorySizeSram2B);
+        out("radio_fus_sram2b", string_get_cstr(value), false, context);
+        string_printf(value, "%dK", pWirelessInfo.FusMemorySizeSram2A);
+        out("radio_fus_sram2a", string_get_cstr(value), false, context);
+        string_printf(value, "%dK", pWirelessInfo.FusMemorySizeFlash * 4);
+        out("radio_fus_flash", string_get_cstr(value), false, context);
+
+        // Stack Info
+        string_printf(value, "%d", pWirelessInfo.StackType);
+        out("radio_stack_type", string_get_cstr(value), false, context);
+        string_printf(value, "%d", pWirelessInfo.VersionMajor);
+        out("radio_stack_major", string_get_cstr(value), false, context);
+        string_printf(value, "%d", pWirelessInfo.VersionMinor);
+        out("radio_stack_minor", string_get_cstr(value), false, context);
+        string_printf(value, "%d", pWirelessInfo.VersionSub);
+        out("radio_stack_sub", string_get_cstr(value), false, context);
+        string_printf(value, "%d", pWirelessInfo.VersionBranch);
+        out("radio_stack_branch", string_get_cstr(value), false, context);
+        string_printf(value, "%d", pWirelessInfo.VersionReleaseType);
+        out("radio_stack_release", string_get_cstr(value), false, context);
+        string_printf(value, "%dK", pWirelessInfo.MemorySizeSram2B);
+        out("radio_stack_sram2b", string_get_cstr(value), false, context);
+        string_printf(value, "%dK", pWirelessInfo.MemorySizeSram2A);
+        out("radio_stack_sram2a", string_get_cstr(value), false, context);
+        string_printf(value, "%dK", pWirelessInfo.MemorySizeSram1);
+        out("radio_stack_sram1", string_get_cstr(value), false, context);
+        string_printf(value, "%dK", pWirelessInfo.MemorySizeFlash * 4);
+        out("radio_stack_flash", string_get_cstr(value), false, context);
+
+        // Mac address
+        string_reset(value);
+        const uint8_t* ble_mac = furi_hal_version_get_ble_mac();
+        for(size_t i = 0; i < 6; i++) {
+            string_cat_printf(value, "%02X", ble_mac[i]);
+        }
+        out("radio_ble_mac", string_get_cstr(value), false, context);
+
+        // Signature verification
+        uint8_t buffer[ENCLAVE_SIGNATURE_SIZE];
+        size_t enclave_valid_keys = 0;
+        for(size_t key_slot = 0; key_slot < ENCLAVE_SIGNATURE_KEY_SLOTS; key_slot++) {
+            if(furi_hal_crypto_store_load_key(key_slot + 1, enclave_signature_iv[key_slot])) {
+                if(furi_hal_crypto_encrypt(
+                       enclave_signature_input[key_slot], buffer, ENCLAVE_SIGNATURE_SIZE)) {
+                    enclave_valid_keys += memcmp(
+                                              buffer,
+                                              enclave_signature_expected[key_slot],
+                                              ENCLAVE_SIGNATURE_SIZE) == 0;
+                }
+                furi_hal_crypto_store_unload_key(key_slot + 1);
+            }
+        }
+        string_printf(value, "%d", enclave_valid_keys);
+        out("enclave_valid_keys", string_get_cstr(value), false, context);
+        out("enclave_valid", (enclave_valid_keys == ENCLAVE_SIGNATURE_KEY_SLOTS) ? "true" : "false", true, context);
+    } else {
+        out("radio_alive", "false", true, context);
+    }
+
+    string_clear(value);
+}

firmware/targets/furi-hal-include/furi-hal-info.h

@@ -0,0 +1,33 @@
+/**
+ * @file furi-hal-info.h
+ * Device info HAL API
+ */
+
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Callback type called every time another key-value pair of device information is ready
+ *
+ * @param      key[in]      device information type identifier
+ * @param      value[in]    device information value
+ * @param      last[in]     whether the passed key-value pair is the last one
+ * @param      context[in]  to pass to callback
+ */
+typedef void (*FuriHalInfoValueCallback) (const char* key, const char* value, bool last, void* context);
+
+/** Get device information
+ *
+ * @param[in]  callback     callback to provide with new data
+ * @param[in]  context      context to pass to callback
+ */
+void furi_hal_info_get(FuriHalInfoValueCallback callback, void* context);
+
+#ifdef __cplusplus
+}
+#endif

firmware/targets/furi-hal-include/furi-hal.h

@@ -38,6 +38,7 @@ template <unsigned int N> struct STOP_EXTERNING_ME {};
 #include "furi-hal-usb-hid.h"
 #include "furi-hal-compress.h"
 #include "furi-hal-uart.h"
+#include "furi-hal-info.h"
 
 /** Init furi-hal */
 void furi_hal_init();

make/toolchain.mk

@@ -27,4 +27,4 @@ endif
 
 CFLAGS		+= -fdata-sections -ffunction-sections -fno-math-errno -fstack-usage -MMD -MP -MF"$(@:%.o=%.d)"
 CPPFLAGS	+= -fno-threadsafe-statics -fno-use-cxa-atexit -fno-exceptions -fno-rtti
-LDFLAGS		+= -Wl,-Map=$(OBJ_DIR)/$(PROJECT).map,--cref -Wl,--gc-sections -Wl,--undefined=uxTopUsedPriority -u _printf_float
+LDFLAGS		+= -Wl,-Map=$(OBJ_DIR)/$(PROJECT).map,--cref -Wl,--gc-sections -Wl,--undefined=uxTopUsedPriority -u _printf_float -n