Update subghz_scene_kl_bf_cleanup.c

applications/main/subghz/scenes/subghz_scene_config.h

@@ -32,4 +32,5 @@ ADD_SCENE(subghz, keeloq_key_edit, KeeloqKeyEdit)
 ADD_SCENE(subghz, psa_decrypt, PsaDecrypt)
 ADD_SCENE(subghz, keeloq_decrypt, KeeloqDecrypt)
 ADD_SCENE(subghz, keeloq_bf2, KeeloqBf2)
+ADD_SCENE(subghz, kl_bf_cleanup, KlBfCleanup)
 ADD_SCENE(subghz, counter_bf, CounterBf)

applications/main/subghz/scenes/subghz_scene_counter_bf.c

@@ -65,11 +65,11 @@ static void counter_bf_draw(SubGhz* subghz, CounterBfContext* ctx) {
     furi_string_printf(
         str,
         "Counter BruteForce\n"
-        "Cnt: 0x%08lX\n"
-        "Start: 0x%08lX\n"
+        "Cnt: 0x%06lX\n"
+        "Start: 0x%06lX\n"
         "Sent: %lu",
-        ctx->current_cnt,
-        ctx->start_cnt,
+        ctx->current_cnt & 0xFFFFFF,
+        ctx->start_cnt & 0xFFFFFF,
         ctx->packets_sent);
     widget_add_string_multiline_element(
         subghz->widget, 0, 0, AlignLeft, AlignTop, FontSecondary, furi_string_get_cstr(str));
@@ -88,7 +88,8 @@ static void counter_bf_save(SubGhz* subghz, CounterBfContext* ctx) {
     FlipperFormat* file_fff = flipper_format_buffered_file_alloc(storage);
     if(flipper_format_buffered_file_open_existing(
            file_fff, furi_string_get_cstr(subghz->file_path))) {
-        if(!flipper_format_update_uint32(file_fff, "Cnt", &ctx->current_cnt, 1)) {
+        uint32_t cnt = ctx->current_cnt & 0xFFFFFF;
+        if(!flipper_format_update_uint32(file_fff, "Cnt", &cnt, 1)) {
             FURI_LOG_E(TAG, "Failed to update Cnt in .sub file");
         }
     } else {
@@ -101,15 +102,15 @@ static void counter_bf_save(SubGhz* subghz, CounterBfContext* ctx) {
 static void counter_bf_send(SubGhz* subghz, CounterBfContext* ctx) {
     subghz_txrx_stop(subghz->txrx);
 
-    FlipperFormat* fff = subghz_txrx_get_fff_data(subghz->txrx);
+    uint32_t delta = (ctx->current_cnt - ctx->start_cnt) & 0xFFFFFF;
+    furi_hal_subghz_set_rolling_counter_mult((int32_t)delta);
+    subghz_block_generic_global_counter_override_set(ctx->current_cnt & 0xFFFFFF);
 
+    FlipperFormat* fff = subghz_txrx_get_fff_data(subghz->txrx);
     uint32_t repeat = 20;
     flipper_format_rewind(fff);
     flipper_format_update_uint32(fff, "Repeat", &repeat, 1);
 
-    flipper_format_rewind(fff);
-    flipper_format_update_uint32(fff, "Cnt", &ctx->current_cnt, 1);
-
     subghz_tx_start(subghz, fff);
 
     ctx->packets_sent++;
@@ -123,33 +124,35 @@ void subghz_scene_counter_bf_on_enter(void* context) {
     memset(ctx, 0, sizeof(CounterBfContext));
     ctx->state = CounterBfStateWarning;
     ctx->step = 1;
+    furi_hal_subghz_set_rolling_counter_mult(0);
+    subghz_key_load(subghz, furi_string_get_cstr(subghz->file_path), false);
 
     {
-        Storage* storage = furi_record_open(RECORD_STORAGE);
-        FlipperFormat* file_fff = flipper_format_buffered_file_alloc(storage);
-        if(flipper_format_buffered_file_open_existing(
-               file_fff, furi_string_get_cstr(subghz->file_path))) {
-            uint32_t cnt = 0;
-            if(flipper_format_read_uint32(file_fff, "Cnt", &cnt, 1)) {
-                ctx->current_cnt = cnt;
-                ctx->start_cnt = cnt;
-            } else {
-                FURI_LOG_W(TAG, "Cnt field not found in file");
-            }
+        FlipperFormat* fff = subghz_txrx_get_fff_data(subghz->txrx);
+        flipper_format_rewind(fff);
+        uint32_t cnt = 0;
+        if(flipper_format_read_uint32(fff, "Cnt", &cnt, 1)) {
+            ctx->current_cnt = cnt & 0xFFFFFF;
+            ctx->start_cnt   = cnt & 0xFFFFFF;
         } else {
-            FURI_LOG_E(TAG, "Failed to open .sub file for Cnt read");
+            FURI_LOG_W(TAG, "Cnt not in fff after key_load, reading from disk");
+            Storage* storage = furi_record_open(RECORD_STORAGE);
+            FlipperFormat* file_fff = flipper_format_buffered_file_alloc(storage);
+            if(flipper_format_buffered_file_open_existing(
+                   file_fff, furi_string_get_cstr(subghz->file_path))) {
+                if(flipper_format_read_uint32(file_fff, "Cnt", &cnt, 1)) {
+                    ctx->current_cnt = cnt & 0xFFFFFF;
+                    ctx->start_cnt   = cnt & 0xFFFFFF;
+                }
+            }
+            flipper_format_free(file_fff);
+            furi_record_close(RECORD_STORAGE);
         }
-        flipper_format_free(file_fff);
-        furi_record_close(RECORD_STORAGE);
     }
 
     scene_manager_set_scene_state(
         subghz->scene_manager, SubGhzSceneCounterBf, (uint32_t)(uintptr_t)ctx);
 
-    furi_hal_subghz_set_rolling_counter_mult(0);
-
-    subghz_key_load(subghz, furi_string_get_cstr(subghz->file_path), false);
-
     counter_bf_draw_warning(subghz);
     view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdWidget);
 }
@@ -190,8 +193,9 @@ bool subghz_scene_counter_bf_on_event(void* context, SceneManagerEvent event) {
             if(ctx->tick_wait > 0) {
                 ctx->tick_wait--;
             } else {
-                ctx->current_cnt += ctx->step;
+                ctx->current_cnt = (ctx->current_cnt + ctx->step) & 0xFFFFFF;
                 counter_bf_send(subghz, ctx);
+                counter_bf_save(subghz, ctx);
                 counter_bf_draw(subghz, ctx);
             }
         }

applications/main/subghz/scenes/subghz_scene_keeloq_bf2.c

@@ -5,9 +5,18 @@
 enum {
     KlBf2IndexLoadSig1,
     KlBf2IndexLoadSig2,
+    KlBf2IndexType,
     KlBf2IndexStartBf,
 };
 
+static const char* kl_bf2_type_labels[] = {
+    "Type: Auto (6>7>8)",
+    "Type: 6 (Serial 1)",
+    "Type: 7 (Serial 2)",
+    "Type: 8 (Serial 3)",
+};
+static const uint8_t kl_bf2_type_values[] = {0, 6, 7, 8};
+
 static bool kl_bf2_extract_key(SubGhz* subghz, uint32_t* out_fix, uint32_t* out_hop) {
     FlipperFormat* fff = subghz_txrx_get_fff_data(subghz->txrx);
     flipper_format_rewind(fff);
@@ -88,6 +97,17 @@ static void kl_bf2_rebuild_menu(SubGhz* subghz) {
         subghz->submenu, label2, KlBf2IndexLoadSig2,
         kl_bf2_submenu_callback, subghz);
 
+    int type_idx = 0;
+    for(int i = 0; i < 4; i++) {
+        if(kl_bf2_type_values[i] == subghz->keeloq_bf2.learn_type) {
+            type_idx = i;
+            break;
+        }
+    }
+    submenu_add_item(
+        subghz->submenu, kl_bf2_type_labels[type_idx], KlBf2IndexType,
+        kl_bf2_submenu_callback, subghz);
+
     if(subghz->keeloq_bf2.sig1_loaded && subghz->keeloq_bf2.sig2_loaded) {
         submenu_add_item(
             subghz->submenu, "Start BF", KlBf2IndexStartBf,
@@ -102,6 +122,7 @@ void subghz_scene_keeloq_bf2_on_enter(void* context) {
 
     subghz->keeloq_bf2.sig1_loaded = false;
     subghz->keeloq_bf2.sig2_loaded = false;
+    subghz->keeloq_bf2.learn_type = 0;
 
     kl_bf2_rebuild_menu(subghz);
 }
@@ -194,6 +215,16 @@ bool subghz_scene_keeloq_bf2_on_event(void* context, SceneManagerEvent event) {
             kl_bf2_rebuild_menu(subghz);
             return true;
 
+        } else if(event.event == KlBf2IndexType) {
+            uint8_t cur = subghz->keeloq_bf2.learn_type;
+            if(cur == 0) cur = 6;
+            else if(cur == 6) cur = 7;
+            else if(cur == 7) cur = 8;
+            else cur = 0;
+            subghz->keeloq_bf2.learn_type = cur;
+            kl_bf2_rebuild_menu(subghz);
+            return true;
+
         } else if(event.event == KlBf2IndexStartBf) {
             if(!subghz->keeloq_bf2.sig1_loaded || !subghz->keeloq_bf2.sig2_loaded) {
                 return true;

applications/main/subghz/scenes/subghz_scene_keeloq_decrypt.c

@@ -27,8 +27,10 @@ typedef struct {
 
     uint32_t hop2;
 
+    uint32_t candidate_count;
     uint64_t recovered_mfkey;
     uint16_t recovered_type;
+    uint32_t recovered_cnt;
 
     bool ble_offload;
 } KlDecryptCtx;
@@ -61,37 +63,59 @@ static void kl_ble_data_received(uint8_t* data, uint16_t size, void* context) {
         memcpy(&cnt, data + 18, 4);
         memcpy(&elapsed_ms, data + 22, 4);
 
-        if(found) {
+        if(found == 1) {
             uint16_t learn_type = (size >= 27) ? data[26] : 6;
 
-            furi_string_printf(
-                ctx->result,
-                "Key FOUND!\n"
-                "MfKey:%08lX%08lX\n"
-                "DevKey:%08lX%08lX\n"
-                "Cnt:%04lX Sn:%07lX\n"
-                "Saved to user keys",
-                (uint32_t)(mfkey >> 32), (uint32_t)(mfkey & 0xFFFFFFFF),
-                (uint32_t)(devkey >> 32), (uint32_t)(devkey & 0xFFFFFFFF),
-                cnt, ctx->serial);
-
-            FlipperFormat* fff = subghz_txrx_get_fff_data(ctx->subghz->txrx);
-            flipper_format_rewind(fff);
-
-            char mf_str[20];
-            snprintf(mf_str, sizeof(mf_str), "BF_%07lX", ctx->serial);
-            flipper_format_insert_or_update_string_cstr(fff, "Manufacture", mf_str);
-
-            uint32_t cnt_val = cnt;
-            flipper_format_rewind(fff);
-            flipper_format_insert_or_update_uint32(fff, "Cnt", &cnt_val, 1);
-
+            ctx->candidate_count++;
             ctx->recovered_mfkey = mfkey;
             ctx->recovered_type = learn_type;
-            ctx->success = true;
-        }
+            ctx->recovered_cnt = cnt;
 
-        view_dispatcher_send_custom_event(ctx->subghz->view_dispatcher, KL_DECRYPT_EVENT_DONE);
+            subghz_view_keeloq_decrypt_update_candidates(
+                ctx->subghz->subghz_keeloq_decrypt, ctx->candidate_count);
+
+            if(!ctx->subghz->keeloq_keys_manager) {
+                ctx->subghz->keeloq_keys_manager = subghz_keeloq_keys_alloc();
+            }
+            char key_name[32];
+            snprintf(key_name, sizeof(key_name), "BF_%07lX_%lu", ctx->serial, ctx->candidate_count);
+            subghz_keeloq_keys_add(
+                ctx->subghz->keeloq_keys_manager,
+                mfkey,
+                learn_type,
+                key_name);
+            subghz_keeloq_keys_save(ctx->subghz->keeloq_keys_manager);
+
+        } else if(found == 2) {
+            ctx->success = (ctx->candidate_count > 0);
+
+            if(ctx->candidate_count > 0) {
+                furi_string_printf(
+                    ctx->result,
+                    "Found %lu candidate(s)\n"
+                    "Last: %08lX%08lX\n"
+                    "Type:%u Cnt:%04lX\n"
+                    "Saved to user keys",
+                    ctx->candidate_count,
+                    (uint32_t)(ctx->recovered_mfkey >> 32),
+                    (uint32_t)(ctx->recovered_mfkey & 0xFFFFFFFF),
+                    ctx->recovered_type,
+                    ctx->recovered_cnt);
+
+                FlipperFormat* fff = subghz_txrx_get_fff_data(ctx->subghz->txrx);
+                flipper_format_rewind(fff);
+
+                char mf_str[20];
+                snprintf(mf_str, sizeof(mf_str), "BF_%07lX", ctx->serial);
+                flipper_format_insert_or_update_string_cstr(fff, "Manufacture", mf_str);
+
+                uint32_t cnt_val = ctx->recovered_cnt;
+                flipper_format_rewind(fff);
+                flipper_format_insert_or_update_uint32(fff, "Cnt", &cnt_val, 1);
+            }
+
+            view_dispatcher_send_custom_event(ctx->subghz->view_dispatcher, KL_DECRYPT_EVENT_DONE);
+        }
     }
 }
 
@@ -114,7 +138,7 @@ static bool kl_ble_start_offload(KlDecryptCtx* ctx) {
 
     uint8_t req[18];
     req[0] = KL_MSG_BF_REQUEST;
-    req[1] = 0;
+    req[1] = ctx->subghz->keeloq_bf2.learn_type;
     memcpy(req + 2, &ctx->fix, 4);
     memcpy(req + 6, &ctx->hop, 4);
     memcpy(req + 10, &ctx->hop2, 4);
@@ -200,18 +224,6 @@ bool subghz_scene_keeloq_decrypt_on_event(void* context, SceneManagerEvent event
                     subghz_txrx_get_fff_data(subghz->txrx),
                     furi_string_get_cstr(subghz->file_path));
 
-                if(!subghz->keeloq_keys_manager) {
-                    subghz->keeloq_keys_manager = subghz_keeloq_keys_alloc();
-                }
-                char key_name[24];
-                snprintf(key_name, sizeof(key_name), "BF_%07lX", ctx->serial);
-                subghz_keeloq_keys_add(
-                    subghz->keeloq_keys_manager,
-                    ctx->recovered_mfkey,
-                    ctx->recovered_type,
-                    key_name);
-                subghz_keeloq_keys_save(subghz->keeloq_keys_manager);
-
                 subghz_view_keeloq_decrypt_set_result(
                     subghz->subghz_keeloq_decrypt, true, furi_string_get_cstr(ctx->result));
             } else if(!ctx->cancel) {

applications/main/subghz/scenes/subghz_scene_kl_bf_cleanup.c

@@ -0,0 +1,139 @@
+#include "../subghz_i.h"
+#include <lib/subghz/protocols/keeloq_common.h>
+
+typedef struct {
+    uint32_t serial;
+    uint32_t hop;
+    uint8_t btn;
+    uint16_t disc;
+    size_t bf_indices[32];
+    size_t bf_count;
+    size_t valid_indices[32];
+    size_t valid_count;
+} KlCleanupCtx;
+
+static bool kl_cleanup_validate_key(uint64_t key, uint32_t hop, uint8_t btn, uint16_t disc) {
+    uint32_t dec = subghz_protocol_keeloq_common_decrypt(hop, key);
+    if((dec >> 28) != btn) return false;
+    uint16_t dec_disc = (dec >> 16) & 0x3FF;
+    if(dec_disc == disc) return true;
+    if((dec_disc & 0xFF) == (disc & 0xFF)) return true;
+    return false;
+}
+
+void subghz_scene_kl_bf_cleanup_on_enter(void* context) {
+    SubGhz* subghz = context;
+
+    KlCleanupCtx* ctx = malloc(sizeof(KlCleanupCtx));
+    memset(ctx, 0, sizeof(KlCleanupCtx));
+
+    FlipperFormat* fff = subghz_txrx_get_fff_data(subghz->txrx);
+    flipper_format_rewind(fff);
+
+    uint8_t key_data[8] = {0};
+    if(flipper_format_read_hex(fff, "Key", key_data, 8)) {
+        uint32_t fix = ((uint32_t)key_data[0] << 24) | ((uint32_t)key_data[1] << 16) |
+                       ((uint32_t)key_data[2] << 8) | key_data[3];
+        ctx->hop = ((uint32_t)key_data[4] << 24) | ((uint32_t)key_data[5] << 16) |
+                   ((uint32_t)key_data[6] << 8) | key_data[7];
+        ctx->serial = fix & 0x0FFFFFFF;
+        ctx->btn = fix >> 28;
+        ctx->disc = ctx->serial & 0x3FF;
+    }
+
+    scene_manager_set_scene_state(
+        subghz->scene_manager, SubGhzSceneKlBfCleanup, (uint32_t)(uintptr_t)ctx);
+
+    if(!subghz->keeloq_keys_manager) {
+        subghz->keeloq_keys_manager = subghz_keeloq_keys_alloc();
+    }
+
+    char prefix[16];
+    snprintf(prefix, sizeof(prefix), "BF_%07lX_", ctx->serial);
+    size_t prefix_len = strlen(prefix);
+
+    size_t user_count = subghz_keeloq_keys_user_count(subghz->keeloq_keys_manager);
+    ctx->bf_count = 0;
+    ctx->valid_count = 0;
+
+    for(size_t i = 0; i < user_count && ctx->bf_count < 32; i++) {
+        SubGhzKey* k = subghz_keeloq_keys_get(subghz->keeloq_keys_manager, i);
+        if(!k || !k->name) continue;
+        const char* name = furi_string_get_cstr(k->name);
+        if(strncmp(name, prefix, prefix_len) == 0) {
+            ctx->bf_indices[ctx->bf_count] = i;
+            if(kl_cleanup_validate_key(k->key, ctx->hop, ctx->btn, ctx->disc)) {
+                ctx->valid_indices[ctx->valid_count++] = i;
+            }
+            ctx->bf_count++;
+        }
+    }
+
+    FuriString* msg = furi_string_alloc();
+
+    if(ctx->bf_count == 0) {
+        furi_string_set_str(msg, "No BF candidate keys\nfound for this serial.");
+    } else if(ctx->bf_count == 1) {
+        furi_string_set_str(msg, "Only 1 BF key exists.\nNothing to clean up.");
+    } else if(ctx->valid_count == 1) {
+        size_t deleted = 0;
+        for(int i = (int)ctx->bf_count - 1; i >= 0; i--) {
+            if(ctx->bf_indices[i] != ctx->valid_indices[0]) {
+                subghz_keeloq_keys_delete(subghz->keeloq_keys_manager, ctx->bf_indices[i]);
+                deleted++;
+            }
+        }
+
+        char new_name[24];
+        snprintf(new_name, sizeof(new_name), "BF_%07lX", ctx->serial);
+
+        size_t new_user_count = subghz_keeloq_keys_user_count(subghz->keeloq_keys_manager);
+        for(size_t i = 0; i < new_user_count; i++) {
+            SubGhzKey* k = subghz_keeloq_keys_get(subghz->keeloq_keys_manager, i);
+            if(!k || !k->name) continue;
+            const char* n = furi_string_get_cstr(k->name);
+            if(strncmp(n, prefix, prefix_len) == 0) {
+                subghz_keeloq_keys_set(
+                    subghz->keeloq_keys_manager, i, k->key, k->type, new_name);
+                break;
+            }
+        }
+        subghz_keeloq_keys_save(subghz->keeloq_keys_manager);
+
+        furi_string_printf(msg,
+            "Cleaned %u keys.\nKept valid key:\n%s",
+            deleted, new_name);
+    } else if(ctx->valid_count == 0) {
+        furi_string_printf(msg,
+            "%u BF keys found\nbut none validates\nhop. Kept all.",
+            ctx->bf_count);
+    } else {
+        furi_string_printf(msg,
+            "%u BF keys, %u valid.\nCannot auto-select.\nKept all.",
+            ctx->bf_count, ctx->valid_count);
+    }
+
+    widget_add_text_scroll_element(subghz->widget, 0, 0, 128, 64, furi_string_get_cstr(msg));
+    furi_string_free(msg);
+
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdWidget);
+}
+
+bool subghz_scene_kl_bf_cleanup_on_event(void* context, SceneManagerEvent event) {
+    UNUSED(context);
+    UNUSED(event);
+    return false;
+}
+
+void subghz_scene_kl_bf_cleanup_on_exit(void* context) {
+    SubGhz* subghz = context;
+
+    KlCleanupCtx* ctx = (KlCleanupCtx*)(uintptr_t)scene_manager_get_scene_state(
+        subghz->scene_manager, SubGhzSceneKlBfCleanup);
+    if(ctx) {
+        free(ctx);
+        scene_manager_set_scene_state(subghz->scene_manager, SubGhzSceneKlBfCleanup, 0);
+    }
+
+    widget_reset(subghz->widget);
+}

applications/main/subghz/scenes/subghz_scene_saved_menu.c

@@ -6,7 +6,8 @@ enum SubmenuIndex {
     SubmenuIndexDelete,
     SubmenuIndexSignalSettings,
     SubmenuIndexPsaDecrypt,
-    SubmenuIndexCounterBf
+    SubmenuIndexCounterBf,
+    SubmenuIndexKlBfCleanup,
 };
 
 void subghz_scene_saved_menu_submenu_callback(void* context, uint32_t index) {
@@ -45,6 +46,18 @@ void subghz_scene_saved_menu_on_enter(void* context) {
         }
     }
 
+    bool has_bf_keys = false;
+    if(fff) {
+        FuriString* mfg = furi_string_alloc();
+        flipper_format_rewind(fff);
+        if(flipper_format_read_string(fff, "Manufacture", mfg)) {
+            if(furi_string_start_with_str(mfg, "BF_")) {
+                has_bf_keys = true;
+            }
+        }
+        furi_string_free(mfg);
+    }
+
     submenu_add_item(
         subghz->submenu,
         "Emulate",
@@ -90,6 +103,14 @@ void subghz_scene_saved_menu_on_enter(void* context) {
             subghz_scene_saved_menu_submenu_callback,
             subghz);
     }
+    if(has_bf_keys) {
+        submenu_add_item(
+            subghz->submenu,
+            "Clean BF Keys",
+            SubmenuIndexKlBfCleanup,
+            subghz_scene_saved_menu_submenu_callback,
+            subghz);
+    }
 
     submenu_set_selected_item(
         subghz->submenu,
@@ -132,6 +153,11 @@ bool subghz_scene_saved_menu_on_event(void* context, SceneManagerEvent event) {
                 subghz->scene_manager, SubGhzSceneSavedMenu, SubmenuIndexCounterBf);
             scene_manager_next_scene(subghz->scene_manager, SubGhzSceneCounterBf);
             return true;
+        } else if(event.event == SubmenuIndexKlBfCleanup) {
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzSceneSavedMenu, SubmenuIndexKlBfCleanup);
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneKlBfCleanup);
+            return true;
         }
     }
     return false;

applications/main/subghz/subghz_i.h

@@ -121,6 +121,7 @@ struct SubGhz {
         bool sig2_loaded;
         FuriString* sig1_path;
         FuriString* sig2_path;
+        uint8_t learn_type;
     } keeloq_bf2;
 };
 

applications/main/subghz/views/subghz_keeloq_decrypt.c

@@ -19,6 +19,7 @@ typedef struct {
     uint32_t eta_sec;
     bool done;
     bool success;
+    uint32_t candidates;
     FuriString* result_str;
     char status_line[40];
 } SubGhzKeeloqDecryptModel;
@@ -72,15 +73,21 @@ static void subghz_view_keeloq_decrypt_draw(Canvas* canvas, void* _model) {
         }
         canvas_draw_str(canvas, 2, 48, speed_str);
 
-        char elapsed_str[24];
-        uint32_t el_m = model->elapsed_sec / 60;
-        uint32_t el_s = model->elapsed_sec % 60;
-        if(el_m > 0) {
-            snprintf(elapsed_str, sizeof(elapsed_str), "Elapsed: %lum %lus", el_m, el_s);
+        if(model->candidates > 0) {
+            char cand_str[32];
+            snprintf(cand_str, sizeof(cand_str), "Candidates: %lu", model->candidates);
+            canvas_draw_str(canvas, 2, 58, cand_str);
         } else {
-            snprintf(elapsed_str, sizeof(elapsed_str), "Elapsed: %lus", el_s);
+            char elapsed_str[24];
+            uint32_t el_m = model->elapsed_sec / 60;
+            uint32_t el_s = model->elapsed_sec % 60;
+            if(el_m > 0) {
+                snprintf(elapsed_str, sizeof(elapsed_str), "Elapsed: %lum %lus", el_m, el_s);
+            } else {
+                snprintf(elapsed_str, sizeof(elapsed_str), "Elapsed: %lus", el_s);
+            }
+            canvas_draw_str(canvas, 2, 58, elapsed_str);
         }
-        canvas_draw_str(canvas, 2, 58, elapsed_str);
 
         canvas_draw_str_aligned(canvas, 126, 64, AlignRight, AlignBottom, "Hold BACK");
     } else {
@@ -124,6 +131,7 @@ SubGhzViewKeeloqDecrypt* subghz_view_keeloq_decrypt_alloc(void) {
             model->eta_sec = 0;
             model->done = false;
             model->success = false;
+            model->candidates = 0;
         },
         false);
 
@@ -205,6 +213,7 @@ void subghz_view_keeloq_decrypt_reset(SubGhzViewKeeloqDecrypt* instance) {
             model->eta_sec = 0;
             model->done = false;
             model->success = false;
+            model->candidates = 0;
             furi_string_reset(model->result_str);
             model->status_line[0] = '\0';
         },
@@ -225,3 +234,13 @@ void subghz_view_keeloq_decrypt_set_status(SubGhzViewKeeloqDecrypt* instance, co
         },
         true);
 }
+
+void subghz_view_keeloq_decrypt_update_candidates(
+    SubGhzViewKeeloqDecrypt* instance, uint32_t count) {
+    furi_check(instance);
+    with_view_model(
+        instance->view,
+        SubGhzKeeloqDecryptModel * model,
+        { model->candidates = count; },
+        true);
+}

applications/main/subghz/views/subghz_keeloq_decrypt.h

@@ -32,3 +32,6 @@ void subghz_view_keeloq_decrypt_set_result(
 void subghz_view_keeloq_decrypt_reset(SubGhzViewKeeloqDecrypt* instance);
 
 void subghz_view_keeloq_decrypt_set_status(SubGhzViewKeeloqDecrypt* instance, const char* status);
+
+void subghz_view_keeloq_decrypt_update_candidates(
+    SubGhzViewKeeloqDecrypt* instance, uint32_t count);