Mirror/Momentum-Firmware
1
0
Fork 0
mirror of https://github.com/Next-Flip/Momentum-Firmware.git synced 2026-05-27 06:04:46 -07:00
Code Issues Packages Projects Releases Wiki Activity

Update multi fuzzer and subghz remote

Browse Source
This commit is contained in:
Willy-JL
2023-07-14 17:50:15 +02:00
parent b8d740c6d8
commit afba0aad71
61 changed files with 1302 additions and 2989 deletions
Download Patch File Download Diff File Expand all files Collapse all files

403
applications/external/multi_fuzzer/views/attack.c vendored
View File

@@ -6,7 +6,12 @@
#define ATTACK_SCENE_MAX_UID_LENGTH 25
#define UID_MAX_DISPLAYED_LEN (8U)
#define LIFT_RIGHT_OFFSET (3)
#define LEFT_RIGHT_OFFSET (3U)
#define LINE_1_Y (12U)
#define LINE_2_Y (24U)
#define LINE_3_Y (36U)
#define LINE_4_Y (48U)
struct FuzzerViewAttack {
View* view;
@@ -60,44 +65,11 @@ void fuzzer_view_attack_set_uid(FuzzerViewAttack* view, const FuzzerPayload* uid
true);
}
void fuzzer_view_attack_start(FuzzerViewAttack* view) {
void fuzzer_view_update_state(FuzzerViewAttack* view, FuzzerAttackState state) {
furi_assert(view);
with_view_model(
view->view,
FuzzerViewAttackModel * model,
{ model->attack_state = FuzzerAttackStateRunning; },
true);
}
void fuzzer_view_attack_stop(FuzzerViewAttack* view) {
furi_assert(view);
with_view_model(
view->view,
FuzzerViewAttackModel * model,
{ model->attack_state = FuzzerAttackStateOff; },
true);
}
void fuzzer_view_attack_pause(FuzzerViewAttack* view) {
furi_assert(view);
with_view_model(
view->view,
FuzzerViewAttackModel * model,
{ model->attack_state = FuzzerAttackStateIdle; },
true);
}
void fuzzer_view_attack_end(FuzzerViewAttack* view) {
furi_assert(view);
with_view_model(
view->view,
FuzzerViewAttackModel * model,
{ model->attack_state = FuzzerAttackStateEnd; },
true);
view->view, FuzzerViewAttackModel * model, { model->attack_state = state; }, true);
}
void fuzzer_view_attack_set_callback(
@@ -110,35 +82,31 @@ void fuzzer_view_attack_set_callback(
view_attack->context = context;
}
void fuzzer_view_attack_draw(Canvas* canvas, FuzzerViewAttackModel* model) {
char temp_str[50];
canvas_clear(canvas);
canvas_set_color(canvas, ColorBlack);
canvas_set_font(canvas, FontPrimary);
canvas_draw_str_aligned(canvas, 64, 2, AlignCenter, AlignTop, model->attack_name);
static void
fuzzer_view_attack_draw_time_delays_line(Canvas* canvas, FuzzerViewAttackModel* model) {
char temp_str[25];
uint16_t crt;
const uint16_t y = LINE_2_Y;
canvas_set_font(canvas, FontPrimary);
if(!model->td_emt_cursor) {
canvas_set_font(canvas, FontSecondary);
snprintf(temp_str, sizeof(temp_str), "Time delay:");
canvas_draw_str_aligned(canvas, LIFT_RIGHT_OFFSET, 21, AlignLeft, AlignBottom, temp_str);
canvas_draw_str_aligned(canvas, LEFT_RIGHT_OFFSET, y, AlignLeft, AlignBottom, temp_str);
crt = canvas_string_width(canvas, temp_str);
canvas_set_font(canvas, FontPrimary);
snprintf(
temp_str, sizeof(temp_str), "%d.%d", model->time_delay / 10, model->time_delay % 10);
canvas_draw_str_aligned(
canvas, crt + LIFT_RIGHT_OFFSET + 3, 21, AlignLeft, AlignBottom, temp_str);
canvas, crt + LEFT_RIGHT_OFFSET + 3, y, AlignLeft, AlignBottom, temp_str);
canvas_set_font(canvas, FontSecondary);
snprintf(
temp_str, sizeof(temp_str), "EmT: %d.%d", model->emu_time / 10, model->emu_time % 10);
canvas_draw_str_aligned(
canvas, 128 - LIFT_RIGHT_OFFSET, 21, AlignRight, AlignBottom, temp_str);
canvas, 128 - LEFT_RIGHT_OFFSET, y, AlignRight, AlignBottom, temp_str);
} else {
canvas_set_font(canvas, FontSecondary);
snprintf(
@@ -148,138 +116,206 @@ void fuzzer_view_attack_draw(Canvas* canvas, FuzzerViewAttackModel* model) {
model->time_delay / 10,
model->time_delay % 10);
canvas_draw_str_aligned(canvas, LIFT_RIGHT_OFFSET, 21, AlignLeft, AlignBottom, temp_str);
canvas_draw_str_aligned(canvas, LEFT_RIGHT_OFFSET, y, AlignLeft, AlignBottom, temp_str);
canvas_set_font(canvas, FontPrimary);
snprintf(temp_str, sizeof(temp_str), "%d.%d", model->emu_time / 10, model->emu_time % 10);
canvas_draw_str_aligned(
canvas, 128 - LIFT_RIGHT_OFFSET, 21, AlignRight, AlignBottom, temp_str);
canvas, 128 - LEFT_RIGHT_OFFSET, y, AlignRight, AlignBottom, temp_str);
crt = canvas_string_width(canvas, temp_str);
canvas_set_font(canvas, FontSecondary);
snprintf(temp_str, sizeof(temp_str), "Emulation time:");
canvas_draw_str_aligned(
canvas, 128 - LIFT_RIGHT_OFFSET - crt - 3, 21, AlignRight, AlignBottom, temp_str);
canvas, 128 - LEFT_RIGHT_OFFSET - crt - 3, y, AlignRight, AlignBottom, temp_str);
}
}
static void fuzzer_view_attack_draw_time_delays_str(Canvas* canvas, FuzzerViewAttackModel* model) {
char temp_str[20];
uint16_t crt;
const uint16_t y = LINE_2_Y;
canvas_set_font(canvas, FontSecondary);
canvas_draw_str_aligned(canvas, 64, 26, AlignCenter, AlignTop, model->protocol_name);
snprintf(
temp_str,
sizeof(temp_str),
"TD: %d.%d Emt: %d.%d",
model->time_delay / 10,
model->time_delay % 10,
model->emu_time / 10,
model->emu_time % 10);
crt = canvas_string_width(canvas, temp_str);
canvas_draw_str_aligned(
canvas, 128 - LEFT_RIGHT_OFFSET - crt, y, AlignLeft, AlignBottom, temp_str);
}
static void fuzzer_view_attack_draw_idle(Canvas* canvas, FuzzerViewAttackModel* model) {
if(model->td_emt_cursor) {
elements_button_center(canvas, "Start");
elements_button_left(canvas, "EmT -");
elements_button_right(canvas, "+ EmT");
} else {
elements_button_center(canvas, "Start");
elements_button_left(canvas, "TD -");
elements_button_right(canvas, "+ TD");
}
}
static void fuzzer_view_attack_draw_running(Canvas* canvas, FuzzerViewAttackModel* model) {
UNUSED(model);
elements_button_left(canvas, "Stop");
elements_button_center(canvas, "Pause");
}
static void fuzzer_view_attack_draw_end(Canvas* canvas, FuzzerViewAttackModel* model) {
UNUSED(model);
// elements_button_center(canvas, "Restart"); // Reset
elements_button_left(canvas, "Exit");
}
void fuzzer_view_attack_draw(Canvas* canvas, FuzzerViewAttackModel* model) {
canvas_clear(canvas);
canvas_set_color(canvas, ColorBlack);
// Header - Attack name
canvas_set_font(canvas, FontPrimary);
canvas_draw_str_aligned(canvas, 64, LINE_1_Y, AlignCenter, AlignBottom, model->attack_name);
// Time delays line or Status line
switch(model->attack_state) {
case FuzzerAttackStateIdle:
fuzzer_view_attack_draw_time_delays_line(canvas, model);
break;
case FuzzerAttackStateAttacking:
canvas_set_font(canvas, FontPrimary);
canvas_draw_str(canvas, LEFT_RIGHT_OFFSET, LINE_2_Y, "Attacking");
fuzzer_view_attack_draw_time_delays_str(canvas, model);
break;
case FuzzerAttackStateEmulating:
canvas_set_font(canvas, FontPrimary);
canvas_draw_str_aligned(canvas, 64, LINE_2_Y, AlignCenter, AlignBottom, "Emulating:");
break;
case FuzzerAttackStatePause:
canvas_set_font(canvas, FontPrimary);
canvas_draw_str(canvas, LEFT_RIGHT_OFFSET, LINE_2_Y, "Paused");
canvas_set_font(canvas, FontSecondary);
canvas_draw_icon_ex(canvas, 62, LINE_2_Y - 9, &I_Pin_arrow_up_7x9, IconRotation180);
canvas_draw_icon(canvas, 69, LINE_2_Y - 9, &I_Pin_arrow_up_7x9);
canvas_draw_str(canvas, 79, LINE_2_Y, "Change UID");
break;
case FuzzerAttackStateEnd:
canvas_set_font(canvas, FontPrimary);
canvas_draw_str_aligned(canvas, 64, LINE_2_Y, AlignCenter, AlignBottom, "Attack is over");
break;
default:
break;
}
// Protocol name
canvas_set_font(canvas, FontSecondary);
canvas_draw_str_aligned(canvas, 64, LINE_3_Y, AlignCenter, AlignBottom, model->protocol_name);
// Current UID
canvas_set_font(canvas, FontPrimary);
if(128 < canvas_string_width(canvas, furi_string_get_cstr(model->uid_str))) {
canvas_set_font(canvas, FontSecondary);
}
canvas_draw_str_aligned(
canvas, 64, 38, AlignCenter, AlignTop, furi_string_get_cstr(model->uid_str));
canvas, 64, LINE_4_Y, AlignCenter, AlignBottom, furi_string_get_cstr(model->uid_str));
// Btns
canvas_set_font(canvas, FontSecondary);
if(model->attack_state == FuzzerAttackStateRunning) {
elements_button_center(canvas, "Stop");
if(model->attack_state == FuzzerAttackStateAttacking ||
model->attack_state == FuzzerAttackStateEmulating) {
fuzzer_view_attack_draw_running(canvas, model);
} else if(model->attack_state == FuzzerAttackStateIdle) {
if(model->td_emt_cursor) {
elements_button_center(canvas, "Start");
elements_button_left(canvas, "EmT -");
elements_button_right(canvas, "+ EmT");
} else {
elements_button_center(canvas, "Start");
elements_button_left(canvas, "TD -");
elements_button_right(canvas, "+ TD");
}
fuzzer_view_attack_draw_idle(canvas, model);
} else if(model->attack_state == FuzzerAttackStatePause) {
elements_button_left(canvas, "Back");
elements_button_right(canvas, "Save");
elements_button_center(canvas, "Emu");
} else if(model->attack_state == FuzzerAttackStateEnd) {
// elements_button_center(canvas, "Restart"); // Reset
elements_button_left(canvas, "Exit");
fuzzer_view_attack_draw_end(canvas, model);
}
}
bool fuzzer_view_attack_input(InputEvent* event, void* context) {
furi_assert(context);
FuzzerViewAttack* view_attack = context;
static bool fuzzer_view_attack_input_idle(
FuzzerViewAttack* view_attack,
InputEvent* event,
FuzzerViewAttackModel* model) {
if(event->key == InputKeyBack && event->type == InputTypeShort) {
view_attack->callback(FuzzerCustomEventViewAttackBack, view_attack->context);
view_attack->callback(FuzzerCustomEventViewAttackExit, view_attack->context);
return true;
} else if(event->key == InputKeyOk && event->type == InputTypeShort) {
view_attack->callback(FuzzerCustomEventViewAttackOk, view_attack->context);
view_attack->callback(FuzzerCustomEventViewAttackRunAttack, view_attack->context);
return true;
} else if(event->key == InputKeyLeft) {
with_view_model(
view_attack->view,
FuzzerViewAttackModel * model,
{
if(model->attack_state == FuzzerAttackStateIdle) {
if(!model->td_emt_cursor) {
// TimeDelay --
if(event->type == InputTypeShort) {
if(model->time_delay > model->time_delay_min) {
model->time_delay--;
}
} else if(event->type == InputTypeLong) {
if((model->time_delay - 10) >= model->time_delay_min) {
model->time_delay -= 10;
} else {
model->time_delay = model->time_delay_min;
}
}
} else {
// EmuTime --
if(event->type == InputTypeShort) {
if(model->emu_time > model->emu_time_min) {
model->emu_time--;
}
} else if(event->type == InputTypeLong) {
if((model->emu_time - 10) >= model->emu_time_min) {
model->emu_time -= 10;
} else {
model->emu_time = model->emu_time_min;
}
}
}
} else if(
(model->attack_state == FuzzerAttackStateEnd) &&
(event->type == InputTypeShort)) {
// Exit if Ended
view_attack->callback(FuzzerCustomEventViewAttackBack, view_attack->context);
if(!model->td_emt_cursor) {
// TimeDelay --
if(event->type == InputTypeShort) {
if(model->time_delay > model->time_delay_min) {
model->time_delay--;
}
},
true);
} else if(event->type == InputTypeLong || event->type == InputTypeRepeat) {
if((model->time_delay - 10) >= model->time_delay_min) {
model->time_delay -= 10;
} else {
model->time_delay = model->time_delay_min;
}
}
} else {
// EmuTime --
if(event->type == InputTypeShort) {
if(model->emu_time > model->emu_time_min) {
model->emu_time--;
}
} else if(event->type == InputTypeLong || event->type == InputTypeRepeat) {
if((model->emu_time - 10) >= model->emu_time_min) {
model->emu_time -= 10;
} else {
model->emu_time = model->emu_time_min;
}
}
}
return true;
} else if(event->key == InputKeyRight) {
with_view_model(
view_attack->view,
FuzzerViewAttackModel * model,
{
if(model->attack_state == FuzzerAttackStateIdle) {
if(!model->td_emt_cursor) {
// TimeDelay ++
if(event->type == InputTypeShort) {
if(model->time_delay < FUZZ_TIME_DELAY_MAX) {
model->time_delay++;
}
} else if(event->type == InputTypeLong) {
model->time_delay += 10;
if(model->time_delay > FUZZ_TIME_DELAY_MAX) {
model->time_delay = FUZZ_TIME_DELAY_MAX;
}
}
} else {
// EmuTime ++
if(event->type == InputTypeShort) {
if(model->emu_time < FUZZ_TIME_DELAY_MAX) {
model->emu_time++;
}
} else if(event->type == InputTypeLong) {
model->emu_time += 10;
if(model->emu_time > FUZZ_TIME_DELAY_MAX) {
model->emu_time = FUZZ_TIME_DELAY_MAX;
}
}
}
} else {
// Nothing
if(!model->td_emt_cursor) {
// TimeDelay ++
if(event->type == InputTypeShort) {
if(model->time_delay < FUZZ_TIME_DELAY_MAX) {
model->time_delay++;
}
},
true);
} else if(event->type == InputTypeLong || event->type == InputTypeRepeat) {
model->time_delay += 10;
if(model->time_delay > FUZZ_TIME_DELAY_MAX) {
model->time_delay = FUZZ_TIME_DELAY_MAX;
}
}
} else {
// EmuTime ++
if(event->type == InputTypeShort) {
if(model->emu_time < FUZZ_TIME_DELAY_MAX) {
model->emu_time++;
}
} else if(event->type == InputTypeLong || event->type == InputTypeRepeat) {
model->emu_time += 10;
if(model->emu_time > FUZZ_TIME_DELAY_MAX) {
model->emu_time = FUZZ_TIME_DELAY_MAX;
}
}
}
return true;
} else if(
(event->key == InputKeyUp || event->key == InputKeyDown) &&
@@ -291,6 +327,81 @@ bool fuzzer_view_attack_input(InputEvent* event, void* context) {
true);
return true;
}
return true;
}
static bool fuzzer_view_attack_input_end(
FuzzerViewAttack* view_attack,
InputEvent* event,
FuzzerViewAttackModel* model) {
UNUSED(model);
if((event->key == InputKeyBack || event->key == InputKeyLeft) &&
event->type == InputTypeShort) {
// Exit if Ended
view_attack->callback(FuzzerCustomEventViewAttackExit, view_attack->context);
}
return true;
}
bool fuzzer_view_attack_input(InputEvent* event, void* context) {
furi_assert(context);
FuzzerViewAttack* view_attack = context;
// if(event->key == InputKeyBack && event->type == InputTypeShort) {
// view_attack->callback(FuzzerCustomEventViewAttackBack, view_attack->context);
// return true;
// } else if(event->key == InputKeyOk && event->type == InputTypeShort) {
// view_attack->callback(FuzzerCustomEventViewAttackOk, view_attack->context);
// return true;
// } else
// {
with_view_model(
view_attack->view,
FuzzerViewAttackModel * model,
{
switch(model->attack_state) {
case FuzzerAttackStateIdle:
fuzzer_view_attack_input_idle(view_attack, event, model);
break;
case FuzzerAttackStateEnd:
fuzzer_view_attack_input_end(view_attack, event, model);
break;
case FuzzerAttackStateAttacking:
case FuzzerAttackStateEmulating:
if((event->key == InputKeyBack || event->key == InputKeyLeft) &&
event->type == InputTypeShort) {
view_attack->callback(FuzzerCustomEventViewAttackIdle, view_attack->context);
} else if(event->key == InputKeyOk && event->type == InputTypeShort) {
view_attack->callback(FuzzerCustomEventViewAttackPause, view_attack->context);
}
break;
case FuzzerAttackStatePause:
if((event->key == InputKeyBack || event->key == InputKeyLeft) &&
event->type == InputTypeShort) {
view_attack->callback(FuzzerCustomEventViewAttackIdle, view_attack->context);
} else if(event->key == InputKeyRight && event->type == InputTypeShort) {
view_attack->callback(FuzzerCustomEventViewAttackSave, view_attack->context);
} else if(event->key == InputKeyOk && event->type == InputTypeShort) {
view_attack->callback(
FuzzerCustomEventViewAttackEmulateCurrent, view_attack->context);
} else if(event->key == InputKeyUp && event->type == InputTypeShort) {
view_attack->callback(
FuzzerCustomEventViewAttackPrevUid, view_attack->context);
} else if(event->key == InputKeyDown && event->type == InputTypeShort) {
view_attack->callback(
FuzzerCustomEventViewAttackNextUid, view_attack->context);
}
break;
default:
break;
}
},
true);
// }
return true;
}