Implement progress bar for upgraded attacks in NFC app

applications/main/nfc/nfc_app_i.h

@@ -100,6 +100,8 @@ typedef struct {
     uint8_t nested_phase;
     uint8_t prng_type;
     uint8_t backdoor;
+    uint16_t nested_target_key;
+    uint16_t msb_count;
 } NfcMfClassicDictAttackContext;
 
 struct NfcApp {

applications/main/nfc/scenes/nfc_scene_mf_classic_dict_attack.c

@@ -5,7 +5,7 @@
 
 #define TAG "NfcMfClassicDictAttack"
 
-// TODO: Update progress bar with nested attacks
+// TODO: Fix lag when leaving the dictionary attack view during Hardnested
 
 typedef enum {
     DictAttackStateUserDictInProgress,
@@ -63,6 +63,8 @@ NfcCommand nfc_dict_attack_worker_callback(NfcGenericEvent event, void* context)
         instance->nfc_dict_context.nested_phase = data_update->nested_phase;
         instance->nfc_dict_context.prng_type = data_update->prng_type;
         instance->nfc_dict_context.backdoor = data_update->backdoor;
+        instance->nfc_dict_context.nested_target_key = data_update->nested_target_key;
+        instance->nfc_dict_context.msb_count = data_update->msb_count;
         view_dispatcher_send_custom_event(
             instance->view_dispatcher, NfcCustomEventDictAttackDataUpdate);
     } else if(mfc_event->type == MfClassicPollerEventTypeNextSector) {
@@ -125,6 +127,8 @@ static void nfc_scene_mf_classic_dict_attack_update_view(NfcApp* instance) {
         dict_attack_set_nested_phase(instance->dict_attack, mfc_dict->nested_phase);
         dict_attack_set_prng_type(instance->dict_attack, mfc_dict->prng_type);
         dict_attack_set_backdoor(instance->dict_attack, mfc_dict->backdoor);
+        dict_attack_set_nested_target_key(instance->dict_attack, mfc_dict->nested_target_key);
+        dict_attack_set_msb_count(instance->dict_attack, mfc_dict->msb_count);
     }
 }
 

applications/main/nfc/views/dict_attack.c

@@ -24,6 +24,8 @@ typedef struct {
     MfClassicNestedPhase nested_phase;
     MfClassicPrngType prng_type;
     MfClassicBackdoor backdoor;
+    uint16_t nested_target_key;
+    uint16_t msb_count;
 } DictAttackViewModel;
 
 static void dict_attack_draw_callback(Canvas* canvas, void* model) {
@@ -71,7 +73,12 @@ static void dict_attack_draw_callback(Canvas* canvas, void* model) {
 
         canvas_draw_str_aligned(
             canvas, 0, 0, AlignLeft, AlignTop, furi_string_get_cstr(m->header));
-        if(m->is_key_attack) {
+        if(m->nested_phase == MfClassicNestedPhaseCollectNtEnc) {
+            uint8_t nonce_sector =
+                m->nested_target_key / (m->prng_type == MfClassicPrngTypeWeak ? 4 : 2);
+            snprintf(draw_str, sizeof(draw_str), "Collecting from sector: %d", nonce_sector);
+            canvas_draw_str_aligned(canvas, 0, 10, AlignLeft, AlignTop, draw_str);
+        } else if(m->is_key_attack) {
             snprintf(
                 draw_str,
                 sizeof(draw_str),
@@ -81,21 +88,47 @@ static void dict_attack_draw_callback(Canvas* canvas, void* model) {
             snprintf(draw_str, sizeof(draw_str), "Unlocking sector: %d", m->current_sector);
         }
         canvas_draw_str_aligned(canvas, 0, 10, AlignLeft, AlignTop, draw_str);
-        float dict_progress = m->dict_keys_total == 0 ?
-                                  0 :
-                                  (float)(m->dict_keys_current) / (float)(m->dict_keys_total);
-        float progress = m->sectors_total == 0 ? 0 :
-                                                 ((float)(m->current_sector) + dict_progress) /
-                                                     (float)(m->sectors_total);
-        if(progress > 1.0f) {
-            progress = 1.0f;
-        }
-        if(m->dict_keys_current == 0) {
-            // Cause when people see 0 they think it's broken
-            snprintf(draw_str, sizeof(draw_str), "%d/%zu", 1, m->dict_keys_total);
+        float dict_progress = 0;
+        if(m->nested_phase == MfClassicNestedPhaseAnalyzePRNG ||
+           m->nested_phase == MfClassicNestedPhaseDictAttack ||
+           m->nested_phase == MfClassicNestedPhaseDictAttackResume) {
+            // Phase: Nested dictionary attack
+            uint8_t target_sector =
+                m->nested_target_key / (m->prng_type == MfClassicPrngTypeWeak ? 2 : 16);
+            dict_progress = (float)(target_sector) / (float)(m->sectors_total);
+            snprintf(draw_str, sizeof(draw_str), "%d/%d", target_sector, m->sectors_total);
+        } else if(
+            m->nested_phase == MfClassicNestedPhaseCalibrate ||
+            m->nested_phase == MfClassicNestedPhaseRecalibrate ||
+            m->nested_phase == MfClassicNestedPhaseCollectNtEnc) {
+            // Phase: Nonce collection
+            if(m->prng_type == MfClassicPrngTypeWeak) {
+                uint8_t target_sector = m->nested_target_key / 4;
+                dict_progress = (float)(target_sector) / (float)(m->sectors_total);
+                snprintf(draw_str, sizeof(draw_str), "%d/%d", target_sector, m->sectors_total);
+            } else {
+                uint16_t max_msb = UINT8_MAX + 1;
+                dict_progress = (float)(m->msb_count) / (float)(max_msb);
+                snprintf(draw_str, sizeof(draw_str), "%d/%d", m->msb_count, max_msb);
+            }
         } else {
-            snprintf(
-                draw_str, sizeof(draw_str), "%zu/%zu", m->dict_keys_current, m->dict_keys_total);
+            dict_progress = m->dict_keys_total == 0 ?
+                                0 :
+                                (float)(m->dict_keys_current) / (float)(m->dict_keys_total);
+            if(m->dict_keys_current == 0) {
+                // Cause when people see 0 they think it's broken
+                snprintf(draw_str, sizeof(draw_str), "%d/%zu", 1, m->dict_keys_total);
+            } else {
+                snprintf(
+                    draw_str,
+                    sizeof(draw_str),
+                    "%zu/%zu",
+                    m->dict_keys_current,
+                    m->dict_keys_total);
+            }
+        }
+        if(dict_progress > 1.0f) {
+            dict_progress = 1.0f;
         }
         elements_progress_bar_with_text(canvas, 0, 20, 128, dict_progress, draw_str);
         canvas_set_font(canvas, FontSecondary);
@@ -170,6 +203,8 @@ void dict_attack_reset(DictAttack* instance) {
             model->nested_phase = MfClassicNestedPhaseNone;
             model->prng_type = MfClassicPrngTypeUnknown;
             model->backdoor = MfClassicBackdoorUnknown;
+            model->nested_target_key = 0;
+            model->msb_count = 0;
             furi_string_reset(model->header);
         },
         false);
@@ -301,3 +336,20 @@ void dict_attack_set_backdoor(DictAttack* instance, uint8_t backdoor) {
     with_view_model(
         instance->view, DictAttackViewModel * model, { model->backdoor = backdoor; }, true);
 }
+
+void dict_attack_set_nested_target_key(DictAttack* instance, uint16_t nested_target_key) {
+    furi_assert(instance);
+
+    with_view_model(
+        instance->view,
+        DictAttackViewModel * model,
+        { model->nested_target_key = nested_target_key; },
+        true);
+}
+
+void dict_attack_set_msb_count(DictAttack* instance, uint16_t msb_count) {
+    furi_assert(instance);
+
+    with_view_model(
+        instance->view, DictAttackViewModel * model, { model->msb_count = msb_count; }, true);
+}

applications/main/nfc/views/dict_attack.h

@@ -77,6 +77,10 @@ void dict_attack_set_prng_type(DictAttack* instance, uint8_t prng_type);
 
 void dict_attack_set_backdoor(DictAttack* instance, uint8_t backdoor);
 
+void dict_attack_set_nested_target_key(DictAttack* instance, uint16_t target_key);
+
+void dict_attack_set_msb_count(DictAttack* instance, uint16_t msb_count);
+
 #ifdef __cplusplus
 }
 #endif