mount/flipperzero-firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

NFC refactoring (#3050)

Browse Source 
"A long time ago in a galaxy far, far away...." we started NFC subsystem refactoring.

Starring:

- @gornekich - NFC refactoring project lead, architect, senior developer
- @gsurkov - architect, senior developer
- @RebornedBrain - senior developer

Supporting roles:

- @skotopes, @DrZlo13, @hedger - general architecture advisors, code review
- @Astrrra, @doomwastaken, @Hellitron, @ImagineVagon333 - quality assurance

Special thanks:

@bettse, @pcunning, @nxv, @noproto, @AloneLiberty and everyone else who has been helping us all this time and contributing valuable knowledges, ideas and source code.
This commit is contained in:
gornekich
2023-10-24 12:08:09 +09:00
committed by GitHub
parent 35c903494c
commit d92b0a82cc
514 changed files with 41487 additions and 68124 deletions
Download Patch File Download Diff File Expand all files Collapse all files
applications/main/nfc/views/detect_reader.c
+4 -1
View File
@@ -163,7 +163,10 @@ void detect_reader_set_nonces_collected(DetectReader* detect_reader, uint16_t no
with_view_model(
detect_reader->view,
DetectReaderViewModel * model,
{ model->nonces = nonces_collected; },
{
model->nonces = nonces_collected;
model->state = DetectReaderStateReaderDetected;
},
false);
}
applications/main/nfc/views/dict_attack.c
+106 -150
View File
@@ -2,42 +2,36 @@
#include <gui/elements.h>
typedef enum {
DictAttackStateRead,
DictAttackStateCardRemoved,
} DictAttackState;
#define NFC_CLASSIC_KEYS_PER_SECTOR 2
struct DictAttack {
View* view;
DictAttackCallback callback;
void* context;
bool card_present;
};
typedef struct {
DictAttackState state;
MfClassicType type;
FuriString* header;
bool card_detected;
uint8_t sectors_total;
uint8_t sectors_read;
uint8_t sector_current;
uint8_t keys_total;
uint8_t current_sector;
uint8_t keys_found;
uint16_t dict_keys_total;
uint16_t dict_keys_current;
size_t dict_keys_total;
size_t dict_keys_current;
bool is_key_attack;
uint8_t key_attack_current_sector;
} DictAttackViewModel;
static void dict_attack_draw_callback(Canvas* canvas, void* model) {
DictAttackViewModel* m = model;
if(m->state == DictAttackStateCardRemoved) {
if(!m->card_detected) {
canvas_set_font(canvas, FontPrimary);
canvas_draw_str_aligned(canvas, 64, 4, AlignCenter, AlignTop, "Lost the tag!");
canvas_set_font(canvas, FontSecondary);
elements_multiline_text_aligned(
canvas, 64, 23, AlignCenter, AlignTop, "Make sure the tag is\npositioned correctly.");
} else if(m->state == DictAttackStateRead) {
} else {
char draw_str[32] = {};
canvas_set_font(canvas, FontSecondary);
canvas_draw_str_aligned(
@@ -49,28 +43,33 @@ static void dict_attack_draw_callback(Canvas* canvas, void* model) {
"Reuse key check for sector: %d",
m->key_attack_current_sector);
} else {
snprintf(draw_str, sizeof(draw_str), "Unlocking sector: %d", m->sector_current);
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->sector_current) + dict_progress) /
((float)(m->current_sector) + dict_progress) /
(float)(m->sectors_total);
if(progress > 1.0) {
progress = 1.0;
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/%d", 1, m->dict_keys_total);
snprintf(draw_str, sizeof(draw_str), "%d/%zu", 1, m->dict_keys_total);
} else {
snprintf(
draw_str, sizeof(draw_str), "%d/%d", m->dict_keys_current, m->dict_keys_total);
draw_str, sizeof(draw_str), "%zu/%zu", m->dict_keys_current, m->dict_keys_total);
}
elements_progress_bar_with_text(canvas, 0, 20, 128, dict_progress, draw_str);
canvas_set_font(canvas, FontSecondary);
snprintf(draw_str, sizeof(draw_str), "Keys found: %d/%d", m->keys_found, m->keys_total);
snprintf(
draw_str,
sizeof(draw_str),
"Keys found: %d/%d",
m->keys_found,
m->sectors_total * NFC_CLASSIC_KEYS_PER_SECTOR);
canvas_draw_str_aligned(canvas, 0, 33, AlignLeft, AlignTop, draw_str);
snprintf(
draw_str, sizeof(draw_str), "Sectors Read: %d/%d", m->sectors_read, m->sectors_total);
@@ -80,55 +79,56 @@ static void dict_attack_draw_callback(Canvas* canvas, void* model) {
}
static bool dict_attack_input_callback(InputEvent* event, void* context) {
DictAttack* dict_attack = context;
DictAttack* instance = context;
bool consumed = false;
if(event->type == InputTypeShort && event->key == InputKeyOk) {
if(dict_attack->callback) {
dict_attack->callback(dict_attack->context);
if(instance->callback) {
instance->callback(DictAttackEventSkipPressed, instance->context);
}
consumed = true;
}
return consumed;
}
DictAttack* dict_attack_alloc() {
DictAttack* dict_attack = malloc(sizeof(DictAttack));
dict_attack->view = view_alloc();
view_allocate_model(dict_attack->view, ViewModelTypeLocking, sizeof(DictAttackViewModel));
view_set_draw_callback(dict_attack->view, dict_attack_draw_callback);
view_set_input_callback(dict_attack->view, dict_attack_input_callback);
view_set_context(dict_attack->view, dict_attack);
DictAttack* instance = malloc(sizeof(DictAttack));
instance->view = view_alloc();
view_allocate_model(instance->view, ViewModelTypeLocking, sizeof(DictAttackViewModel));
view_set_draw_callback(instance->view, dict_attack_draw_callback);
view_set_input_callback(instance->view, dict_attack_input_callback);
view_set_context(instance->view, instance);
with_view_model(
dict_attack->view,
instance->view,
DictAttackViewModel * model,
{ model->header = furi_string_alloc(); },
false);
return dict_attack;
return instance;
}
void dict_attack_free(DictAttack* dict_attack) {
furi_assert(dict_attack);
void dict_attack_free(DictAttack* instance) {
furi_assert(instance);
with_view_model(
dict_attack->view,
DictAttackViewModel * model,
{ furi_string_free(model->header); },
false);
view_free(dict_attack->view);
free(dict_attack);
instance->view, DictAttackViewModel * model, { furi_string_free(model->header); }, false);
view_free(instance->view);
free(instance);
}
void dict_attack_reset(DictAttack* dict_attack) {
furi_assert(dict_attack);
void dict_attack_reset(DictAttack* instance) {
furi_assert(instance);
with_view_model(
dict_attack->view,
instance->view,
DictAttackViewModel * model,
{
model->state = DictAttackStateRead;
model->type = MfClassicType1k;
model->card_detected = false;
model->sectors_total = 0;
model->sectors_read = 0;
model->sector_current = 0;
model->keys_total = 0;
model->current_sector = 0;
model->keys_found = 0;
model->dict_keys_total = 0;
model->dict_keys_current = 0;
@@ -138,152 +138,108 @@ void dict_attack_reset(DictAttack* dict_attack) {
false);
}
View* dict_attack_get_view(DictAttack* dict_attack) {
furi_assert(dict_attack);
return dict_attack->view;
View* dict_attack_get_view(DictAttack* instance) {
furi_assert(instance);
return instance->view;
}
void dict_attack_set_callback(DictAttack* dict_attack, DictAttackCallback callback, void* context) {
furi_assert(dict_attack);
void dict_attack_set_callback(DictAttack* instance, DictAttackCallback callback, void* context) {
furi_assert(instance);
furi_assert(callback);
dict_attack->callback = callback;
dict_attack->context = context;
instance->callback = callback;
instance->context = context;
}
void dict_attack_set_header(DictAttack* dict_attack, const char* header) {
furi_assert(dict_attack);
void dict_attack_set_header(DictAttack* instance, const char* header) {
furi_assert(instance);
furi_assert(header);
with_view_model(
dict_attack->view,
instance->view,
DictAttackViewModel * model,
{ furi_string_set(model->header, header); },
true);
}
void dict_attack_set_card_detected(DictAttack* dict_attack, MfClassicType type) {
furi_assert(dict_attack);
dict_attack->card_present = true;
void dict_attack_set_card_state(DictAttack* instance, bool detected) {
furi_assert(instance);
with_view_model(
dict_attack->view,
instance->view, DictAttackViewModel * model, { model->card_detected = detected; }, true);
}
void dict_attack_set_sectors_total(DictAttack* instance, uint8_t sectors_total) {
furi_assert(instance);
with_view_model(
instance->view,
DictAttackViewModel * model,
{
model->state = DictAttackStateRead;
model->sectors_total = mf_classic_get_total_sectors_num(type);
model->keys_total = model->sectors_total * 2;
},
{ model->sectors_total = sectors_total; },
true);
}
void dict_attack_set_card_removed(DictAttack* dict_attack) {
furi_assert(dict_attack);
dict_attack->card_present = false;
void dict_attack_set_sectors_read(DictAttack* instance, uint8_t sectors_read) {
furi_assert(instance);
with_view_model(
dict_attack->view,
instance->view, DictAttackViewModel * model, { model->sectors_read = sectors_read; }, true);
}
void dict_attack_set_keys_found(DictAttack* instance, uint8_t keys_found) {
furi_assert(instance);
with_view_model(
instance->view, DictAttackViewModel * model, { model->keys_found = keys_found; }, true);
}
void dict_attack_set_current_sector(DictAttack* instance, uint8_t current_sector) {
furi_assert(instance);
with_view_model(
instance->view,
DictAttackViewModel * model,
{ model->state = DictAttackStateCardRemoved; },
{ model->current_sector = current_sector; },
true);
}
bool dict_attack_get_card_state(DictAttack* dict_attack) {
furi_assert(dict_attack);
return dict_attack->card_present;
}
void dict_attack_set_total_dict_keys(DictAttack* instance, size_t dict_keys_total) {
furi_assert(instance);
void dict_attack_set_sector_read(DictAttack* dict_attack, uint8_t sec_read) {
furi_assert(dict_attack);
with_view_model(
dict_attack->view, DictAttackViewModel * model, { model->sectors_read = sec_read; }, true);
}
void dict_attack_set_keys_found(DictAttack* dict_attack, uint8_t keys_found) {
furi_assert(dict_attack);
with_view_model(
dict_attack->view, DictAttackViewModel * model, { model->keys_found = keys_found; }, true);
}
void dict_attack_set_current_sector(DictAttack* dict_attack, uint8_t curr_sec) {
furi_assert(dict_attack);
with_view_model(
dict_attack->view,
DictAttackViewModel * model,
{
model->sector_current = curr_sec;
model->dict_keys_current = 0;
},
true);
}
void dict_attack_inc_current_sector(DictAttack* dict_attack) {
furi_assert(dict_attack);
with_view_model(
dict_attack->view,
DictAttackViewModel * model,
{
if(model->sector_current < model->sectors_total) {
model->sector_current++;
model->dict_keys_current = 0;
}
},
true);
}
void dict_attack_inc_keys_found(DictAttack* dict_attack) {
furi_assert(dict_attack);
with_view_model(
dict_attack->view,
DictAttackViewModel * model,
{
if(model->keys_found < model->keys_total) {
model->keys_found++;
}
},
true);
}
void dict_attack_set_total_dict_keys(DictAttack* dict_attack, uint16_t dict_keys_total) {
furi_assert(dict_attack);
with_view_model(
dict_attack->view,
instance->view,
DictAttackViewModel * model,
{ model->dict_keys_total = dict_keys_total; },
true);
}
void dict_attack_inc_current_dict_key(DictAttack* dict_attack, uint16_t keys_tried) {
furi_assert(dict_attack);
void dict_attack_set_current_dict_key(DictAttack* instance, size_t cur_key_num) {
furi_assert(instance);
with_view_model(
dict_attack->view,
instance->view,
DictAttackViewModel * model,
{
if(model->dict_keys_current + keys_tried < model->dict_keys_total) {
model->dict_keys_current += keys_tried;
}
},
{ model->dict_keys_current = cur_key_num; },
true);
}
void dict_attack_set_key_attack(DictAttack* dict_attack, bool is_key_attack, uint8_t sector) {
furi_assert(dict_attack);
void dict_attack_set_key_attack(DictAttack* instance, uint8_t sector) {
furi_assert(instance);
with_view_model(
dict_attack->view,
instance->view,
DictAttackViewModel * model,
{
model->is_key_attack = is_key_attack;
model->is_key_attack = true;
model->key_attack_current_sector = sector;
},
true);
}
void dict_attack_inc_key_attack_current_sector(DictAttack* dict_attack) {
furi_assert(dict_attack);
void dict_attack_reset_key_attack(DictAttack* instance) {
furi_assert(instance);
with_view_model(
dict_attack->view,
DictAttackViewModel * model,
{
if(model->key_attack_current_sector < model->sectors_total) {
model->key_attack_current_sector++;
}
},
true);
instance->view, DictAttackViewModel * model, { model->is_key_attack = false; }, true);
}
applications/main/nfc/views/dict_attack.h
+26 -22
View File
@@ -1,46 +1,50 @@
#pragma once
#include <stdint.h>
#include <gui/view.h>
#include <gui/modules/widget.h>
#include <lib/nfc/protocols/mifare_classic.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct DictAttack DictAttack;
typedef void (*DictAttackCallback)(void* context);
typedef enum {
DictAttackEventSkipPressed,
} DictAttackEvent;
typedef void (*DictAttackCallback)(DictAttackEvent event, void* context);
DictAttack* dict_attack_alloc();
void dict_attack_free(DictAttack* dict_attack);
void dict_attack_free(DictAttack* instance);
void dict_attack_reset(DictAttack* dict_attack);
void dict_attack_reset(DictAttack* instance);
View* dict_attack_get_view(DictAttack* dict_attack);
View* dict_attack_get_view(DictAttack* instance);
void dict_attack_set_callback(DictAttack* dict_attack, DictAttackCallback callback, void* context);
void dict_attack_set_callback(DictAttack* instance, DictAttackCallback callback, void* context);
void dict_attack_set_header(DictAttack* dict_attack, const char* header);
void dict_attack_set_header(DictAttack* instance, const char* header);
void dict_attack_set_card_detected(DictAttack* dict_attack, MfClassicType type);
void dict_attack_set_card_state(DictAttack* instance, bool detected);
void dict_attack_set_card_removed(DictAttack* dict_attack);
void dict_attack_set_sectors_total(DictAttack* instance, uint8_t sectors_total);
bool dict_attack_get_card_state(DictAttack* dict_attack);
void dict_attack_set_sectors_read(DictAttack* instance, uint8_t sectors_read);
void dict_attack_set_sector_read(DictAttack* dict_attack, uint8_t sec_read);
void dict_attack_set_keys_found(DictAttack* instance, uint8_t keys_found);
void dict_attack_set_keys_found(DictAttack* dict_attack, uint8_t keys_found);
void dict_attack_set_current_sector(DictAttack* instance, uint8_t curr_sec);
void dict_attack_set_current_sector(DictAttack* dict_attack, uint8_t curr_sec);
void dict_attack_set_total_dict_keys(DictAttack* instance, size_t dict_keys_total);
void dict_attack_inc_current_sector(DictAttack* dict_attack);
void dict_attack_set_current_dict_key(DictAttack* instance, size_t cur_key_num);
void dict_attack_inc_keys_found(DictAttack* dict_attack);
void dict_attack_set_key_attack(DictAttack* instance, uint8_t sector);
void dict_attack_set_total_dict_keys(DictAttack* dict_attack, uint16_t dict_keys_total);
void dict_attack_reset_key_attack(DictAttack* instance);
void dict_attack_inc_current_dict_key(DictAttack* dict_attack, uint16_t keys_tried);
void dict_attack_set_key_attack(DictAttack* dict_attack, bool is_key_attack, uint8_t sector);
void dict_attack_inc_key_attack_current_sector(DictAttack* dict_attack);
#ifdef __cplusplus
}
#endif