addding some great plugins to be preinstalled

and running fbt format, and fixing TOTP printf format

ReadMe.md

@@ -80,6 +80,8 @@ Also check changelog in releases for latest updates!
 - Simple Clock (timer by GMMan / settings by kowalski7cc) [(Original by CompaqDisc)](https://gist.github.com/CompaqDisc/4e329c501bd03c1e801849b81f48ea61)
 - UniversalRF Remix / Sub-GHz Remote [(by ESurge)](https://github.com/ESurge/flipperzero-firmware-unirfremix)[(updated and all protocol support added by darmiel & xMasterX)](https://github.com/darmiel/flipper-playlist/tree/feat/unirf-protocols)
 - Spectrum Analyzer (with changes) [(by jolcese)](https://github.com/jolcese/flipperzero-firmware/tree/spectrum/applications/spectrum_analyzer) - [Ultra Narrow mode & scan channels non-consecutively](https://github.com/theY4Kman/flipperzero-firmware/commits?author=theY4Kman)
+- Metronome [(by panki27)](https://github.com/panki27/Metronome)
+- **TOTP (Authenticator)** [(by akopachov)](https://github.com/akopachov/flipper-zero_authenticator)
 
 Games:
 - DOOM (fixed) [(By p4nic4ttack)](https://github.com/p4nic4ttack/doom-flipper-zero/)
@@ -88,6 +90,7 @@ Games:
 - Arkanoid (refactored by xMasterX) [(by gotnull)](https://github.com/gotnull/flipperzero-firmware-wPlugins)
 - Tic Tac Toe (refactored by xMasterX) [(by gotnull)](https://github.com/gotnull/flipperzero-firmware-wPlugins)
 - Tetris (with fixes) [(by jeffplang)](https://github.com/jeffplang/flipperzero-firmware/tree/tetris_game/applications/tetris_game)
+- Minesweeper [(by panki27)](https://github.com/panki27/minesweeper)
 
 ### Other changes
 
@@ -113,6 +116,8 @@ Games:
 
 ## [- Configure Sub-GHz Remote App](https://github.com/DarkFlippers/unleashed-firmware/blob/dev/documentation/SubGHzRemotePlugin.md)
 
+## [- TOTP (Authenticator) config description](https://github.com/akopachov/flipper-zero_authenticator/blob/master/.github/conf-file_description.md)
+
 ## [- Barcode Generator](https://github.com/DarkFlippers/unleashed-firmware/blob/dev/documentation/BarcodeGenerator.md)
 
 ## [- Multi Converter](https://github.com/DarkFlippers/unleashed-firmware/blob/dev/documentation/MultiConverter.md)

applications/plugins/metronome/README.md

@@ -0,0 +1,23 @@
+# Metronome
+
+[Original link](https://github.com/panki27/Metronome)
+
+A metronome for the [Flipper Zero](https://flipperzero.one/) device. Goes along perfectly with my [BPM tapper](https://github.com/panki27/bpm-tapper).
+
+![screenshot](img/screenshot.png)
+
+## Features
+
+- BPM adjustable, fine and coarse (hold pressed)
+- Selectable amount of beats per bar
+- Selectable note length
+- First beat is pronounced
+- Progress indicator
+- LED flashes accordingly
+- 3 different settings: Beep, Vibrate, Silent (push Down to change)
+
+## Compiling
+
+```
+./fbt firmware_metronome
+```

applications/plugins/metronome/application.fam

@@ -0,0 +1,14 @@
+App(
+    appid="Metronome",
+    name="Metronome",
+    apptype=FlipperAppType.EXTERNAL,
+    entry_point="metronome_app",
+    cdefines=["APP_METRONOME"],
+    requires=[
+        "gui",
+    ],
+    fap_icon="metronome_icon.png",
+    fap_category="Music",
+    stack_size=2 * 1024,
+    order=20,
+)

applications/plugins/metronome/gui_extensions.c

@@ -0,0 +1,55 @@
+#include <gui/canvas.h>
+#include <gui/icon_i.h>
+
+//lib can only do bottom left/right
+void elements_button_top_left(Canvas* canvas, const char* str) {
+    const uint8_t button_height = 12;
+    const uint8_t vertical_offset = 3;
+    const uint8_t horizontal_offset = 3;
+    const uint8_t string_width = canvas_string_width(canvas, str);
+    const Icon* icon = &I_ButtonUp_7x4;
+    const uint8_t icon_h_offset = 3;
+    const uint8_t icon_width_with_offset = icon->width + icon_h_offset;
+    const uint8_t icon_v_offset = icon->height + vertical_offset;
+    const uint8_t button_width = string_width + horizontal_offset * 2 + icon_width_with_offset;
+
+    const uint8_t x = 0;
+    const uint8_t y = 0 + button_height;
+
+    canvas_draw_box(canvas, x, y - button_height, button_width, button_height);
+    canvas_draw_line(canvas, x + button_width + 0, y - button_height, x + button_width + 0, y - 1);
+    canvas_draw_line(canvas, x + button_width + 1, y - button_height, x + button_width + 1, y - 2);
+    canvas_draw_line(canvas, x + button_width + 2, y - button_height, x + button_width + 2, y - 3);
+
+    canvas_invert_color(canvas);
+    canvas_draw_icon(canvas, x + horizontal_offset, y - icon_v_offset, &I_ButtonUp_7x4);
+    canvas_draw_str(
+        canvas, x + horizontal_offset + icon_width_with_offset, y - vertical_offset, str);
+    canvas_invert_color(canvas);
+}
+
+void elements_button_top_right(Canvas* canvas, const char* str) {
+    const uint8_t button_height = 12;
+    const uint8_t vertical_offset = 3;
+    const uint8_t horizontal_offset = 3;
+    const uint8_t string_width = canvas_string_width(canvas, str);
+    const Icon* icon = &I_ButtonUp_7x4;
+    const uint8_t icon_h_offset = 3;
+    const uint8_t icon_width_with_offset = icon->width + icon_h_offset;
+    const uint8_t icon_v_offset = icon->height + vertical_offset;
+    const uint8_t button_width = string_width + horizontal_offset * 2 + icon_width_with_offset;
+
+    const uint8_t x = canvas_width(canvas);
+    const uint8_t y = 0 + button_height;
+
+    canvas_draw_box(canvas, x - button_width, y - button_height, button_width, button_height);
+    canvas_draw_line(canvas, x - button_width - 1, y - button_height, x - button_width - 1, y - 1);
+    canvas_draw_line(canvas, x - button_width - 2, y - button_height, x - button_width - 2, y - 2);
+    canvas_draw_line(canvas, x - button_width - 3, y - button_height, x - button_width - 3, y - 3);
+
+    canvas_invert_color(canvas);
+    canvas_draw_str(canvas, x - button_width + horizontal_offset, y - vertical_offset, str);
+    canvas_draw_icon(
+        canvas, x - horizontal_offset - icon->width, y - icon_v_offset, &I_ButtonUp_7x4);
+    canvas_invert_color(canvas);
+}

applications/plugins/metronome/gui_extensions.h

@@ -0,0 +1,3 @@
+void elements_button_top_right(Canvas* canvas, const char* str);
+
+void elements_button_top_left(Canvas* canvas, const char* str);

applications/plugins/metronome/metronome.c

@@ -0,0 +1,383 @@
+#include <furi.h>
+#include <furi_hal.h>
+#include <input/input.h>
+#include <m-string.h>
+#include <stdlib.h>
+
+#include <gui/gui.h>
+#include <gui/elements.h>
+#include <gui/canvas.h>
+
+#include <notification/notification.h>
+#include <notification/notification_messages.h>
+
+#include "gui_extensions.h"
+
+#define BPM_STEP_SIZE_FINE 0.5d
+#define BPM_STEP_SIZE_COARSE 10.0d
+#define BPM_BOUNDARY_LOW 10.0d
+#define BPM_BOUNDARY_HIGH 300.0d
+#define BEEP_DELAY_MS 50
+
+#define wave_bitmap_left_width 4
+#define wave_bitmap_left_height 14
+static uint8_t wave_bitmap_left_bits[] =
+    {0x08, 0x0C, 0x06, 0x06, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x06, 0x06, 0x0C, 0x08};
+
+#define wave_bitmap_right_width 4
+#define wave_bitmap_right_height 14
+static uint8_t wave_bitmap_right_bits[] =
+    {0x01, 0x03, 0x06, 0x06, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x06, 0x06, 0x03, 0x01};
+
+typedef enum {
+    EventTypeTick,
+    EventTypeKey,
+} EventType;
+
+typedef struct {
+    EventType type;
+    InputEvent input;
+} PluginEvent;
+
+enum OutputMode { Loud, Vibro, Silent };
+
+typedef struct {
+    double bpm;
+    bool playing;
+    int beats_per_bar;
+    int note_length;
+    int current_beat;
+    enum OutputMode output_mode;
+    FuriTimer* timer;
+    NotificationApp* notifications;
+} MetronomeState;
+
+static void render_callback(Canvas* const canvas, void* ctx) {
+    const MetronomeState* metronome_state = acquire_mutex((ValueMutex*)ctx, 25);
+    if(metronome_state == NULL) {
+        return;
+    }
+
+    string_t tempStr;
+    string_init(tempStr);
+
+    canvas_draw_frame(canvas, 0, 0, 128, 64);
+
+    canvas_set_font(canvas, FontPrimary);
+
+    // draw bars/beat
+    string_printf(tempStr, "%d/%d", metronome_state->beats_per_bar, metronome_state->note_length);
+    canvas_draw_str_aligned(canvas, 64, 8, AlignCenter, AlignCenter, string_get_cstr(tempStr));
+    string_reset(tempStr);
+
+    // draw BPM value
+    string_printf(tempStr, "%.2f", metronome_state->bpm);
+    canvas_set_font(canvas, FontBigNumbers);
+    canvas_draw_str_aligned(canvas, 64, 24, AlignCenter, AlignCenter, string_get_cstr(tempStr));
+    string_reset(tempStr);
+
+    // draw volume indicator
+    // always draw first waves
+    canvas_draw_xbm(
+        canvas, 20, 17, wave_bitmap_left_width, wave_bitmap_left_height, wave_bitmap_left_bits);
+    canvas_draw_xbm(
+        canvas,
+        canvas_width(canvas) - 20 - wave_bitmap_right_width,
+        17,
+        wave_bitmap_right_width,
+        wave_bitmap_right_height,
+        wave_bitmap_right_bits);
+    if(metronome_state->output_mode < Silent) {
+        canvas_draw_xbm(
+            canvas, 16, 17, wave_bitmap_left_width, wave_bitmap_left_height, wave_bitmap_left_bits);
+        canvas_draw_xbm(
+            canvas,
+            canvas_width(canvas) - 16 - wave_bitmap_right_width,
+            17,
+            wave_bitmap_right_width,
+            wave_bitmap_right_height,
+            wave_bitmap_right_bits);
+    }
+    if(metronome_state->output_mode < Vibro) {
+        canvas_draw_xbm(
+            canvas, 12, 17, wave_bitmap_left_width, wave_bitmap_left_height, wave_bitmap_left_bits);
+        canvas_draw_xbm(
+            canvas,
+            canvas_width(canvas) - 12 - wave_bitmap_right_width,
+            17,
+            wave_bitmap_right_width,
+            wave_bitmap_right_height,
+            wave_bitmap_right_bits);
+    }
+    // draw button prompts
+    canvas_set_font(canvas, FontSecondary);
+    elements_button_left(canvas, "Slow");
+    elements_button_right(canvas, "Fast");
+    if(metronome_state->playing) {
+        elements_button_center(canvas, "Stop ");
+    } else {
+        elements_button_center(canvas, "Start");
+    }
+    elements_button_top_left(canvas, "Push");
+    elements_button_top_right(canvas, "Hold");
+
+    // draw progress bar
+    elements_progress_bar(
+        canvas, 8, 36, 112, (float)metronome_state->current_beat / metronome_state->beats_per_bar);
+
+    // cleanup
+    string_clear(tempStr);
+    release_mutex((ValueMutex*)ctx, metronome_state);
+}
+
+static void input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
+    furi_assert(event_queue);
+
+    PluginEvent event = {.type = EventTypeKey, .input = *input_event};
+    furi_message_queue_put(event_queue, &event, FuriWaitForever);
+}
+
+static void timer_callback(void* ctx) {
+    // this is where we go BEEP!
+    MetronomeState* metronome_state = acquire_mutex((ValueMutex*)ctx, 25);
+    metronome_state->current_beat++;
+    if(metronome_state->current_beat > metronome_state->beats_per_bar) {
+        metronome_state->current_beat = 1;
+    }
+    if(metronome_state->current_beat == 1) {
+        // pronounced beat
+        notification_message(metronome_state->notifications, &sequence_set_only_red_255);
+        switch(metronome_state->output_mode) {
+        case Loud:
+            furi_hal_speaker_start(440.0f, 1.0f);
+            break;
+        case Vibro:
+            notification_message(metronome_state->notifications, &sequence_set_vibro_on);
+            break;
+        case Silent:
+            break;
+        }
+    } else {
+        // unpronounced beat
+        notification_message(metronome_state->notifications, &sequence_set_only_green_255);
+        switch(metronome_state->output_mode) {
+        case Loud:
+            furi_hal_speaker_start(220.0f, 1.0f);
+            break;
+        case Vibro:
+            notification_message(metronome_state->notifications, &sequence_set_vibro_on);
+            break;
+        case Silent:
+            break;
+        }
+    };
+
+    // this is a bit of a kludge... if we are on vibro and unpronounced, stop vibro after half the usual duration
+    switch(metronome_state->output_mode) {
+    case Loud:
+        furi_delay_ms(BEEP_DELAY_MS);
+        furi_hal_speaker_stop();
+        break;
+    case Vibro:
+        if(metronome_state->current_beat == 1) {
+            furi_delay_ms(BEEP_DELAY_MS);
+            notification_message(metronome_state->notifications, &sequence_reset_vibro);
+        } else {
+            furi_delay_ms((int)BEEP_DELAY_MS / 2);
+            notification_message(metronome_state->notifications, &sequence_reset_vibro);
+            furi_delay_ms((int)BEEP_DELAY_MS / 2);
+        }
+        break;
+    case Silent:
+        break;
+    }
+    notification_message(metronome_state->notifications, &sequence_reset_rgb);
+
+    release_mutex((ValueMutex*)ctx, metronome_state);
+}
+
+static uint32_t state_to_sleep_ticks(MetronomeState* metronome_state) {
+    // calculate time between beeps
+    uint32_t tps = furi_kernel_get_tick_frequency();
+    double multiplier = 4.0d / metronome_state->note_length;
+    double bps = (double)metronome_state->bpm / 60;
+    return (uint32_t)(round(tps / bps) - ((BEEP_DELAY_MS / 1000) * tps)) * multiplier;
+}
+
+static void update_timer(MetronomeState* metronome_state) {
+    if(furi_timer_is_running(metronome_state->timer)) {
+        furi_timer_stop(metronome_state->timer);
+        furi_timer_start(metronome_state->timer, state_to_sleep_ticks(metronome_state));
+    }
+}
+
+static void increase_bpm(MetronomeState* metronome_state, double amount) {
+    metronome_state->bpm += amount;
+    if(metronome_state->bpm > (double)BPM_BOUNDARY_HIGH) {
+        metronome_state->bpm = BPM_BOUNDARY_HIGH;
+    }
+    update_timer(metronome_state);
+}
+
+static void decrease_bpm(MetronomeState* metronome_state, double amount) {
+    metronome_state->bpm -= amount;
+    if(metronome_state->bpm < (double)BPM_BOUNDARY_LOW) {
+        metronome_state->bpm = BPM_BOUNDARY_LOW;
+    }
+    update_timer(metronome_state);
+}
+
+static void cycle_beats_per_bar(MetronomeState* metronome_state) {
+    metronome_state->beats_per_bar++;
+    if(metronome_state->beats_per_bar > metronome_state->note_length) {
+        metronome_state->beats_per_bar = 1;
+    }
+}
+
+static void cycle_note_length(MetronomeState* metronome_state) {
+    metronome_state->note_length *= 2;
+    if(metronome_state->note_length > 16) {
+        metronome_state->note_length = 2;
+        metronome_state->beats_per_bar = 1;
+    }
+    update_timer(metronome_state);
+}
+
+static void cycle_output_mode(MetronomeState* metronome_state) {
+    metronome_state->output_mode++;
+    if(metronome_state->output_mode > Silent) {
+        metronome_state->output_mode = Loud;
+    }
+}
+
+static void metronome_state_init(MetronomeState* const metronome_state) {
+    metronome_state->bpm = 120.0;
+    metronome_state->playing = false;
+    metronome_state->beats_per_bar = 4;
+    metronome_state->note_length = 4;
+    metronome_state->current_beat = 0;
+    metronome_state->output_mode = Loud;
+    metronome_state->notifications = furi_record_open(RECORD_NOTIFICATION);
+}
+
+int32_t metronome_app() {
+    FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(PluginEvent));
+
+    MetronomeState* metronome_state = malloc(sizeof(MetronomeState));
+    metronome_state_init(metronome_state);
+
+    ValueMutex state_mutex;
+    if(!init_mutex(&state_mutex, metronome_state, sizeof(MetronomeState))) {
+        FURI_LOG_E("Metronome", "cannot create mutex\r\n");
+        free(metronome_state);
+        return 255;
+    }
+
+    // Set system callbacks
+    ViewPort* view_port = view_port_alloc();
+    view_port_draw_callback_set(view_port, render_callback, &state_mutex);
+    view_port_input_callback_set(view_port, input_callback, event_queue);
+    metronome_state->timer = furi_timer_alloc(timer_callback, FuriTimerTypePeriodic, &state_mutex);
+
+    // Open GUI and register view_port
+    Gui* gui = furi_record_open("gui");
+    gui_add_view_port(gui, view_port, GuiLayerFullscreen);
+
+    PluginEvent event;
+    for(bool processing = true; processing;) {
+        FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
+
+        MetronomeState* metronome_state = (MetronomeState*)acquire_mutex_block(&state_mutex);
+
+        if(event_status == FuriStatusOk) {
+            if(event.type == EventTypeKey) {
+                if(event.input.type == InputTypeShort) {
+                    // push events
+                    switch(event.input.key) {
+                    case InputKeyUp:
+                        cycle_beats_per_bar(metronome_state);
+                        break;
+                    case InputKeyDown:
+                        cycle_output_mode(metronome_state);
+                        break;
+                    case InputKeyRight:
+                        increase_bpm(metronome_state, BPM_STEP_SIZE_FINE);
+                        break;
+                    case InputKeyLeft:
+                        decrease_bpm(metronome_state, BPM_STEP_SIZE_FINE);
+                        break;
+                    case InputKeyOk:
+                        metronome_state->playing = !metronome_state->playing;
+                        if(metronome_state->playing) {
+                            furi_timer_start(
+                                metronome_state->timer, state_to_sleep_ticks(metronome_state));
+                        } else {
+                            furi_timer_stop(metronome_state->timer);
+                        }
+                        break;
+                    case InputKeyBack:
+                        processing = false;
+                        break;
+                    }
+                } else if(event.input.type == InputTypeLong) {
+                    // hold events
+                    switch(event.input.key) {
+                    case InputKeyUp:
+                        cycle_note_length(metronome_state);
+                        break;
+                    case InputKeyDown:
+                        break;
+                    case InputKeyRight:
+                        increase_bpm(metronome_state, BPM_STEP_SIZE_COARSE);
+                        break;
+                    case InputKeyLeft:
+                        decrease_bpm(metronome_state, BPM_STEP_SIZE_COARSE);
+                        break;
+                    case InputKeyOk:
+                        break;
+                    case InputKeyBack:
+                        processing = false;
+                        break;
+                    }
+                } else if(event.input.type == InputTypeRepeat) {
+                    // repeat events
+                    switch(event.input.key) {
+                    case InputKeyUp:
+                        break;
+                    case InputKeyDown:
+                        break;
+                    case InputKeyRight:
+                        increase_bpm(metronome_state, BPM_STEP_SIZE_COARSE);
+                        break;
+                    case InputKeyLeft:
+                        decrease_bpm(metronome_state, BPM_STEP_SIZE_COARSE);
+                        break;
+                    case InputKeyOk:
+                        break;
+                    case InputKeyBack:
+                        processing = false;
+                        break;
+                    }
+                }
+            }
+        } else {
+            FURI_LOG_D("Metronome", "FuriMessageQueue: event timeout");
+            // event timeout
+        }
+
+        view_port_update(view_port);
+        release_mutex(&state_mutex, metronome_state);
+    }
+
+    view_port_enabled_set(view_port, false);
+    gui_remove_view_port(gui, view_port);
+    furi_record_close("gui");
+    view_port_free(view_port);
+    furi_message_queue_free(event_queue);
+    delete_mutex(&state_mutex);
+    furi_timer_free(metronome_state->timer);
+    furi_record_close(RECORD_NOTIFICATION);
+    free(metronome_state);
+
+    return 0;
+}

applications/plugins/minesweeper/LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

applications/plugins/minesweeper/README.md

@@ -0,0 +1,19 @@
+# Minesweeper
+
+[Original Link](https://github.com/panki27/minesweeper)
+
+This is a Minesweeper implementation for the Flipper Zero device.
+
+![screenshot](img/screenshot.png)
+
+## Controls
+
+- Arrow buttons to move
+- Push center button to open field
+- Hold center button to toggle flag
+
+## Compiling
+
+```
+./fbt firmware_minesweeper
+```

applications/plugins/minesweeper/application.fam

@@ -0,0 +1,12 @@
+App(
+    appid="Minesweeper",
+    name="Minesweeper",
+    apptype=FlipperAppType.EXTERNAL,
+    entry_point="minesweeper_app",
+    cdefines=["APP_MINESWEEPER"],
+    requires=["gui"],
+    stack_size=8 * 1024,
+    fap_category="Games",
+    fap_icon="minesweeper_icon.png",
+    order=35,
+)

applications/plugins/minesweeper/assets.h

@@ -0,0 +1,144 @@
+#define tile_0_width 8
+#define tile_0_height 8
+static uint8_t tile_0_bits[] = {
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+};
+#define tile_1_width 8
+#define tile_1_height 8
+static uint8_t tile_1_bits[] = {
+    0x00,
+    0x10,
+    0x18,
+    0x10,
+    0x10,
+    0x10,
+    0x10,
+    0x00,
+};
+#define tile_2_width 8
+#define tile_2_height 8
+static uint8_t tile_2_bits[] = {
+    0x00,
+    0x1C,
+    0x20,
+    0x20,
+    0x18,
+    0x04,
+    0x3C,
+    0x00,
+};
+#define tile_3_width 8
+#define tile_3_height 8
+static uint8_t tile_3_bits[] = {
+    0x00,
+    0x1C,
+    0x20,
+    0x20,
+    0x18,
+    0x20,
+    0x1C,
+    0x00,
+};
+#define tile_4_width 8
+#define tile_4_height 8
+static uint8_t tile_4_bits[] = {
+    0x00,
+    0x04,
+    0x14,
+    0x14,
+    0x3C,
+    0x10,
+    0x10,
+    0x00,
+};
+#define tile_5_width 8
+#define tile_5_height 8
+static uint8_t tile_5_bits[] = {
+    0x00,
+    0x3C,
+    0x04,
+    0x1C,
+    0x20,
+    0x20,
+    0x1C,
+    0x00,
+};
+#define tile_6_width 8
+#define tile_6_height 8
+static uint8_t tile_6_bits[] = {
+    0x00,
+    0x18,
+    0x24,
+    0x04,
+    0x1C,
+    0x24,
+    0x18,
+    0x00,
+};
+#define tile_7_width 8
+#define tile_7_height 8
+static uint8_t tile_7_bits[] = {
+    0x00,
+    0x3C,
+    0x20,
+    0x20,
+    0x10,
+    0x08,
+    0x08,
+    0x00,
+};
+#define tile_8_width 8
+#define tile_8_height 8
+static uint8_t tile_8_bits[] = {
+    0x00,
+    0x18,
+    0x24,
+    0x18,
+    0x24,
+    0x24,
+    0x18,
+    0x00,
+};
+#define tile_flag_width 8
+#define tile_flag_height 8
+static uint8_t tile_flag_bits[] = {
+    0xFF,
+    0x81,
+    0xB9,
+    0x89,
+    0x89,
+    0x9D,
+    0x81,
+    0xFF,
+};
+#define tile_mine_width 8
+#define tile_mine_height 8
+static uint8_t tile_mine_bits[] = {
+    0x55,
+    0xAA,
+    0x55,
+    0xAA,
+    0x55,
+    0xAA,
+    0x55,
+    0xAA,
+};
+#define tile_uncleared_width 8
+#define tile_uncleared_height 8
+static uint8_t tile_uncleared_bits[] = {
+    0xFF,
+    0x81,
+    0x81,
+    0x81,
+    0x81,
+    0x81,
+    0x81,
+    0xFF,
+};

applications/plugins/minesweeper/assets/asset

@@ -0,0 +1,48 @@
+#define tile_0_width 8
+#define tile_0_height 8
+static uint8_t tile_0_bits[] = {
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, };
+#define tile_1_width 8
+#define tile_1_height 8
+static uint8_t tile_1_bits[] = {
+  0x00, 0x10, 0x18, 0x10, 0x10, 0x10, 0x10, 0x00, };
+#define tile_2_width 8
+#define tile_2_height 8
+static uint8_t tile_2_bits[] = {
+  0x00, 0x1C, 0x20, 0x20, 0x18, 0x04, 0x3C, 0x00, };
+#define tile_3_width 8
+#define tile_3_height 8
+static uint8_t tile_3_bits[] = {
+  0x00, 0x1C, 0x20, 0x20, 0x18, 0x20, 0x1C, 0x00, };
+#define tile_4_width 8
+#define tile_4_height 8
+static uint8_t tile_4_bits[] = {
+  0x00, 0x04, 0x14, 0x14, 0x3C, 0x10, 0x10, 0x00, };
+#define tile_5_width 8
+#define tile_5_height 8
+static uint8_t tile_5_bits[] = {
+  0x00, 0x3C, 0x04, 0x1C, 0x20, 0x20, 0x1C, 0x00, };
+#define tile_6_width 8
+#define tile_6_height 8
+static uint8_t tile_6_bits[] = {
+  0x00, 0x18, 0x24, 0x04, 0x1C, 0x24, 0x18, 0x00, };
+#define tile_7_width 8
+#define tile_7_height 8
+static uint8_t tile_7_bits[] = {
+  0x00, 0x3C, 0x20, 0x20, 0x10, 0x08, 0x08, 0x00, };
+#define tile_8_width 8
+#define tile_8_height 8
+static uint8_t tile_8_bits[] = {
+  0x00, 0x18, 0x24, 0x18, 0x24, 0x24, 0x18, 0x00, };
+#define tile_flag_width 8
+#define tile_flag_height 8
+static uint8_t tile_flag_bits[] = {
+  0xFF, 0x81, 0xB9, 0x89, 0x89, 0x9D, 0x81, 0xFF, };
+#define tile_mine_width 8
+#define tile_mine_height 8
+static uint8_t tile_mine_bits[] = {
+  0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, };
+#define tile_uncleared_width 8
+#define tile_uncleared_height 8
+static uint8_t tile_uncleared_bits[] = {
+  0xFF, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0xFF, };

applications/plugins/minesweeper/assets/tile_0.xbm

@@ -0,0 +1,4 @@
+#define tile_0_width 8
+#define tile_0_height 8
+static char tile_0_bits[] = {
+  0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, };

applications/plugins/minesweeper/assets/tile_1.xbm

@@ -0,0 +1,4 @@
+#define tile_1_width 8
+#define tile_1_height 8
+static uint8_t tile_1_bits[] = {
+  0x00, 0x10, 0x18, 0x10, 0x10, 0x10, 0x10, 0x00, };

applications/plugins/minesweeper/assets/tile_2.xbm

@@ -0,0 +1,4 @@
+#define tile_2_width 8
+#define tile_2_height 8
+static uint8_t tile_2_bits[] = {
+  0x00, 0x1C, 0x20, 0x20, 0x18, 0x04, 0x3C, 0x00, };

applications/plugins/minesweeper/assets/tile_3.xbm

@@ -0,0 +1,4 @@
+#define tile_3_width 8
+#define tile_3_height 8
+static uint8_t tile_3_bits[] = {
+  0x00, 0x1C, 0x20, 0x20, 0x18, 0x20, 0x1C, 0x00, };

applications/plugins/minesweeper/assets/tile_4.xbm

@@ -0,0 +1,4 @@
+#define tile_4_width 8
+#define tile_4_height 8
+static uint8_t tile_4_bits[] = {
+  0x00, 0x04, 0x14, 0x14, 0x3C, 0x10, 0x10, 0x00, };

applications/plugins/minesweeper/assets/tile_5.xbm

@@ -0,0 +1,4 @@
+#define tile_5_width 8
+#define tile_5_height 8
+static uint8_t tile_5_bits[] = {
+  0x00, 0x3C, 0x04, 0x1C, 0x20, 0x20, 0x1C, 0x00, };

applications/plugins/minesweeper/assets/tile_6.xbm

@@ -0,0 +1,4 @@
+#define tile_6_width 8
+#define tile_6_height 8
+static uint8_t tile_6_bits[] = {
+  0x00, 0x18, 0x24, 0x04, 0x1C, 0x24, 0x18, 0x00, };

applications/plugins/minesweeper/assets/tile_7.xbm

@@ -0,0 +1,4 @@
+#define tile_7_width 8
+#define tile_7_height 8
+static uint8_t tile_7_bits[] = {
+  0x00, 0x3C, 0x20, 0x20, 0x10, 0x08, 0x08, 0x00, };

applications/plugins/minesweeper/assets/tile_8.xbm

@@ -0,0 +1,4 @@
+#define tile_8_width 8
+#define tile_8_height 8
+static uint8_t tile_8_bits[] = {
+  0x00, 0x18, 0x24, 0x18, 0x24, 0x24, 0x18, 0x00, };

applications/plugins/minesweeper/assets/tile_flag.xbm

@@ -0,0 +1,4 @@
+#define tile_flag_width 8
+#define tile_flag_height 8
+static uint8_t tile_flag_bits[] = {
+  0xFF, 0x81, 0xB9, 0x89, 0x89, 0x9D, 0x81, 0xFF, };

applications/plugins/minesweeper/assets/tile_mine.xbm

@@ -0,0 +1,4 @@
+#define tile_mine_width 8
+#define tile_mine_height 8
+static uint8_t tile_mine_bits[] = {
+  0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, };

applications/plugins/minesweeper/assets/tile_uncleared.xbm

@@ -0,0 +1,4 @@
+#define tile_uncleared_width 8
+#define tile_uncleared_height 8
+static uint8_t tile_uncleared_bits[] = {
+  0xFF, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0xFF, };

applications/plugins/minesweeper/minesweeper.c

@@ -0,0 +1,527 @@
+#include <furi.h>
+#include <furi_hal.h>
+#include <gui/gui.h>
+#include <input/input.h>
+#include <stdlib.h>
+
+#include <notification/notification_messages.h>
+#include <dialogs/dialogs.h>
+#include <m-string.h>
+
+#include "assets.h"
+
+#define PLAYFIELD_WIDTH 16
+#define PLAYFIELD_HEIGHT 7
+#define TILE_WIDTH 8
+#define TILE_HEIGHT 8
+
+#define MINECOUNT 20
+
+typedef enum {
+    EventTypeTick,
+    EventTypeKey,
+} EventType;
+
+typedef struct {
+    EventType type;
+    InputEvent input;
+} PluginEvent;
+
+typedef enum {
+    TileType0, // this HAS to be in order, for hint assignment to be ez pz
+    TileType1,
+    TileType2,
+    TileType3,
+    TileType4,
+    TileType5,
+    TileType6,
+    TileType7,
+    TileType8,
+    TileTypeUncleared,
+    TileTypeFlag,
+    TileTypeMine
+} TileType;
+
+typedef enum {
+    FieldEmpty, // <-- same goes for this
+    FieldMine
+} Field;
+
+typedef struct {
+    Field minefield[PLAYFIELD_WIDTH][PLAYFIELD_HEIGHT];
+    TileType playfield[PLAYFIELD_WIDTH][PLAYFIELD_HEIGHT];
+    FuriTimer* timer;
+    int cursor_x;
+    int cursor_y;
+    int mines_left;
+    int fields_cleared;
+    int flags_set;
+    bool game_started;
+    uint32_t game_started_tick;
+} Minesweeper;
+
+static void timer_callback(void* ctx) {
+    UNUSED(ctx);
+    NotificationApp* notification = furi_record_open(RECORD_NOTIFICATION);
+    notification_message(notification, &sequence_reset_vibro);
+    furi_record_close(RECORD_NOTIFICATION);
+}
+
+static void input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
+    furi_assert(event_queue);
+
+    PluginEvent event = {.type = EventTypeKey, .input = *input_event};
+    furi_message_queue_put(event_queue, &event, FuriWaitForever);
+}
+
+static void render_callback(Canvas* const canvas, void* ctx) {
+    const Minesweeper* minesweeper_state = acquire_mutex((ValueMutex*)ctx, 25);
+    if(minesweeper_state == NULL) {
+        return;
+    }
+    FuriString* mineStr;
+    FuriString* timeStr;
+    mineStr = furi_string_alloc();
+    timeStr = furi_string_alloc();
+
+    furi_string_printf(mineStr, "Mines: %d", MINECOUNT - minesweeper_state->flags_set);
+    canvas_set_font(canvas, FontSecondary);
+    canvas_draw_str_aligned(canvas, 0, 0, AlignLeft, AlignTop, furi_string_get_cstr(mineStr));
+
+    int seconds = 0;
+    int minutes = 0;
+    if(minesweeper_state->game_started) {
+        uint32_t ticks_elapsed = furi_get_tick() - minesweeper_state->game_started_tick;
+        seconds = (int)ticks_elapsed / furi_kernel_get_tick_frequency();
+        minutes = (int)seconds / 60;
+        seconds = seconds % 60;
+    }
+    furi_string_printf(timeStr, "%01d:%02d", minutes, seconds);
+    canvas_draw_str_aligned(canvas, 128, 0, AlignRight, AlignTop, furi_string_get_cstr(timeStr));
+
+    for(int y = 0; y < PLAYFIELD_HEIGHT; y++) {
+        for(int x = 0; x < PLAYFIELD_WIDTH; x++) {
+            if(x == minesweeper_state->cursor_x && y == minesweeper_state->cursor_y) {
+                canvas_invert_color(canvas);
+            }
+            switch(minesweeper_state->playfield[x][y]) {
+            case TileType0:
+                canvas_draw_xbm(
+                    canvas,
+                    x * TILE_HEIGHT, // x
+                    8 + (y * TILE_WIDTH), // y
+                    TILE_WIDTH,
+                    TILE_HEIGHT,
+                    tile_0_bits);
+                break;
+            case TileType1:
+                canvas_draw_xbm(
+                    canvas,
+                    x * TILE_HEIGHT, // x
+                    8 + (y * TILE_WIDTH), // y
+                    TILE_WIDTH,
+                    TILE_HEIGHT,
+                    tile_1_bits);
+                break;
+            case TileType2:
+                canvas_draw_xbm(
+                    canvas,
+                    x * TILE_HEIGHT, // x
+                    8 + (y * TILE_WIDTH), // y
+                    TILE_WIDTH,
+                    TILE_HEIGHT,
+                    tile_2_bits);
+                break;
+            case TileType3:
+                canvas_draw_xbm(
+                    canvas,
+                    x * TILE_HEIGHT, // x
+                    8 + (y * TILE_WIDTH), // y
+                    TILE_WIDTH,
+                    TILE_HEIGHT,
+                    tile_3_bits);
+                break;
+            case TileType4:
+                canvas_draw_xbm(
+                    canvas,
+                    x * TILE_HEIGHT, // x
+                    8 + (y * TILE_WIDTH), // y
+                    TILE_WIDTH,
+                    TILE_HEIGHT,
+                    tile_4_bits);
+                break;
+            case TileType5:
+                canvas_draw_xbm(
+                    canvas,
+                    x * TILE_HEIGHT, // x
+                    8 + (y * TILE_WIDTH), // y
+                    TILE_WIDTH,
+                    TILE_HEIGHT,
+                    tile_5_bits);
+                break;
+            case TileType6:
+                canvas_draw_xbm(
+                    canvas,
+                    x * TILE_HEIGHT, // x
+                    8 + (y * TILE_WIDTH), // y
+                    TILE_WIDTH,
+                    TILE_HEIGHT,
+                    tile_6_bits);
+                break;
+            case TileType7:
+                canvas_draw_xbm(
+                    canvas,
+                    x * TILE_HEIGHT, // x
+                    8 + (y * TILE_WIDTH), // y
+                    TILE_WIDTH,
+                    TILE_HEIGHT,
+                    tile_7_bits);
+                break;
+            case TileType8:
+                canvas_draw_xbm(
+                    canvas,
+                    x * TILE_HEIGHT, // x
+                    8 + (y * TILE_WIDTH), // y
+                    TILE_WIDTH,
+                    TILE_HEIGHT,
+                    tile_8_bits);
+                break;
+            case TileTypeFlag:
+                canvas_draw_xbm(
+                    canvas,
+                    x * TILE_HEIGHT, // x
+                    8 + (y * TILE_WIDTH), // y
+                    TILE_WIDTH,
+                    TILE_HEIGHT,
+                    tile_flag_bits);
+                break;
+            case TileTypeUncleared:
+                canvas_draw_xbm(
+                    canvas,
+                    x * TILE_HEIGHT, // x
+                    8 + (y * TILE_WIDTH), // y
+                    TILE_WIDTH,
+                    TILE_HEIGHT,
+                    tile_uncleared_bits);
+                break;
+            case TileTypeMine:
+                canvas_draw_xbm(
+                    canvas,
+                    x * TILE_HEIGHT, // x
+                    8 + (y * TILE_WIDTH), // y
+                    TILE_WIDTH,
+                    TILE_HEIGHT,
+                    tile_mine_bits);
+                break;
+            }
+            if(x == minesweeper_state->cursor_x && y == minesweeper_state->cursor_y) {
+                canvas_invert_color(canvas);
+            }
+        }
+    }
+
+    furi_string_free(mineStr);
+    furi_string_free(timeStr);
+    release_mutex((ValueMutex*)ctx, minesweeper_state);
+}
+
+static void setup_playfield(Minesweeper* minesweeper_state) {
+    int mines_left = MINECOUNT;
+    for(int y = 0; y < PLAYFIELD_HEIGHT; y++) {
+        for(int x = 0; x < PLAYFIELD_WIDTH; x++) {
+            minesweeper_state->minefield[x][y] = FieldEmpty;
+            minesweeper_state->playfield[x][y] = TileTypeUncleared;
+        }
+    }
+    while(mines_left > 0) {
+        int rand_x = rand() % PLAYFIELD_WIDTH;
+        int rand_y = rand() % PLAYFIELD_HEIGHT;
+        // make sure first guess isn't a mine
+        if(minesweeper_state->minefield[rand_x][rand_y] == FieldEmpty &&
+           (minesweeper_state->cursor_x != rand_x && minesweeper_state->cursor_y != rand_y)) {
+            minesweeper_state->minefield[rand_x][rand_y] = FieldMine;
+            mines_left--;
+        }
+    }
+    minesweeper_state->mines_left = MINECOUNT;
+    minesweeper_state->fields_cleared = 0;
+    minesweeper_state->flags_set = 0;
+    minesweeper_state->game_started_tick = furi_get_tick();
+    minesweeper_state->game_started = false;
+}
+
+static void place_flag(Minesweeper* minesweeper_state) {
+    if(minesweeper_state->playfield[minesweeper_state->cursor_x][minesweeper_state->cursor_y] ==
+       TileTypeUncleared) {
+        minesweeper_state->playfield[minesweeper_state->cursor_x][minesweeper_state->cursor_y] =
+            TileTypeFlag;
+        minesweeper_state->flags_set++;
+    } else if(
+        minesweeper_state->playfield[minesweeper_state->cursor_x][minesweeper_state->cursor_y] ==
+        TileTypeFlag) {
+        minesweeper_state->playfield[minesweeper_state->cursor_x][minesweeper_state->cursor_y] =
+            TileTypeUncleared;
+        minesweeper_state->flags_set--;
+    }
+}
+
+static bool game_lost(Minesweeper* minesweeper_state) {
+    // returns true if the player wants to restart, otherwise false
+    DialogsApp* dialogs = furi_record_open(RECORD_DIALOGS);
+
+    DialogMessage* message = dialog_message_alloc();
+    const char* header_text = "Game Over";
+    const char* message_text = "You hit a mine!";
+
+    dialog_message_set_header(message, header_text, 64, 3, AlignCenter, AlignTop);
+    dialog_message_set_text(message, message_text, 64, 32, AlignCenter, AlignCenter);
+    dialog_message_set_buttons(message, NULL, "Play again", NULL);
+
+    dialog_message_set_icon(message, NULL, 0, 10);
+
+    NotificationApp* notifications = furi_record_open(RECORD_NOTIFICATION);
+    notification_message(notifications, &sequence_set_vibro_on);
+    furi_record_close(RECORD_NOTIFICATION);
+    furi_timer_start(minesweeper_state->timer, (uint32_t)furi_kernel_get_tick_frequency() * 0.2);
+
+    DialogMessageButton choice = dialog_message_show(dialogs, message);
+    dialog_message_free(message);
+    furi_record_close(RECORD_DIALOGS);
+
+    return choice == DialogMessageButtonCenter;
+}
+
+static bool game_won(Minesweeper* minesweeper_state) {
+    DialogsApp* dialogs = furi_record_open(RECORD_DIALOGS);
+
+    FuriString* tempStr;
+    tempStr = furi_string_alloc();
+
+    int seconds = 0;
+    int minutes = 0;
+    uint32_t ticks_elapsed = furi_get_tick() - minesweeper_state->game_started_tick;
+    seconds = (int)ticks_elapsed / furi_kernel_get_tick_frequency();
+    minutes = (int)seconds / 60;
+    seconds = seconds % 60;
+
+    DialogMessage* message = dialog_message_alloc();
+    const char* header_text = "Game won!";
+    furi_string_cat_printf(tempStr, "Minefield cleared in %01d:%02d", minutes, seconds);
+    dialog_message_set_header(message, header_text, 64, 3, AlignCenter, AlignTop);
+    dialog_message_set_text(
+        message, furi_string_get_cstr(tempStr), 64, 32, AlignCenter, AlignCenter);
+    dialog_message_set_buttons(message, NULL, "Play again", NULL);
+    // TODO: create icon
+    dialog_message_set_icon(message, NULL, 72, 17);
+
+    DialogMessageButton choice = dialog_message_show(dialogs, message);
+    dialog_message_free(message);
+    furi_string_free(tempStr);
+    furi_record_close(RECORD_DIALOGS);
+    return choice == DialogMessageButtonCenter;
+}
+
+static bool play_move(Minesweeper* minesweeper_state, int cursor_x, int cursor_y) {
+    if(minesweeper_state->playfield[cursor_x][cursor_y] != TileTypeUncleared) {
+        // we're on an already uncovered field
+        return true;
+    }
+    if(minesweeper_state->minefield[cursor_x][cursor_y] == FieldMine) {
+        // TODO: player loses!
+        minesweeper_state->playfield[cursor_x][cursor_y] = TileTypeMine;
+        return false;
+    } else {
+        // get number of surrounding mines.
+        int hint = 0;
+        for(int y = cursor_y - 1; y <= cursor_y + 1; y++) {
+            for(int x = cursor_x - 1; x <= cursor_x + 1; x++) {
+                if(x == cursor_x && y == cursor_y) {
+                    // we're on the cell the user selected, so ignore.
+                    continue;
+                }
+                // make sure we don't go OOB
+                if(x >= 0 && x < PLAYFIELD_WIDTH && y >= 0 && y < PLAYFIELD_HEIGHT) {
+                    if(minesweeper_state->minefield[x][y] == FieldMine) {
+                        hint++;
+                    }
+                }
+            }
+        }
+        // 〜(￣▽￣〜) don't judge me (〜￣▽￣)〜
+        minesweeper_state->playfield[cursor_x][cursor_y] = hint;
+        minesweeper_state->fields_cleared++;
+        FURI_LOG_D("Minesweeper", "Setting %d,%d to %d", cursor_x, cursor_y, hint);
+        if(hint == 0) {
+            // auto open surrounding fields.
+            for(int auto_y = cursor_y - 1; auto_y <= cursor_y + 1; auto_y++) {
+                for(int auto_x = cursor_x - 1; auto_x <= cursor_x + 1; auto_x++) {
+                    if(auto_x == cursor_x && auto_y == cursor_y) {
+                        continue;
+                    }
+                    if(auto_x >= 0 && auto_x < PLAYFIELD_WIDTH && auto_y >= 0 &&
+                       auto_y < PLAYFIELD_HEIGHT) {
+                        if(minesweeper_state->playfield[auto_x][auto_y] == TileTypeUncleared) {
+                            play_move(minesweeper_state, auto_x, auto_y);
+                        }
+                    }
+                }
+            }
+        }
+        return true;
+    }
+}
+
+static void minesweeper_state_init(Minesweeper* const minesweeper_state) {
+    minesweeper_state->cursor_x = minesweeper_state->cursor_y = 0;
+    minesweeper_state->game_started = false;
+    for(int y = 0; y < PLAYFIELD_HEIGHT; y++) {
+        for(int x = 0; x < PLAYFIELD_WIDTH; x++) {
+            minesweeper_state->playfield[x][y] = TileTypeUncleared;
+        }
+    }
+}
+
+int32_t minesweeper_app(void* p) {
+    UNUSED(p);
+    DialogsApp* dialogs = furi_record_open(RECORD_DIALOGS);
+
+    DialogMessage* message = dialog_message_alloc();
+    const char* header_text = "Minesweeper";
+    const char* message_text = "Hold OK pressed to toggle flags.\ngithub.com/panki27";
+
+    dialog_message_set_header(message, header_text, 64, 3, AlignCenter, AlignTop);
+    dialog_message_set_text(message, message_text, 64, 32, AlignCenter, AlignCenter);
+    dialog_message_set_buttons(message, NULL, "Play", NULL);
+
+    dialog_message_set_icon(message, NULL, 0, 10);
+
+    dialog_message_show(dialogs, message);
+    dialog_message_free(message);
+    furi_record_close(RECORD_DIALOGS);
+
+    FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(PluginEvent));
+
+    Minesweeper* minesweeper_state = malloc(sizeof(Minesweeper));
+    // setup
+    minesweeper_state_init(minesweeper_state);
+
+    ValueMutex state_mutex;
+    if(!init_mutex(&state_mutex, minesweeper_state, sizeof(minesweeper_state))) {
+        FURI_LOG_E("Minesweeper", "cannot create mutex\r\n");
+        free(minesweeper_state);
+        return 255;
+    }
+    // BEGIN IMPLEMENTATION
+
+    // Set system callbacks
+    ViewPort* view_port = view_port_alloc();
+    view_port_draw_callback_set(view_port, render_callback, &state_mutex);
+    view_port_input_callback_set(view_port, input_callback, event_queue);
+    minesweeper_state->timer = furi_timer_alloc(timer_callback, FuriTimerTypeOnce, &state_mutex);
+
+    // Open GUI and register view_port
+    Gui* gui = furi_record_open("gui");
+    gui_add_view_port(gui, view_port, GuiLayerFullscreen);
+
+    PluginEvent event;
+    for(bool processing = true; processing;) {
+        FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
+        Minesweeper* minesweeper_state = (Minesweeper*)acquire_mutex_block(&state_mutex);
+        if(event_status == FuriStatusOk) {
+            // press events
+            if(event.type == EventTypeKey) {
+                if(event.input.type == InputTypeShort) {
+                    switch(event.input.key) {
+                    case InputKeyUp:
+                        minesweeper_state->cursor_y--;
+                        if(minesweeper_state->cursor_y < 0) {
+                            minesweeper_state->cursor_y = 0;
+                        }
+                        break;
+                    case InputKeyDown:
+                        minesweeper_state->cursor_y++;
+                        if(minesweeper_state->cursor_y >= PLAYFIELD_HEIGHT) {
+                            minesweeper_state->cursor_y = PLAYFIELD_HEIGHT - 1;
+                        }
+                        break;
+                    case InputKeyRight:
+                        minesweeper_state->cursor_x++;
+                        if(minesweeper_state->cursor_x >= PLAYFIELD_WIDTH) {
+                            minesweeper_state->cursor_x = PLAYFIELD_WIDTH - 1;
+                        }
+                        break;
+                    case InputKeyLeft:
+                        minesweeper_state->cursor_x--;
+                        if(minesweeper_state->cursor_x < 0) {
+                            minesweeper_state->cursor_x = 0;
+                        }
+                        break;
+                    case InputKeyOk:
+                        if(!minesweeper_state->game_started) {
+                            setup_playfield(minesweeper_state);
+                            minesweeper_state->game_started = true;
+                        }
+                        if(!play_move(
+                               minesweeper_state,
+                               minesweeper_state->cursor_x,
+                               minesweeper_state->cursor_y)) {
+                            // ooops. looks like we hit a mine!
+                            if(game_lost(minesweeper_state)) {
+                                // player wants to restart.
+                                setup_playfield(minesweeper_state);
+                            } else {
+                                // player wants to exit :(
+                                processing = false;
+                            }
+                        } else {
+                            // check win condition.
+                            if(minesweeper_state->fields_cleared ==
+                               (PLAYFIELD_HEIGHT * PLAYFIELD_WIDTH) - MINECOUNT) {
+                                if(game_won(minesweeper_state)) {
+                                    //player wants to restart
+                                    setup_playfield(minesweeper_state);
+                                } else {
+                                    processing = false;
+                                }
+                            }
+                        }
+                        break;
+                    case InputKeyBack:
+                        // Exit the plugin
+                        processing = false;
+                        break;
+                    }
+                } else if(event.input.type == InputTypeLong) {
+                    // hold events
+                    FURI_LOG_D("Minesweeper", "Got a long press!");
+                    switch(event.input.key) {
+                    case InputKeyUp:
+                    case InputKeyDown:
+                    case InputKeyRight:
+                    case InputKeyLeft:
+                        break;
+                    case InputKeyOk:
+                        FURI_LOG_D("Minesweeper", "Toggling flag");
+                        place_flag(minesweeper_state);
+                        break;
+                    case InputKeyBack:
+                        processing = false;
+                        break;
+                    }
+                }
+            }
+        }
+        view_port_update(view_port);
+        release_mutex(&state_mutex, minesweeper_state);
+    }
+    view_port_enabled_set(view_port, false);
+    gui_remove_view_port(gui, view_port);
+    furi_record_close("gui");
+    view_port_free(view_port);
+    furi_message_queue_free(event_queue);
+    delete_mutex(&state_mutex);
+    furi_timer_free(minesweeper_state->timer);
+    free(minesweeper_state);
+
+    return 0;
+}

applications/plugins/subbrute/scenes/subbrute_scene_run_attack.c

@@ -72,7 +72,6 @@ bool subbrute_scene_run_attack_on_event(void* context, SceneManagerEvent event)
             notification_message(instance->notifications, &sequence_display_backlight_on);
             notification_message(instance->notifications, &sequence_double_vibro);
 
-
             scene_manager_next_scene(instance->scene_manager, SubBruteSceneSetupAttack);
         } else if(
             event.event == SubBruteCustomEventTypeTransmitNotStarted ||

applications/plugins/subbrute/scenes/subbrute_scene_save_name.c

@@ -47,9 +47,14 @@ bool subbrute_scene_save_name_on_event(void* context, SceneManagerEvent event) {
         if(strcmp(instance->text_store, "")) {
             furi_string_reset(instance->file_path);
             furi_string_cat_printf(
-                instance->file_path, "%s/%s%s", SUBBRUTE_PATH, instance->text_store, SUBBRUTE_FILE_EXT);
+                instance->file_path,
+                "%s/%s%s",
+                SUBBRUTE_PATH,
+                instance->text_store,
+                SUBBRUTE_FILE_EXT);
 
-            if(subbrute_device_save_file(instance->device, furi_string_get_cstr(instance->file_path))) {
+            if(subbrute_device_save_file(
+                   instance->device, furi_string_get_cstr(instance->file_path))) {
                 scene_manager_next_scene(instance->scene_manager, SubBruteSceneSaveSuccess);
                 success = true;
                 consumed = true;

applications/plugins/totp/.clang-format

@@ -0,0 +1,191 @@
+---
+Language:        Cpp
+AccessModifierOffset: -4
+AlignAfterOpenBracket: AlwaysBreak
+AlignArrayOfStructures: None
+AlignConsecutiveMacros: None
+AlignConsecutiveAssignments: None
+AlignConsecutiveBitFields: None
+AlignConsecutiveDeclarations: None
+AlignEscapedNewlines: Left
+AlignOperands:   Align
+AlignTrailingComments: false
+AllowAllArgumentsOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortEnumsOnASingleLine: true
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: None
+AllowShortLambdasOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: WithoutElse
+AllowShortLoopsOnASingleLine: true
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: Yes
+AttributeMacros:
+  - __capability
+BinPackArguments: false
+BinPackParameters: false
+BraceWrapping:
+  AfterCaseLabel:  false
+  AfterClass:      false
+  AfterControlStatement: Never
+  AfterEnum:       false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  AfterExternBlock: false
+  BeforeCatch:     false
+  BeforeElse:      false
+  BeforeLambdaBody: false
+  BeforeWhile:     false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: None
+BreakBeforeConceptDeclarations: true
+BreakBeforeBraces: Attach
+BreakBeforeInheritanceComma: false
+BreakInheritanceList: BeforeColon
+BreakBeforeTernaryOperators: false
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeComma
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: false
+ColumnLimit:     99
+CommentPragmas:  '^ IWYU pragma:'
+QualifierAlignment: Leave
+CompactNamespaces: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DeriveLineEnding: true
+DerivePointerAlignment: false
+DisableFormat:   false
+EmptyLineAfterAccessModifier: Never
+EmptyLineBeforeAccessModifier: LogicalBlock
+ExperimentalAutoDetectBinPacking: false
+PackConstructorInitializers: BinPack
+BasedOnStyle:    ''
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+AllowAllConstructorInitializersOnNextLine: true
+FixNamespaceComments: false
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IfMacros:
+  - KJ_IF_MAYBE
+IncludeBlocks:   Preserve
+IncludeCategories:
+  - Regex:           '.*'
+    Priority:        1
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
+    Priority:        3
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '.*'
+    Priority:        1
+    SortPriority:    0
+    CaseSensitive:   false
+IncludeIsMainRegex: '(Test)?$'
+IncludeIsMainSourceRegex: ''
+IndentAccessModifiers: false
+IndentCaseLabels: false
+IndentCaseBlocks: false
+IndentGotoLabels: true
+IndentPPDirectives: None
+IndentExternBlock: AfterExternBlock
+IndentRequires:  false
+IndentWidth:     4
+IndentWrappedFunctionNames: true
+InsertTrailingCommas: None
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: false
+LambdaBodyIndentation: Signature
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Auto
+ObjCBlockIndentWidth: 4
+ObjCBreakBeforeNestedBlockParam: true
+ObjCSpaceAfterProperty: true
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 10
+PenaltyBreakBeforeFirstCallParameter: 30
+PenaltyBreakComment: 10
+PenaltyBreakFirstLessLess: 0
+PenaltyBreakOpenParenthesis: 0
+PenaltyBreakString: 10
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 100
+PenaltyReturnTypeOnItsOwnLine: 60
+PenaltyIndentedWhitespace: 0
+PointerAlignment: Left
+PPIndentWidth:   -1
+ReferenceAlignment: Pointer
+ReflowComments:  false
+RemoveBracesLLVM: false
+SeparateDefinitionBlocks: Leave
+ShortNamespaceLines: 1
+SortIncludes:    Never
+SortJavaStaticImport: Before
+SortUsingDeclarations: false
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: Never
+SpaceBeforeParensOptions:
+  AfterControlStatements: false
+  AfterForeachMacros: false
+  AfterFunctionDefinitionName: false
+  AfterFunctionDeclarationName: false
+  AfterIfMacros:   false
+  AfterOverloadedOperator: false
+  BeforeNonEmptyParentheses: false
+SpaceAroundPointerQualifiers: Default
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyBlock: false
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  Never
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: false
+SpacesInCStyleCastParentheses: false
+SpacesInLineCommentPrefix:
+  Minimum:         1
+  Maximum:         -1
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+SpaceBeforeSquareBrackets: false
+BitFieldColonSpacing: Both
+Standard:        c++03
+StatementAttributeLikeMacros:
+  - Q_EMIT
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TabWidth:        4
+UseCRLF:         false
+UseTab:          Never
+WhitespaceSensitiveMacros:
+  - STRINGIZE
+  - PP_STRINGIZE
+  - BOOST_PP_STRINGIZE
+  - NS_SWIFT_NAME
+  - CF_SWIFT_NAME
+...
+

applications/plugins/totp/application.fam

@@ -0,0 +1,19 @@
+App(
+    appid="totp",
+    name="Authenticator",
+    apptype=FlipperAppType.EXTERNAL,
+    entry_point="totp_app",
+    cdefines=["APP_TOTP"],
+    requires=[
+        "gui",
+        "cli",
+        "dialogs",
+        "storage",
+        "input", 
+        "notification"
+    ],
+    stack_size=2 * 1024,
+    order=20,
+    fap_category="Misc",
+    fap_icon="totp_10px.png"
+)

applications/plugins/totp/scenes/add_new_token/totp_input_text.c

@@ -0,0 +1,75 @@
+#include "totp_input_text.h"
+#include <gui/view_i.h>
+#include "../../types/common.h"
+
+void view_draw(View* view, Canvas* canvas) {
+    furi_assert(view);
+    if(view->draw_callback) {
+        void* data = view_get_model(view);
+        view->draw_callback(canvas, data);
+        view_unlock_model(view);
+    }
+}
+
+bool view_input(View* view, InputEvent* event) {
+    furi_assert(view);
+    if(view->input_callback) {
+        return view->input_callback(event, view->context);
+    } else {
+        return false;
+    }
+}
+
+void view_unlock_model(View* view) {
+    furi_assert(view);
+    if(view->model_type == ViewModelTypeLocking) {
+        ViewModelLocking* model = (ViewModelLocking*)(view->model);
+        furi_check(furi_mutex_release(model->mutex) == FuriStatusOk);
+    }
+}
+
+static void commit_text_input_callback(void* context) {
+    InputTextSceneState* text_input_state = (InputTextSceneState*)context;
+    if(text_input_state->callback != 0) {
+        InputTextSceneCallbackResult* result = malloc(sizeof(InputTextSceneCallbackResult));
+        result->user_input_length = strlen(text_input_state->text_input_buffer);
+        result->user_input = malloc(result->user_input_length + 1);
+        result->callback_data = text_input_state->callback_data;
+        strcpy(result->user_input, text_input_state->text_input_buffer);
+        text_input_state->callback(result);
+    }
+}
+
+InputTextSceneState* totp_input_text_activate(InputTextSceneContext* context) {
+    InputTextSceneState* text_input_state = malloc(sizeof(InputTextSceneState));
+    text_input_state->text_input = text_input_alloc();
+    text_input_state->text_input_view = text_input_get_view(text_input_state->text_input);
+    text_input_state->callback = context->callback;
+    text_input_state->callback_data = context->callback_data;
+    text_input_set_header_text(text_input_state->text_input, context->header_text);
+    text_input_set_result_callback(
+        text_input_state->text_input,
+        commit_text_input_callback,
+        text_input_state,
+        &text_input_state->text_input_buffer[0],
+        INPUT_BUFFER_SIZE,
+        true);
+    return text_input_state;
+}
+
+void totp_input_text_render(Canvas* const canvas, InputTextSceneState* text_input_state) {
+    view_draw(text_input_state->text_input_view, canvas);
+}
+
+bool totp_input_text_handle_event(PluginEvent* const event, InputTextSceneState* text_input_state) {
+    if(event->type == EventTypeKey) {
+        view_input(text_input_state->text_input_view, &event->input);
+    }
+
+    return true;
+}
+
+void totp_input_text_free(InputTextSceneState* state) {
+    text_input_free(state->text_input);
+    free(state);
+}

applications/plugins/totp/scenes/add_new_token/totp_input_text.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <gui/gui.h>
+#include <gui/view.h>
+#include <gui/modules/text_input.h>
+#include <furi.h>
+#include <furi_hal.h>
+#include "../../types/plugin_state.h"
+#include "../../types/plugin_event.h"
+
+typedef struct {
+    char* user_input;
+    uint8_t user_input_length;
+    void* callback_data;
+} InputTextSceneCallbackResult;
+
+typedef void (*InputTextSceneCallback)(InputTextSceneCallbackResult* result);
+
+typedef struct {
+    InputTextSceneCallback callback;
+    char* header_text;
+    void* callback_data;
+} InputTextSceneContext;
+
+#define INPUT_BUFFER_SIZE 255
+
+typedef struct {
+    TextInput* text_input;
+    View* text_input_view;
+    char text_input_buffer[INPUT_BUFFER_SIZE];
+    InputTextSceneCallback callback;
+    void* callback_data;
+} InputTextSceneState;
+
+InputTextSceneState* totp_input_text_activate(InputTextSceneContext* context);
+void totp_input_text_render(Canvas* const canvas, InputTextSceneState* text_input_state);
+bool totp_input_text_handle_event(PluginEvent* const event, InputTextSceneState* text_input_state);
+void totp_input_text_free(InputTextSceneState* state);

applications/plugins/totp/scenes/add_new_token/totp_scene_add_new_token.c

@@ -0,0 +1,300 @@
+#include "totp_scene_add_new_token.h"
+#include "../../types/common.h"
+#include "../../services/ui/constants.h"
+#include "../scene_director.h"
+#include "totp_input_text.h"
+#include "../../types/token_info.h"
+#include "../../services/list/list.h"
+#include "../../services/base32/base32.h"
+#include "../../services/config/config.h"
+#include "../../services/ui/ui_controls.h"
+#include "../generate_token/totp_scene_generate_token.h"
+
+#define TOKEN_ALGO_LIST_LENGTH 3
+char* TOKEN_ALGO_LIST[] = {"SHA1", "SHA256", "SHA512"};
+#define TOKEN_DIGITS_LIST_LENGTH 2
+char* TOKEN_DIGITS_LIST[] = {"6 digits", "8 digits"};
+
+typedef enum {
+    TokenNameTextBox,
+    TokenSecretTextBox,
+    TokenAlgoSelect,
+    TokenLengthSelect,
+    ConfirmButton,
+} Control;
+
+typedef struct {
+    char* token_name;
+    uint8_t token_name_length;
+    char* token_secret;
+    uint8_t token_secret_length;
+    bool saved;
+    Control selected_control;
+    InputTextSceneContext* token_name_input_context;
+    InputTextSceneContext* token_secret_input_context;
+    InputTextSceneState* input_state;
+    uint32_t input_started_at;
+    int current_token_index;
+    int32_t screen_y_offset;
+    TokenHashAlgo algo;
+    TokenDigitsCount digits_count;
+} SceneState;
+
+void totp_scene_add_new_token_init(PluginState* plugin_state) {
+    UNUSED(plugin_state);
+}
+
+static void on_token_name_user_comitted(InputTextSceneCallbackResult* result) {
+    SceneState* scene_state = result->callback_data;
+    free(scene_state->token_name);
+    scene_state->token_name = result->user_input;
+    scene_state->token_name_length = result->user_input_length;
+    scene_state->input_started_at = 0;
+    free(result);
+}
+
+static void on_token_secret_user_comitted(InputTextSceneCallbackResult* result) {
+    SceneState* scene_state = result->callback_data;
+    free(scene_state->token_secret);
+    scene_state->token_secret = result->user_input;
+    scene_state->token_secret_length = result->user_input_length;
+    scene_state->input_started_at = 0;
+    free(result);
+}
+
+void totp_scene_add_new_token_activate(
+    PluginState* plugin_state,
+    const TokenAddEditSceneContext* context) {
+    SceneState* scene_state = malloc(sizeof(SceneState));
+    plugin_state->current_scene_state = scene_state;
+    scene_state->token_name = "Name";
+    scene_state->token_name_length = strlen(scene_state->token_name);
+    scene_state->token_secret = "Secret";
+    scene_state->token_secret_length = strlen(scene_state->token_secret);
+
+    scene_state->token_name_input_context = malloc(sizeof(InputTextSceneContext));
+    scene_state->token_name_input_context->header_text = "Enter token name";
+    scene_state->token_name_input_context->callback_data = scene_state;
+    scene_state->token_name_input_context->callback = on_token_name_user_comitted;
+
+    scene_state->token_secret_input_context = malloc(sizeof(InputTextSceneContext));
+    scene_state->token_secret_input_context->header_text = "Enter token secret";
+    scene_state->token_secret_input_context->callback_data = scene_state;
+    scene_state->token_secret_input_context->callback = on_token_secret_user_comitted;
+
+    scene_state->screen_y_offset = 0;
+
+    scene_state->input_state = NULL;
+
+    if(context == NULL) {
+        scene_state->current_token_index = -1;
+    } else {
+        scene_state->current_token_index = context->current_token_index;
+    }
+}
+
+void totp_scene_add_new_token_render(Canvas* const canvas, PluginState* plugin_state) {
+    SceneState* scene_state = (SceneState*)plugin_state->current_scene_state;
+    if(scene_state->input_started_at > 0) {
+        totp_input_text_render(canvas, scene_state->input_state);
+        return;
+    }
+
+    ui_control_text_box_render(
+        canvas,
+        10 - scene_state->screen_y_offset,
+        scene_state->token_name,
+        scene_state->selected_control == TokenNameTextBox);
+    ui_control_text_box_render(
+        canvas,
+        27 - scene_state->screen_y_offset,
+        scene_state->token_secret,
+        scene_state->selected_control == TokenSecretTextBox);
+    ui_control_select_render(
+        canvas,
+        44 - scene_state->screen_y_offset,
+        TOKEN_ALGO_LIST[scene_state->algo],
+        scene_state->selected_control == TokenAlgoSelect);
+    ui_control_select_render(
+        canvas,
+        63 - scene_state->screen_y_offset,
+        TOKEN_DIGITS_LIST[scene_state->digits_count],
+        scene_state->selected_control == TokenLengthSelect);
+    ui_control_button_render(
+        canvas,
+        SCREEN_WIDTH_CENTER - 24,
+        85 - scene_state->screen_y_offset,
+        48,
+        13,
+        "Confirm",
+        scene_state->selected_control == ConfirmButton);
+
+    canvas_set_color(canvas, ColorWhite);
+    canvas_draw_box(canvas, 0, 0, SCREEN_WIDTH, 10);
+    canvas_set_color(canvas, ColorBlack);
+    canvas_set_font(canvas, FontPrimary);
+    canvas_draw_str_aligned(canvas, 0, 0, AlignLeft, AlignTop, "Add new token");
+    canvas_set_font(canvas, FontSecondary);
+}
+
+void update_screen_y_offset(SceneState* scene_state) {
+    if(scene_state->selected_control > TokenAlgoSelect) {
+        scene_state->screen_y_offset = 35;
+    } else {
+        scene_state->screen_y_offset = 0;
+    }
+}
+
+bool totp_scene_add_new_token_handle_event(PluginEvent* const event, PluginState* plugin_state) {
+    if(event->type == EventTypeKey) {
+        SceneState* scene_state = (SceneState*)plugin_state->current_scene_state;
+        if(scene_state->input_started_at > 0 &&
+           furi_get_tick() - scene_state->input_started_at > 300) {
+            return totp_input_text_handle_event(event, scene_state->input_state);
+        }
+
+        if(event->input.type == InputTypeLong && event->input.key == InputKeyBack) {
+            return false;
+        } else if(event->input.type == InputTypePress) {
+            switch(event->input.key) {
+            case InputKeyUp:
+                if(scene_state->selected_control > TokenNameTextBox) {
+                    scene_state->selected_control--;
+                    update_screen_y_offset(scene_state);
+                }
+                break;
+            case InputKeyDown:
+                if(scene_state->selected_control < ConfirmButton) {
+                    scene_state->selected_control++;
+                    update_screen_y_offset(scene_state);
+                }
+                break;
+            case InputKeyRight:
+                if(scene_state->selected_control == TokenAlgoSelect) {
+                    if(scene_state->algo < SHA512) {
+                        scene_state->algo++;
+                    } else {
+                        scene_state->algo = SHA1;
+                    }
+                } else if(scene_state->selected_control == TokenLengthSelect) {
+                    if(scene_state->digits_count < TOTP_8_DIGITS) {
+                        scene_state->digits_count++;
+                    } else {
+                        scene_state->digits_count = TOTP_6_DIGITS;
+                    }
+                }
+                break;
+            case InputKeyLeft:
+                if(scene_state->selected_control == TokenAlgoSelect) {
+                    if(scene_state->algo > SHA1) {
+                        scene_state->algo--;
+                    } else {
+                        scene_state->algo = SHA512;
+                    }
+                } else if(scene_state->selected_control == TokenLengthSelect) {
+                    if(scene_state->digits_count > TOTP_6_DIGITS) {
+                        scene_state->digits_count--;
+                    } else {
+                        scene_state->digits_count = TOTP_8_DIGITS;
+                    }
+                }
+                break;
+            case InputKeyOk:
+                switch(scene_state->selected_control) {
+                case TokenNameTextBox:
+                    if(scene_state->input_state != NULL) {
+                        totp_input_text_free(scene_state->input_state);
+                    }
+                    scene_state->input_state =
+                        totp_input_text_activate(scene_state->token_name_input_context);
+                    scene_state->input_started_at = furi_get_tick();
+                    break;
+                case TokenSecretTextBox:
+                    if(scene_state->input_state != NULL) {
+                        totp_input_text_free(scene_state->input_state);
+                    }
+                    scene_state->input_state =
+                        totp_input_text_activate(scene_state->token_secret_input_context);
+                    scene_state->input_started_at = furi_get_tick();
+                    break;
+                case TokenAlgoSelect:
+                    break;
+                case TokenLengthSelect:
+                    break;
+                case ConfirmButton: {
+                    TokenInfo* tokenInfo = token_info_alloc();
+                    tokenInfo->name = malloc(scene_state->token_name_length + 1);
+                    strcpy(tokenInfo->name, scene_state->token_name);
+
+                    token_info_set_secret(
+                        tokenInfo,
+                        scene_state->token_secret,
+                        scene_state->token_secret_length,
+                        &plugin_state->iv[0]);
+
+                    tokenInfo->algo = scene_state->algo;
+                    tokenInfo->digits = scene_state->digits_count;
+
+                    if(plugin_state->tokens_list == NULL) {
+                        plugin_state->tokens_list = list_init_head(tokenInfo);
+                    } else {
+                        list_add(plugin_state->tokens_list, tokenInfo);
+                    }
+                    plugin_state->tokens_count++;
+
+                    Storage* cfg_storage = totp_open_storage();
+                    FlipperFormat* cfg_file = totp_open_config_file(cfg_storage);
+
+                    flipper_format_seek_to_end(cfg_file);
+                    totp_config_file_save_new_token(cfg_file, tokenInfo);
+
+                    totp_close_config_file(cfg_file);
+                    totp_close_storage();
+
+                    GenerateTokenSceneContext generate_scene_context = {
+                        .current_token_index = plugin_state->tokens_count - 1};
+                    totp_scene_director_activate_scene(
+                        plugin_state, TotpSceneGenerateToken, &generate_scene_context);
+                    break;
+                }
+                }
+                break;
+            case InputKeyBack:
+                if(scene_state->current_token_index >= 0) {
+                    GenerateTokenSceneContext generate_scene_context = {
+                        .current_token_index = scene_state->current_token_index};
+                    totp_scene_director_activate_scene(
+                        plugin_state, TotpSceneGenerateToken, &generate_scene_context);
+                } else {
+                    totp_scene_director_activate_scene(plugin_state, TotpSceneGenerateToken, NULL);
+                }
+                break;
+            }
+        }
+    }
+    return true;
+}
+
+void totp_scene_add_new_token_deactivate(PluginState* plugin_state) {
+    if(plugin_state->current_scene_state == NULL) return;
+    SceneState* scene_state = (SceneState*)plugin_state->current_scene_state;
+    free(scene_state->token_name);
+    free(scene_state->token_secret);
+
+    free(scene_state->token_name_input_context->header_text);
+    free(scene_state->token_name_input_context);
+
+    free(scene_state->token_secret_input_context->header_text);
+    free(scene_state->token_secret_input_context);
+
+    if(scene_state->input_state != NULL) {
+        totp_input_text_free(scene_state->input_state);
+    }
+
+    free(plugin_state->current_scene_state);
+    plugin_state->current_scene_state = NULL;
+}
+
+void totp_scene_add_new_token_free(PluginState* plugin_state) {
+    UNUSED(plugin_state);
+}

applications/plugins/totp/scenes/add_new_token/totp_scene_add_new_token.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <gui/gui.h>
+#include <furi.h>
+#include <furi_hal.h>
+#include "../../types/plugin_state.h"
+#include "../../types/plugin_event.h"
+
+typedef struct {
+    uint8_t current_token_index;
+} TokenAddEditSceneContext;
+
+void totp_scene_add_new_token_init(PluginState* plugin_state);
+void totp_scene_add_new_token_activate(
+    PluginState* plugin_state,
+    const TokenAddEditSceneContext* context);
+void totp_scene_add_new_token_render(Canvas* const canvas, PluginState* plugin_state);
+bool totp_scene_add_new_token_handle_event(PluginEvent* const event, PluginState* plugin_state);
+void totp_scene_add_new_token_deactivate(PluginState* plugin_state);
+void totp_scene_add_new_token_free(PluginState* plugin_state);

applications/plugins/totp/scenes/authenticate/totp_scene_authenticate.c

@@ -0,0 +1,203 @@
+#include "totp_scene_authenticate.h"
+#include <dialogs/dialogs.h>
+#include "../../types/common.h"
+#include "../../services/ui/icons.h"
+#include "../../services/ui/constants.h"
+#include "../../services/config/config.h"
+#include "../scene_director.h"
+#include "../totp_scenes_enum.h"
+
+#define MAX_CODE_LENGTH TOTP_IV_SIZE
+#define CRYPTO_VERIFY_KEY "FFF_Crypto_pass"
+#define CRYPTO_VERIFY_KEY_LENGTH 16
+
+typedef struct {
+    uint8_t code_input[MAX_CODE_LENGTH];
+    uint8_t code_length;
+} SceneState;
+
+void totp_scene_authenticate_init(PluginState* plugin_state) {
+    memset(&plugin_state->iv[0], 0, TOTP_IV_SIZE);
+}
+
+void totp_scene_authenticate_activate(PluginState* plugin_state) {
+    SceneState* scene_state = malloc(sizeof(SceneState));
+    scene_state->code_length = 0;
+    memset(&scene_state->code_input[0], 0, MAX_CODE_LENGTH);
+    plugin_state->current_scene_state = scene_state;
+}
+
+void totp_scene_authenticate_render(Canvas* const canvas, PluginState* plugin_state) {
+    SceneState* scene_state = (SceneState*)plugin_state->current_scene_state;
+
+    int v_shift = 0;
+    if(scene_state->code_length > 0) {
+        v_shift = -10;
+    }
+
+    if(plugin_state->crypto_verify_data == NULL) {
+        canvas_draw_str_aligned(
+            canvas,
+            SCREEN_WIDTH_CENTER,
+            SCREEN_HEIGHT_CENTER - 10 + v_shift,
+            AlignCenter,
+            AlignCenter,
+            "Use arrow keys");
+        canvas_draw_str_aligned(
+            canvas,
+            SCREEN_WIDTH_CENTER,
+            SCREEN_HEIGHT_CENTER + 5 + v_shift,
+            AlignCenter,
+            AlignCenter,
+            "to setup new PIN");
+    } else {
+        canvas_draw_str_aligned(
+            canvas,
+            SCREEN_WIDTH_CENTER,
+            SCREEN_HEIGHT_CENTER + v_shift,
+            AlignCenter,
+            AlignCenter,
+            "Use arrow keys to enter PIN");
+    }
+    const uint8_t PIN_ASTERISK_RADIUS = 3;
+    const uint8_t PIN_ASTERISK_STEP = (PIN_ASTERISK_RADIUS << 1) + 2;
+    if(scene_state->code_length > 0) {
+        uint8_t left_start_x = (scene_state->code_length - 1) * PIN_ASTERISK_STEP >> 1;
+        for(uint8_t i = 0; i < scene_state->code_length; i++) {
+            canvas_draw_disc(
+                canvas,
+                SCREEN_WIDTH_CENTER - left_start_x + i * PIN_ASTERISK_STEP,
+                SCREEN_HEIGHT_CENTER + 10,
+                PIN_ASTERISK_RADIUS);
+        }
+    }
+}
+
+bool totp_scene_authenticate_handle_event(PluginEvent* const event, PluginState* plugin_state) {
+    if(event->type == EventTypeKey) {
+        if(event->input.type == InputTypeLong && event->input.key == InputKeyBack) {
+            return false;
+        } else if(event->input.type == InputTypePress) {
+            SceneState* scene_state = (SceneState*)plugin_state->current_scene_state;
+
+            const uint8_t ARROW_UP_CODE = 2;
+            const uint8_t ARROW_RIGHT_CODE = 8;
+            const uint8_t ARROW_DOWN_CODE = 11;
+            const uint8_t ARROW_LEFT_CODE = 5;
+
+            switch(event->input.key) {
+            case InputKeyUp:
+                if(scene_state->code_length < MAX_CODE_LENGTH) {
+                    scene_state->code_input[scene_state->code_length] = ARROW_UP_CODE;
+                    scene_state->code_length++;
+                }
+                break;
+            case InputKeyDown:
+                if(scene_state->code_length < MAX_CODE_LENGTH) {
+                    scene_state->code_input[scene_state->code_length] = ARROW_DOWN_CODE;
+                    scene_state->code_length++;
+                }
+                break;
+            case InputKeyRight:
+                if(scene_state->code_length < MAX_CODE_LENGTH) {
+                    scene_state->code_input[scene_state->code_length] = ARROW_RIGHT_CODE;
+                    scene_state->code_length++;
+                }
+                break;
+            case InputKeyLeft:
+                if(scene_state->code_length < MAX_CODE_LENGTH) {
+                    scene_state->code_input[scene_state->code_length] = ARROW_LEFT_CODE;
+                    scene_state->code_length++;
+                }
+                break;
+            case InputKeyOk:
+                if(plugin_state->crypto_verify_data == NULL) {
+                    FURI_LOG_D(LOGGING_TAG, "Generating new IV");
+                    furi_hal_random_fill_buf(&plugin_state->base_iv[0], TOTP_IV_SIZE);
+                }
+
+                memcpy(&plugin_state->iv[0], &plugin_state->base_iv[0], TOTP_IV_SIZE);
+                for(uint8_t i = 0; i < scene_state->code_length; i++) {
+                    plugin_state->iv[i] = plugin_state->iv[i] ^
+                                          (uint8_t)(scene_state->code_input[i] * (i + 1));
+                }
+
+                if(plugin_state->crypto_verify_data == NULL) {
+                    FURI_LOG_D(LOGGING_TAG, "Generating crypto verify data");
+                    plugin_state->crypto_verify_data = malloc(CRYPTO_VERIFY_KEY_LENGTH);
+                    plugin_state->crypto_verify_data_length = CRYPTO_VERIFY_KEY_LENGTH;
+                    Storage* storage = totp_open_storage();
+                    FlipperFormat* config_file = totp_open_config_file(storage);
+                    furi_hal_crypto_store_load_key(CRYPTO_KEY_SLOT, &plugin_state->iv[0]);
+                    furi_hal_crypto_encrypt(
+                        (uint8_t*)CRYPTO_VERIFY_KEY,
+                        plugin_state->crypto_verify_data,
+                        CRYPTO_VERIFY_KEY_LENGTH);
+                    furi_hal_crypto_store_unload_key(CRYPTO_KEY_SLOT);
+                    flipper_format_insert_or_update_hex(
+                        config_file, TOTP_CONFIG_KEY_BASE_IV, plugin_state->base_iv, TOTP_IV_SIZE);
+                    flipper_format_insert_or_update_hex(
+                        config_file,
+                        TOTP_CONFIG_KEY_CRYPTO_VERIFY,
+                        plugin_state->crypto_verify_data,
+                        CRYPTO_VERIFY_KEY_LENGTH);
+                    totp_close_config_file(config_file);
+                    totp_close_storage();
+                }
+
+                uint8_t decrypted_key[CRYPTO_VERIFY_KEY_LENGTH];
+                furi_hal_crypto_store_load_key(CRYPTO_KEY_SLOT, &plugin_state->iv[0]);
+                furi_hal_crypto_decrypt(
+                    plugin_state->crypto_verify_data, &decrypted_key[0], CRYPTO_VERIFY_KEY_LENGTH);
+                furi_hal_crypto_store_unload_key(CRYPTO_KEY_SLOT);
+
+                bool key_valid = true;
+                for(uint8_t i = 0; i < CRYPTO_VERIFY_KEY_LENGTH && key_valid; i++) {
+                    if(decrypted_key[i] != CRYPTO_VERIFY_KEY[i]) key_valid = false;
+                }
+
+                if(key_valid) {
+                    FURI_LOG_D(LOGGING_TAG, "PIN is valid");
+                    totp_scene_director_activate_scene(plugin_state, TotpSceneGenerateToken, NULL);
+                } else {
+                    FURI_LOG_D(LOGGING_TAG, "PIN is NOT valid");
+                    memset(&scene_state->code_input[0], 0, MAX_CODE_LENGTH);
+                    memset(&plugin_state->iv[0], 0, TOTP_IV_SIZE);
+                    scene_state->code_length = 0;
+
+                    DialogMessage* message = dialog_message_alloc();
+                    dialog_message_set_buttons(message, "Try again", NULL, NULL);
+                    dialog_message_set_header(
+                        message,
+                        "You entered\ninvalid PIN",
+                        SCREEN_WIDTH_CENTER - 25,
+                        SCREEN_HEIGHT_CENTER - 5,
+                        AlignCenter,
+                        AlignCenter);
+                    dialog_message_set_icon(message, &I_DolphinCommon_56x48, 72, 17);
+                    dialog_message_show(plugin_state->dialogs, message);
+                    dialog_message_free(message);
+                }
+                break;
+            case InputKeyBack:
+                if(scene_state->code_length > 0) {
+                    scene_state->code_input[scene_state->code_length - 1] = 0;
+                    scene_state->code_length--;
+                }
+                break;
+            }
+        }
+    }
+
+    return true;
+}
+
+void totp_scene_authenticate_deactivate(PluginState* plugin_state) {
+    if(plugin_state->current_scene_state == NULL) return;
+    free(plugin_state->current_scene_state);
+    plugin_state->current_scene_state = NULL;
+}
+
+void totp_scene_authenticate_free(PluginState* plugin_state) {
+    UNUSED(plugin_state);
+}

applications/plugins/totp/scenes/authenticate/totp_scene_authenticate.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <gui/gui.h>
+#include <furi.h>
+#include <furi_hal.h>
+#include "../../types/plugin_state.h"
+#include "../../types/plugin_event.h"
+
+void totp_scene_authenticate_init(PluginState* plugin_state);
+void totp_scene_authenticate_activate(PluginState* plugin_state);
+void totp_scene_authenticate_render(Canvas* const canvas, PluginState* plugin_state);
+bool totp_scene_authenticate_handle_event(PluginEvent* const event, PluginState* plugin_state);
+void totp_scene_authenticate_deactivate(PluginState* plugin_state);
+void totp_scene_authenticate_free(PluginState* plugin_state);

applications/plugins/totp/scenes/generate_token/totp_scene_generate_token.c

@@ -0,0 +1,299 @@
+#include <gui/gui.h>
+#include <notification/notification.h>
+#include <notification/notification_messages.h>
+#include "totp_scene_generate_token.h"
+#include "../../types/token_info.h"
+#include "../../types/common.h"
+#include "../../services/ui/icons.h"
+#include "../../services/ui/constants.h"
+#include "../../services/totp/totp.h"
+#include "../../services/config/config.h"
+#include "../scene_director.h"
+#include "../token_menu/totp_scene_token_menu.h"
+
+#define TOKEN_LIFETIME 30
+#define DIGIT_TO_CHAR(digit) ((digit) + '0')
+
+typedef struct {
+    uint8_t current_token_index;
+    char last_code[9];
+    char* last_code_name;
+    bool need_token_update;
+    uint32_t last_token_gen_time;
+} SceneState;
+
+static const NotificationSequence sequence_short_vibro_and_sound = {
+    &message_display_backlight_on,
+    &message_green_255,
+    &message_vibro_on,
+    &message_note_c5,
+    &message_delay_50,
+    &message_vibro_off,
+    &message_sound_off,
+    NULL,
+};
+
+static void i_token_to_str(uint32_t i_token_code, char* str, TokenDigitsCount len) {
+    if(len == TOTP_8_DIGITS) {
+        str[8] = '\0';
+    } else if(len == TOTP_6_DIGITS) {
+        str[6] = '\0';
+    }
+
+    if(i_token_code == 0) {
+        if(len > TOTP_6_DIGITS) {
+            str[7] = '-';
+            str[6] = '-';
+        }
+
+        str[5] = '-';
+        str[4] = '-';
+        str[3] = '-';
+        str[2] = '-';
+        str[1] = '-';
+        str[0] = '-';
+    } else {
+        if(len == TOTP_8_DIGITS) {
+            str[7] = DIGIT_TO_CHAR(i_token_code % 10);
+            str[6] = DIGIT_TO_CHAR((i_token_code = i_token_code / 10) % 10);
+            str[5] = DIGIT_TO_CHAR((i_token_code = i_token_code / 10) % 10);
+        } else if(len == TOTP_6_DIGITS) {
+            str[5] = DIGIT_TO_CHAR(i_token_code % 10);
+        }
+
+        str[4] = DIGIT_TO_CHAR((i_token_code = i_token_code / 10) % 10);
+        str[3] = DIGIT_TO_CHAR((i_token_code = i_token_code / 10) % 10);
+        str[2] = DIGIT_TO_CHAR((i_token_code = i_token_code / 10) % 10);
+        str[1] = DIGIT_TO_CHAR((i_token_code = i_token_code / 10) % 10);
+        str[0] = DIGIT_TO_CHAR((i_token_code = i_token_code / 10) % 10);
+    }
+}
+
+TOTP_ALGO get_totp_algo_impl(TokenHashAlgo algo) {
+    switch(algo) {
+    case SHA1:
+        return TOTP_ALGO_SHA1;
+    case SHA256:
+        return TOTP_ALGO_SHA256;
+    case SHA512:
+        return TOTP_ALGO_SHA512;
+    }
+
+    return NULL;
+}
+
+void update_totp_params(PluginState* const plugin_state) {
+    SceneState* scene_state = (SceneState*)plugin_state->current_scene_state;
+
+    if(scene_state->current_token_index < plugin_state->tokens_count) {
+        TokenInfo* tokenInfo =
+            (TokenInfo*)(list_element_at(
+                             plugin_state->tokens_list, scene_state->current_token_index)
+                             ->data);
+
+        scene_state->need_token_update = true;
+        scene_state->last_code_name = tokenInfo->name;
+    }
+}
+
+void totp_scene_generate_token_init(PluginState* plugin_state) {
+    UNUSED(plugin_state);
+}
+
+void totp_scene_generate_token_activate(
+    PluginState* plugin_state,
+    const GenerateTokenSceneContext* context) {
+    if(!plugin_state->token_list_loaded) {
+        totp_config_file_load_tokens(plugin_state);
+    }
+    SceneState* scene_state = malloc(sizeof(SceneState));
+    if(context == NULL) {
+        scene_state->current_token_index = 0;
+    } else {
+        scene_state->current_token_index = context->current_token_index;
+    }
+    scene_state->need_token_update = true;
+    plugin_state->current_scene_state = scene_state;
+    FURI_LOG_D(LOGGING_TAG, "Timezone set to: %f", (double)plugin_state->timezone_offset);
+    update_totp_params(plugin_state);
+}
+
+void totp_scene_generate_token_render(Canvas* const canvas, PluginState* plugin_state) {
+    if(plugin_state->tokens_count == 0) {
+        canvas_draw_str_aligned(
+            canvas,
+            SCREEN_WIDTH_CENTER,
+            SCREEN_HEIGHT_CENTER - 10,
+            AlignCenter,
+            AlignCenter,
+            "Token list is empty");
+        canvas_draw_str_aligned(
+            canvas,
+            SCREEN_WIDTH_CENTER,
+            SCREEN_HEIGHT_CENTER + 10,
+            AlignCenter,
+            AlignCenter,
+            "Press OK button to add");
+        return;
+    }
+
+    SceneState* scene_state = (SceneState*)plugin_state->current_scene_state;
+    FuriHalRtcDateTime curr_dt;
+    furi_hal_rtc_get_datetime(&curr_dt);
+    uint32_t curr_ts = furi_hal_rtc_datetime_to_timestamp(&curr_dt);
+
+    bool is_new_token_time = curr_ts % TOKEN_LIFETIME == 0;
+    if(is_new_token_time && scene_state->last_token_gen_time != curr_ts) {
+        scene_state->need_token_update = true;
+    }
+
+    if(scene_state->need_token_update) {
+        scene_state->need_token_update = false;
+        scene_state->last_token_gen_time = curr_ts;
+
+        TokenInfo* tokenInfo =
+            (TokenInfo*)(list_element_at(
+                             plugin_state->tokens_list, scene_state->current_token_index)
+                             ->data);
+
+        uint8_t* key = malloc(tokenInfo->token_length);
+
+        furi_hal_crypto_store_load_key(CRYPTO_KEY_SLOT, &plugin_state->iv[0]);
+        furi_hal_crypto_decrypt(tokenInfo->token, key, tokenInfo->token_length);
+        furi_hal_crypto_store_unload_key(CRYPTO_KEY_SLOT);
+
+        i_token_to_str(
+            totp_at(
+                get_totp_algo_impl(tokenInfo->algo),
+                token_info_get_digits_count(tokenInfo),
+                key,
+                tokenInfo->token_length,
+                curr_ts,
+                plugin_state->timezone_offset,
+                TOKEN_LIFETIME),
+            scene_state->last_code,
+            tokenInfo->digits);
+        memset(key, 0, tokenInfo->token_length);
+        free(key);
+
+        if(is_new_token_time) {
+            notification_message(plugin_state->notification, &sequence_short_vibro_and_sound);
+        }
+    }
+
+    canvas_set_font(canvas, FontPrimary);
+    uint16_t token_name_width = canvas_string_width(canvas, scene_state->last_code_name);
+    if(SCREEN_WIDTH - token_name_width > 18) {
+        canvas_draw_str_aligned(
+            canvas,
+            SCREEN_WIDTH_CENTER,
+            SCREEN_HEIGHT_CENTER - 20,
+            AlignCenter,
+            AlignCenter,
+            scene_state->last_code_name);
+    } else {
+        canvas_draw_str_aligned(
+            canvas,
+            9,
+            SCREEN_HEIGHT_CENTER - 20,
+            AlignLeft,
+            AlignCenter,
+            scene_state->last_code_name);
+        canvas_set_color(canvas, ColorWhite);
+        canvas_draw_box(canvas, 0, SCREEN_HEIGHT_CENTER - 24, 9, 9);
+        canvas_draw_box(canvas, SCREEN_WIDTH - 10, SCREEN_HEIGHT_CENTER - 24, 9, 9);
+        canvas_set_color(canvas, ColorBlack);
+    }
+
+    canvas_set_font(canvas, FontBigNumbers);
+    canvas_draw_str_aligned(
+        canvas,
+        SCREEN_WIDTH_CENTER,
+        SCREEN_HEIGHT_CENTER,
+        AlignCenter,
+        AlignCenter,
+        scene_state->last_code);
+
+    const uint8_t BAR_MARGIN = 3;
+    const uint8_t BAR_HEIGHT = 4;
+    float percentDone = (float)(TOKEN_LIFETIME - curr_ts % TOKEN_LIFETIME) / (float)TOKEN_LIFETIME;
+    uint8_t barWidth = (uint8_t)((float)(SCREEN_WIDTH - (BAR_MARGIN << 1)) * percentDone);
+    uint8_t barX = ((SCREEN_WIDTH - (BAR_MARGIN << 1) - barWidth) >> 1) + BAR_MARGIN;
+
+    canvas_draw_box(canvas, barX, SCREEN_HEIGHT - BAR_MARGIN - BAR_HEIGHT, barWidth, BAR_HEIGHT);
+
+    if(plugin_state->tokens_count > 1) {
+        canvas_draw_xbm(
+            canvas,
+            0,
+            SCREEN_HEIGHT_CENTER - 24,
+            ICON_ARROW_LEFT_8x9_WIDTH,
+            ICON_ARROW_LEFT_8x9_HEIGHT,
+            &ICON_ARROW_LEFT_8x9[0]);
+        canvas_draw_xbm(
+            canvas,
+            SCREEN_WIDTH - 9,
+            SCREEN_HEIGHT_CENTER - 24,
+            ICON_ARROW_RIGHT_8x9_WIDTH,
+            ICON_ARROW_RIGHT_8x9_HEIGHT,
+            &ICON_ARROW_RIGHT_8x9[0]);
+    }
+}
+
+bool totp_scene_generate_token_handle_event(PluginEvent* const event, PluginState* plugin_state) {
+    if(event->type == EventTypeKey) {
+        if(event->input.type == InputTypeLong && event->input.key == InputKeyBack) {
+            return false;
+        } else if(event->input.type == InputTypePress) {
+            SceneState* scene_state = (SceneState*)plugin_state->current_scene_state;
+            switch(event->input.key) {
+            case InputKeyUp:
+                break;
+            case InputKeyDown:
+                break;
+            case InputKeyRight:
+                if(scene_state->current_token_index < plugin_state->tokens_count - 1) {
+                    scene_state->current_token_index++;
+                } else {
+                    scene_state->current_token_index = 0;
+                }
+                update_totp_params(plugin_state);
+                break;
+            case InputKeyLeft:
+                if(scene_state->current_token_index > 0) {
+                    scene_state->current_token_index--;
+                } else {
+                    scene_state->current_token_index = plugin_state->tokens_count - 1;
+                }
+                update_totp_params(plugin_state);
+                break;
+            case InputKeyOk:
+                if(plugin_state->tokens_count == 0) {
+                    totp_scene_director_activate_scene(plugin_state, TotpSceneAddNewToken, NULL);
+                } else {
+                    TokenMenuSceneContext ctx = {
+                        .current_token_index = scene_state->current_token_index};
+                    totp_scene_director_activate_scene(plugin_state, TotpSceneTokenMenu, &ctx);
+                }
+                break;
+            case InputKeyBack:
+                break;
+            }
+        }
+    }
+
+    return true;
+}
+
+void totp_scene_generate_token_deactivate(PluginState* plugin_state) {
+    if(plugin_state->current_scene_state == NULL) return;
+    SceneState* scene_state = (SceneState*)plugin_state->current_scene_state;
+
+    free(scene_state->last_code);
+    free(scene_state);
+    plugin_state->current_scene_state = NULL;
+}
+
+void totp_scene_generate_token_free(PluginState* plugin_state) {
+    UNUSED(plugin_state);
+}

applications/plugins/totp/scenes/generate_token/totp_scene_generate_token.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <gui/gui.h>
+#include <furi.h>
+#include <furi_hal.h>
+#include "../../types/plugin_state.h"
+#include "../../types/plugin_event.h"
+
+typedef struct {
+    uint8_t current_token_index;
+} GenerateTokenSceneContext;
+
+void totp_scene_generate_token_init(PluginState* plugin_state);
+void totp_scene_generate_token_activate(
+    PluginState* plugin_state,
+    const GenerateTokenSceneContext* context);
+void totp_scene_generate_token_render(Canvas* const canvas, PluginState* plugin_state);
+bool totp_scene_generate_token_handle_event(PluginEvent* const event, PluginState* plugin_state);
+void totp_scene_generate_token_deactivate(PluginState* plugin_state);
+void totp_scene_generate_token_free(PluginState* plugin_state);

applications/plugins/totp/scenes/scene_director.c

@@ -0,0 +1,99 @@
+#include "../types/common.h"
+#include "scene_director.h"
+#include "authenticate/totp_scene_authenticate.h"
+#include "generate_token/totp_scene_generate_token.h"
+#include "add_new_token/totp_scene_add_new_token.h"
+#include "token_menu/totp_scene_token_menu.h"
+
+void totp_scene_director_activate_scene(
+    PluginState* const plugin_state,
+    Scene scene,
+    const void* context) {
+    plugin_state->changing_scene = true;
+    totp_scene_director_deactivate_active_scene(plugin_state);
+    switch(scene) {
+    case TotpSceneGenerateToken:
+        totp_scene_generate_token_activate(plugin_state, context);
+        break;
+    case TotpSceneAuthentication:
+        totp_scene_authenticate_activate(plugin_state);
+        break;
+    case TotpSceneAddNewToken:
+        totp_scene_add_new_token_activate(plugin_state, context);
+        break;
+    case TotpSceneTokenMenu:
+        totp_scene_token_menu_activate(plugin_state, context);
+        break;
+    }
+
+    plugin_state->current_scene = scene;
+    plugin_state->changing_scene = false;
+}
+
+void totp_scene_director_deactivate_active_scene(PluginState* const plugin_state) {
+    switch(plugin_state->current_scene) {
+    case TotpSceneGenerateToken:
+        totp_scene_generate_token_deactivate(plugin_state);
+        break;
+    case TotpSceneAuthentication:
+        totp_scene_authenticate_deactivate(plugin_state);
+        break;
+    case TotpSceneAddNewToken:
+        totp_scene_add_new_token_deactivate(plugin_state);
+        break;
+    case TotpSceneTokenMenu:
+        totp_scene_token_menu_deactivate(plugin_state);
+        break;
+    }
+}
+
+void totp_scene_director_init_scenes(PluginState* const plugin_state) {
+    totp_scene_authenticate_init(plugin_state);
+    totp_scene_generate_token_init(plugin_state);
+    totp_scene_add_new_token_init(plugin_state);
+    totp_scene_token_menu_init(plugin_state);
+}
+
+void totp_scene_director_render(Canvas* const canvas, PluginState* const plugin_state) {
+    switch(plugin_state->current_scene) {
+    case TotpSceneGenerateToken:
+        totp_scene_generate_token_render(canvas, plugin_state);
+        break;
+    case TotpSceneAuthentication:
+        totp_scene_authenticate_render(canvas, plugin_state);
+        break;
+    case TotpSceneAddNewToken:
+        totp_scene_add_new_token_render(canvas, plugin_state);
+        break;
+    case TotpSceneTokenMenu:
+        totp_scene_token_menu_render(canvas, plugin_state);
+        break;
+    }
+}
+
+void totp_scene_director_dispose(PluginState* const plugin_state) {
+    totp_scene_generate_token_free(plugin_state);
+    totp_scene_authenticate_free(plugin_state);
+    totp_scene_add_new_token_free(plugin_state);
+    totp_scene_token_menu_free(plugin_state);
+}
+
+bool totp_scene_director_handle_event(PluginEvent* const event, PluginState* const plugin_state) {
+    bool processing = true;
+    switch(plugin_state->current_scene) {
+    case TotpSceneGenerateToken:
+        processing = totp_scene_generate_token_handle_event(event, plugin_state);
+        break;
+    case TotpSceneAuthentication:
+        processing = totp_scene_authenticate_handle_event(event, plugin_state);
+        break;
+    case TotpSceneAddNewToken:
+        processing = totp_scene_add_new_token_handle_event(event, plugin_state);
+        break;
+    case TotpSceneTokenMenu:
+        processing = totp_scene_token_menu_handle_event(event, plugin_state);
+        break;
+    }
+
+    return processing;
+}

applications/plugins/totp/scenes/scene_director.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <gui/gui.h>
+#include "../types/plugin_state.h"
+#include "../types/plugin_event.h"
+#include "totp_scenes_enum.h"
+
+void totp_scene_director_activate_scene(
+    PluginState* const plugin_state,
+    Scene scene,
+    const void* context);
+void totp_scene_director_deactivate_active_scene(PluginState* const plugin_state);
+void totp_scene_director_init_scenes(PluginState* const plugin_state);
+void totp_scene_director_render(Canvas* const canvas, PluginState* const plugin_state);
+void totp_scene_director_dispose(PluginState* const plugin_state);
+bool totp_scene_director_handle_event(PluginEvent* const event, PluginState* const plugin_state);

applications/plugins/totp/scenes/token_menu/totp_scene_token_menu.c

@@ -0,0 +1,139 @@
+#include "totp_scene_token_menu.h"
+#include <gui/gui.h>
+#include <dialogs/dialogs.h>
+#include "../../services/ui/ui_controls.h"
+#include "../../services/ui/constants.h"
+#include "../scene_director.h"
+#include "../../services/config/config.h"
+#include "../../services/list/list.h"
+#include "../../types/token_info.h"
+#include "../generate_token/totp_scene_generate_token.h"
+#include "../add_new_token/totp_scene_add_new_token.h"
+
+typedef enum { AddNewToken, DeleteToken } Control;
+
+typedef struct {
+    Control selected_control;
+    uint8_t current_token_index;
+} SceneState;
+
+void totp_scene_token_menu_init(PluginState* plugin_state) {
+    UNUSED(plugin_state);
+}
+
+void totp_scene_token_menu_activate(
+    PluginState* plugin_state,
+    const TokenMenuSceneContext* context) {
+    SceneState* scene_state = malloc(sizeof(SceneState));
+    plugin_state->current_scene_state = scene_state;
+    scene_state->current_token_index = context->current_token_index;
+}
+
+void totp_scene_token_menu_render(Canvas* const canvas, PluginState* plugin_state) {
+    SceneState* scene_state = (SceneState*)plugin_state->current_scene_state;
+    ui_control_button_render(
+        canvas,
+        SCREEN_WIDTH_CENTER - 36,
+        5,
+        72,
+        21,
+        "Add new token",
+        scene_state->selected_control == AddNewToken);
+    ui_control_button_render(
+        canvas,
+        SCREEN_WIDTH_CENTER - 36,
+        39,
+        72,
+        21,
+        "Delete token",
+        scene_state->selected_control == DeleteToken);
+}
+
+bool totp_scene_token_menu_handle_event(PluginEvent* const event, PluginState* plugin_state) {
+    if(event->type == EventTypeKey) {
+        SceneState* scene_state = (SceneState*)plugin_state->current_scene_state;
+        if(event->input.type == InputTypePress) {
+            switch(event->input.key) {
+            case InputKeyUp:
+                if(scene_state->selected_control > AddNewToken) {
+                    scene_state->selected_control--;
+                }
+                break;
+            case InputKeyDown:
+                if(scene_state->selected_control < DeleteToken) {
+                    scene_state->selected_control++;
+                }
+                break;
+            case InputKeyRight:
+                break;
+            case InputKeyLeft:
+                break;
+            case InputKeyOk:
+                switch(scene_state->selected_control) {
+                case AddNewToken: {
+                    TokenAddEditSceneContext add_new_token_scene_context = {
+                        .current_token_index = scene_state->current_token_index};
+                    totp_scene_director_activate_scene(
+                        plugin_state, TotpSceneAddNewToken, &add_new_token_scene_context);
+                    break;
+                }
+                case DeleteToken: {
+                    DialogMessage* message = dialog_message_alloc();
+                    dialog_message_set_buttons(message, "No", NULL, "Yes");
+                    dialog_message_set_header(message, "Confirmation", 0, 0, AlignLeft, AlignTop);
+                    dialog_message_set_text(
+                        message,
+                        "Are you sure want to delete?",
+                        SCREEN_WIDTH_CENTER,
+                        SCREEN_HEIGHT_CENTER,
+                        AlignCenter,
+                        AlignCenter);
+                    DialogMessageButton dialog_result =
+                        dialog_message_show(plugin_state->dialogs, message);
+                    dialog_message_free(message);
+                    if(dialog_result == DialogMessageButtonRight) {
+                        uint8_t i = 0;
+
+                        ListNode* list_node = plugin_state->tokens_list;
+                        while(i < scene_state->current_token_index && list_node->next != NULL) {
+                            list_node = list_node->next;
+                            i++;
+                        }
+
+                        TokenInfo* tokenInfo = list_node->data;
+                        token_info_free(tokenInfo);
+                        plugin_state->tokens_list =
+                            list_remove(plugin_state->tokens_list, list_node);
+                        plugin_state->tokens_count--;
+
+                        totp_full_save_config_file(plugin_state);
+                        totp_scene_director_activate_scene(
+                            plugin_state, TotpSceneGenerateToken, NULL);
+                    }
+                    break;
+                }
+                }
+                break;
+            case InputKeyBack: {
+                GenerateTokenSceneContext generate_scene_context = {
+                    .current_token_index = scene_state->current_token_index};
+                totp_scene_director_activate_scene(
+                    plugin_state, TotpSceneGenerateToken, &generate_scene_context);
+                break;
+            }
+            }
+        }
+    }
+    return true;
+}
+
+void totp_scene_token_menu_deactivate(PluginState* plugin_state) {
+    if(plugin_state->current_scene_state == NULL) return;
+
+    free(plugin_state->current_scene_state);
+    plugin_state->current_scene_state = NULL;
+}
+
+void totp_scene_token_menu_free(PluginState* plugin_state) {
+    UNUSED(plugin_state);
+}

applications/plugins/totp/scenes/token_menu/totp_scene_token_menu.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <gui/gui.h>
+#include <furi.h>
+#include <furi_hal.h>
+#include "../../types/plugin_state.h"
+#include "../../types/plugin_event.h"
+
+typedef struct {
+    uint8_t current_token_index;
+} TokenMenuSceneContext;
+
+void totp_scene_token_menu_init(PluginState* plugin_state);
+void totp_scene_token_menu_activate(
+    PluginState* plugin_state,
+    const TokenMenuSceneContext* context);
+void totp_scene_token_menu_render(Canvas* const canvas, PluginState* plugin_state);
+bool totp_scene_token_menu_handle_event(PluginEvent* const event, PluginState* plugin_state);
+void totp_scene_token_menu_deactivate(PluginState* plugin_state);
+void totp_scene_token_menu_free(PluginState* plugin_state);

applications/plugins/totp/scenes/totp_scenes_enum.h

@@ -0,0 +1,8 @@
+#pragma once
+
+typedef enum {
+    TotpSceneAuthentication,
+    TotpSceneGenerateToken,
+    TotpSceneAddNewToken,
+    TotpSceneTokenMenu
+} Scene;

applications/plugins/totp/services/base32/base32.c

@@ -0,0 +1,94 @@
+// Base32 implementation
+//
+// Copyright 2010 Google Inc.
+// Author: Markus Gutschke
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <string.h>
+
+#include "base32.h"
+
+int base32_decode(const uint8_t* encoded, uint8_t* result, int bufSize) {
+    int buffer = 0;
+    int bitsLeft = 0;
+    int count = 0;
+    for(const uint8_t* ptr = encoded; count < bufSize && *ptr; ++ptr) {
+        uint8_t ch = *ptr;
+        if(ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n' || ch == '-') {
+            continue;
+        }
+        buffer <<= 5;
+
+        // Deal with commonly mistyped characters
+        if(ch == '0') {
+            ch = 'O';
+        } else if(ch == '1') {
+            ch = 'L';
+        } else if(ch == '8') {
+            ch = 'B';
+        }
+
+        // Look up one base32 digit
+        if((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')) {
+            ch = (ch & 0x1F) - 1;
+        } else if(ch >= '2' && ch <= '7') {
+            ch -= '2' - 26;
+        } else {
+            return -1;
+        }
+
+        buffer |= ch;
+        bitsLeft += 5;
+        if(bitsLeft >= 8) {
+            result[count++] = buffer >> (bitsLeft - 8);
+            bitsLeft -= 8;
+        }
+    }
+    if(count < bufSize) {
+        result[count] = '\000';
+    }
+    return count;
+}
+
+int base32_encode(const uint8_t* data, int length, uint8_t* result, int bufSize) {
+    if(length < 0 || length > (1 << 28)) {
+        return -1;
+    }
+    int count = 0;
+    if(length > 0) {
+        int buffer = data[0];
+        int next = 1;
+        int bitsLeft = 8;
+        while(count < bufSize && (bitsLeft > 0 || next < length)) {
+            if(bitsLeft < 5) {
+                if(next < length) {
+                    buffer <<= 8;
+                    buffer |= data[next++] & 0xFF;
+                    bitsLeft += 8;
+                } else {
+                    int pad = 5 - bitsLeft;
+                    buffer <<= pad;
+                    bitsLeft += pad;
+                }
+            }
+            int index = 0x1F & (buffer >> (bitsLeft - 5));
+            bitsLeft -= 5;
+            result[count++] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"[index];
+        }
+    }
+    if(count < bufSize) {
+        result[count] = '\000';
+    }
+    return count;
+}

applications/plugins/totp/services/base32/base32.h

@@ -0,0 +1,35 @@
+// Base32 implementation
+//
+// Copyright 2010 Google Inc.
+// Author: Markus Gutschke
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Encode and decode from base32 encoding using the following alphabet:
+//   ABCDEFGHIJKLMNOPQRSTUVWXYZ234567
+// This alphabet is documented in RFC 4648/3548
+//
+// We allow white-space and hyphens, but all other characters are considered
+// invalid.
+//
+// All functions return the number of output bytes or -1 on error. If the
+// output buffer is too small, the result will silently be truncated.
+
+#pragma once
+
+#include <stdint.h>
+
+int base32_decode(const uint8_t* encoded, uint8_t* result, int bufSize)
+    __attribute__((visibility("hidden")));
+int base32_encode(const uint8_t* data, int length, uint8_t* result, int bufSize)
+    __attribute__((visibility("hidden")));

applications/plugins/totp/services/config/config.c

@@ -0,0 +1,381 @@
+#include "config.h"
+#include <stdlib.h>
+#include <string.h>
+#include "../list/list.h"
+#include "../../types/common.h"
+#include "../../types/token_info.h"
+#include "migrations/config_migration_v1_to_v2.h"
+
+#define CONFIG_FILE_DIRECTORY_PATH "/ext/apps/Misc"
+#define CONFIG_FILE_PATH CONFIG_FILE_DIRECTORY_PATH "/totp.conf"
+#define CONFIG_FILE_BACKUP_PATH CONFIG_FILE_PATH ".backup"
+
+uint8_t token_info_get_digits_as_int(TokenInfo* token_info) {
+    switch(token_info->digits) {
+    case TOTP_6_DIGITS:
+        return 6;
+    case TOTP_8_DIGITS:
+        return 8;
+    }
+
+    return 6;
+}
+
+void token_info_set_digits_from_int(TokenInfo* token_info, uint8_t digits) {
+    switch(digits) {
+    case 6:
+        token_info->digits = TOTP_6_DIGITS;
+        break;
+    case 8:
+        token_info->digits = TOTP_8_DIGITS;
+        break;
+    }
+}
+
+char* token_info_get_algo_as_cstr(TokenInfo* token_info) {
+    switch(token_info->algo) {
+    case SHA1:
+        return TOTP_CONFIG_TOKEN_ALGO_SHA1_NAME;
+    case SHA256:
+        return TOTP_CONFIG_TOKEN_ALGO_SHA256_NAME;
+    case SHA512:
+        return TOTP_CONFIG_TOKEN_ALGO_SHA512_NAME;
+    }
+
+    return NULL;
+}
+
+void token_info_set_algo_from_str(TokenInfo* token_info, FuriString* str) {
+    if(furi_string_cmpi_str(str, TOTP_CONFIG_TOKEN_ALGO_SHA1_NAME) == 0) {
+        token_info->algo = SHA1;
+    } else if(furi_string_cmpi_str(str, TOTP_CONFIG_TOKEN_ALGO_SHA256_NAME)) {
+        token_info->algo = SHA256;
+    } else if(furi_string_cmpi_str(str, TOTP_CONFIG_TOKEN_ALGO_SHA512_NAME)) {
+        token_info->algo = SHA512;
+    }
+}
+
+Storage* totp_open_storage() {
+    return furi_record_open(RECORD_STORAGE);
+}
+
+void totp_close_storage() {
+    furi_record_close(RECORD_STORAGE);
+}
+
+FlipperFormat* totp_open_config_file(Storage* storage) {
+    FlipperFormat* fff_data_file = flipper_format_file_alloc(storage);
+
+    if(storage_common_stat(storage, CONFIG_FILE_PATH, NULL) == FSE_OK) {
+        FURI_LOG_D(LOGGING_TAG, "Config file %s found", CONFIG_FILE_PATH);
+        if(!flipper_format_file_open_existing(fff_data_file, CONFIG_FILE_PATH)) {
+            FURI_LOG_E(LOGGING_TAG, "Error opening existing file %s", CONFIG_FILE_PATH);
+            totp_close_config_file(fff_data_file);
+            return NULL;
+        }
+    } else {
+        FURI_LOG_D(LOGGING_TAG, "Config file %s is not found. Will create new.", CONFIG_FILE_PATH);
+        if(storage_common_stat(storage, CONFIG_FILE_DIRECTORY_PATH, NULL) == FSE_NOT_EXIST) {
+            FURI_LOG_D(
+                LOGGING_TAG,
+                "Directory %s doesn't exist. Will create new.",
+                CONFIG_FILE_DIRECTORY_PATH);
+            if(!storage_simply_mkdir(storage, CONFIG_FILE_DIRECTORY_PATH)) {
+                FURI_LOG_E(LOGGING_TAG, "Error creating directory %s", CONFIG_FILE_DIRECTORY_PATH);
+                return NULL;
+            }
+        }
+
+        if(!flipper_format_file_open_new(fff_data_file, CONFIG_FILE_PATH)) {
+            totp_close_config_file(fff_data_file);
+            FURI_LOG_E(LOGGING_TAG, "Error creating new file %s", CONFIG_FILE_PATH);
+            return NULL;
+        }
+
+        flipper_format_write_header_cstr(
+            fff_data_file, CONFIG_FILE_HEADER, CONFIG_FILE_ACTUAL_VERSION);
+        float tmp_tz = 0;
+        flipper_format_write_comment_cstr(fff_data_file, " ");
+        flipper_format_write_comment_cstr(
+            fff_data_file,
+            "Timezone offset in hours. Important note: do not put '+' sign for positive values");
+        flipper_format_write_float(fff_data_file, TOTP_CONFIG_KEY_TIMEZONE, &tmp_tz, 1);
+        FuriString* temp_str = furi_string_alloc();
+
+        flipper_format_write_comment_cstr(fff_data_file, " ");
+        flipper_format_write_comment_cstr(fff_data_file, "=== TOKEN SAMPLE BEGIN ===");
+        flipper_format_write_comment_cstr(fff_data_file, " ");
+        flipper_format_write_comment_cstr(
+            fff_data_file, "# Token name which will be visible in the UI.");
+        furi_string_printf(temp_str, "%s: Sample token name", TOTP_CONFIG_KEY_TOKEN_NAME);
+        flipper_format_write_comment(fff_data_file, temp_str);
+        flipper_format_write_comment_cstr(fff_data_file, " ");
+
+        flipper_format_write_comment_cstr(
+            fff_data_file,
+            "# Plain token secret without spaces, dashes and etc, just pure alpha-numeric characters. Important note: plain token will be encrypted and replaced by TOTP app");
+        furi_string_printf(temp_str, "%s: plaintokensecret", TOTP_CONFIG_KEY_TOKEN_SECRET);
+        flipper_format_write_comment(fff_data_file, temp_str);
+        flipper_format_write_comment_cstr(fff_data_file, " ");
+
+        furi_string_printf(
+            temp_str,
+            " # Token hashing algorithm to use during code generation. Supported options are %s, %s and %s. If you are not use which one to use - use %s",
+            TOTP_CONFIG_TOKEN_ALGO_SHA1_NAME,
+            TOTP_CONFIG_TOKEN_ALGO_SHA256_NAME,
+            TOTP_CONFIG_TOKEN_ALGO_SHA512_NAME,
+            TOTP_CONFIG_TOKEN_ALGO_SHA1_NAME);
+        flipper_format_write_comment(fff_data_file, temp_str);
+        furi_string_printf(
+            temp_str, "%s: %s", TOTP_CONFIG_KEY_TOKEN_ALGO, TOTP_CONFIG_TOKEN_ALGO_SHA1_NAME);
+        flipper_format_write_comment(fff_data_file, temp_str);
+        flipper_format_write_comment_cstr(fff_data_file, " ");
+
+        flipper_format_write_comment_cstr(
+            fff_data_file,
+            "# How many digits there should be in generated code. Available options are 6 and 8. Majority websites requires 6 digits code, however some rare websites wants to get 8 digits code. If you are not sure which one to use - use 6");
+        furi_string_printf(temp_str, "%s: 6", TOTP_CONFIG_KEY_TOKEN_DIGITS);
+        flipper_format_write_comment(fff_data_file, temp_str);
+        flipper_format_write_comment_cstr(fff_data_file, " ");
+
+        flipper_format_write_comment_cstr(fff_data_file, "=== TOKEN SAMPLE END ===");
+        flipper_format_write_comment_cstr(fff_data_file, " ");
+
+        furi_string_free(temp_str);
+        if(!flipper_format_rewind(fff_data_file)) {
+            totp_close_config_file(fff_data_file);
+            FURI_LOG_E(LOGGING_TAG, "Rewind error");
+            return NULL;
+        }
+    }
+
+    return fff_data_file;
+}
+
+void totp_config_file_save_new_token(FlipperFormat* file, TokenInfo* token_info) {
+    flipper_format_write_string_cstr(file, TOTP_CONFIG_KEY_TOKEN_NAME, token_info->name);
+    flipper_format_write_hex(
+        file, TOTP_CONFIG_KEY_TOKEN_SECRET, token_info->token, token_info->token_length);
+    flipper_format_write_string_cstr(
+        file, TOTP_CONFIG_KEY_TOKEN_ALGO, token_info_get_algo_as_cstr(token_info));
+    uint32_t digits_count_as_uint32 = token_info_get_digits_as_int(token_info);
+    flipper_format_write_uint32(file, TOTP_CONFIG_KEY_TOKEN_DIGITS, &digits_count_as_uint32, 1);
+}
+
+void totp_full_save_config_file(PluginState* const plugin_state) {
+    Storage* storage = totp_open_storage();
+    FlipperFormat* fff_data_file = flipper_format_file_alloc(storage);
+
+    flipper_format_file_open_always(fff_data_file, CONFIG_FILE_PATH);
+    flipper_format_write_header_cstr(
+        fff_data_file, CONFIG_FILE_HEADER, CONFIG_FILE_ACTUAL_VERSION);
+    flipper_format_write_hex(
+        fff_data_file, TOTP_CONFIG_KEY_BASE_IV, &plugin_state->base_iv[0], TOTP_IV_SIZE);
+    flipper_format_write_hex(
+        fff_data_file,
+        TOTP_CONFIG_KEY_CRYPTO_VERIFY,
+        plugin_state->crypto_verify_data,
+        plugin_state->crypto_verify_data_length);
+    flipper_format_write_float(
+        fff_data_file, TOTP_CONFIG_KEY_TIMEZONE, &plugin_state->timezone_offset, 1);
+    ListNode* node = plugin_state->tokens_list;
+    while(node != NULL) {
+        TokenInfo* token_info = node->data;
+        totp_config_file_save_new_token(fff_data_file, token_info);
+        node = node->next;
+    }
+
+    totp_close_config_file(fff_data_file);
+    totp_close_storage();
+}
+
+void totp_config_file_load_base(PluginState* const plugin_state) {
+    Storage* storage = totp_open_storage();
+    FlipperFormat* fff_data_file = totp_open_config_file(storage);
+
+    plugin_state->timezone_offset = 0;
+
+    FuriString* temp_str = furi_string_alloc();
+
+    uint32_t file_version;
+    if(!flipper_format_read_header(fff_data_file, temp_str, &file_version)) {
+        FURI_LOG_E(LOGGING_TAG, "Missing or incorrect header");
+        furi_string_free(temp_str);
+        return;
+    }
+
+    if(file_version < CONFIG_FILE_ACTUAL_VERSION) {
+        FURI_LOG_I(
+            LOGGING_TAG,
+            "Obsolete config file version detected. Current version: %ld; Actual version: %d",
+            file_version,
+            CONFIG_FILE_ACTUAL_VERSION);
+        totp_close_config_file(fff_data_file);
+
+        if(storage_common_stat(storage, CONFIG_FILE_BACKUP_PATH, NULL) == FSE_OK) {
+            storage_simply_remove(storage, CONFIG_FILE_BACKUP_PATH);
+        }
+
+        if(storage_common_copy(storage, CONFIG_FILE_PATH, CONFIG_FILE_BACKUP_PATH) == FSE_OK) {
+            FURI_LOG_I(LOGGING_TAG, "Took config file backup to %s", CONFIG_FILE_BACKUP_PATH);
+            fff_data_file = totp_open_config_file(storage);
+            FlipperFormat* fff_backup_data_file = flipper_format_file_alloc(storage);
+            flipper_format_file_open_existing(fff_backup_data_file, CONFIG_FILE_BACKUP_PATH);
+
+            if(file_version == 1) {
+                if(totp_config_migrate_v1_to_v2(fff_data_file, fff_backup_data_file)) {
+                    FURI_LOG_I(LOGGING_TAG, "Applied migration from v1 to v2");
+                } else {
+                    FURI_LOG_W(LOGGING_TAG, "An error occurred during migration from v1 to v2");
+                }
+            }
+
+            flipper_format_file_close(fff_backup_data_file);
+            flipper_format_free(fff_backup_data_file);
+            flipper_format_rewind(fff_data_file);
+        } else {
+            FURI_LOG_E(
+                LOGGING_TAG,
+                "An error occurred during taking backup of %s into %s before migration",
+                CONFIG_FILE_PATH,
+                CONFIG_FILE_BACKUP_PATH);
+        }
+    }
+
+    if(!flipper_format_read_hex(
+           fff_data_file, TOTP_CONFIG_KEY_BASE_IV, &plugin_state->base_iv[0], TOTP_IV_SIZE)) {
+        FURI_LOG_D(LOGGING_TAG, "Missing base IV");
+    }
+
+    flipper_format_rewind(fff_data_file);
+
+    uint32_t crypto_size;
+    if(flipper_format_get_value_count(fff_data_file, TOTP_CONFIG_KEY_CRYPTO_VERIFY, &crypto_size)) {
+        plugin_state->crypto_verify_data = malloc(sizeof(uint8_t) * crypto_size);
+        plugin_state->crypto_verify_data_length = crypto_size;
+        if(!flipper_format_read_hex(
+               fff_data_file,
+               TOTP_CONFIG_KEY_CRYPTO_VERIFY,
+               plugin_state->crypto_verify_data,
+               crypto_size)) {
+            FURI_LOG_D(LOGGING_TAG, "Missing crypto verify token");
+            free(plugin_state->crypto_verify_data);
+            plugin_state->crypto_verify_data = NULL;
+        }
+    }
+
+    flipper_format_rewind(fff_data_file);
+
+    if(!flipper_format_read_float(
+           fff_data_file, TOTP_CONFIG_KEY_TIMEZONE, &plugin_state->timezone_offset, 1)) {
+        plugin_state->timezone_offset = 0;
+        FURI_LOG_D(LOGGING_TAG, "Missing timezone offset information, defaulting to 0");
+    }
+
+    furi_string_free(temp_str);
+    totp_close_config_file(fff_data_file);
+    totp_close_storage();
+}
+
+void totp_config_file_load_tokens(PluginState* const plugin_state) {
+    Storage* storage = totp_open_storage();
+    FlipperFormat* fff_data_file = totp_open_config_file(storage);
+
+    FuriString* temp_str = furi_string_alloc();
+    uint32_t temp_data32;
+
+    if(!flipper_format_read_header(fff_data_file, temp_str, &temp_data32)) {
+        FURI_LOG_E(LOGGING_TAG, "Missing or incorrect header");
+        furi_string_free(temp_str);
+        return;
+    }
+
+    uint8_t index = 0;
+    bool has_any_plain_secret = false;
+
+    while(true) {
+        if(!flipper_format_read_string(fff_data_file, TOTP_CONFIG_KEY_TOKEN_NAME, temp_str)) {
+            break;
+        }
+
+        TokenInfo* tokenInfo = token_info_alloc();
+
+        const char* temp_cstr = furi_string_get_cstr(temp_str);
+        tokenInfo->name = (char*)malloc(strlen(temp_cstr) + 1);
+        strcpy(tokenInfo->name, temp_cstr);
+
+        uint32_t secret_bytes_count;
+        if(!flipper_format_get_value_count(
+               fff_data_file, TOTP_CONFIG_KEY_TOKEN_SECRET, &secret_bytes_count)) {
+            token_info_free(tokenInfo);
+            continue;
+        }
+
+        if(secret_bytes_count == 1) { // Plain secret key
+            if(!flipper_format_read_string(fff_data_file, TOTP_CONFIG_KEY_TOKEN_SECRET, temp_str)) {
+                token_info_free(tokenInfo);
+                continue;
+            }
+
+            temp_cstr = furi_string_get_cstr(temp_str);
+            token_info_set_secret(tokenInfo, temp_cstr, strlen(temp_cstr), &plugin_state->iv[0]);
+            has_any_plain_secret = true;
+            FURI_LOG_W(LOGGING_TAG, "Found token with plain secret");
+        } else { // encrypted
+            tokenInfo->token_length = secret_bytes_count;
+            tokenInfo->token = malloc(tokenInfo->token_length);
+            if(!flipper_format_read_hex(
+                   fff_data_file,
+                   TOTP_CONFIG_KEY_TOKEN_SECRET,
+                   tokenInfo->token,
+                   tokenInfo->token_length)) {
+                token_info_free(tokenInfo);
+                continue;
+            }
+        }
+
+        if(!flipper_format_read_string(fff_data_file, TOTP_CONFIG_KEY_TOKEN_ALGO, temp_str)) {
+            token_info_free(tokenInfo);
+            continue;
+        }
+
+        token_info_set_algo_from_str(tokenInfo, temp_str);
+
+        if(!flipper_format_read_uint32(
+               fff_data_file, TOTP_CONFIG_KEY_TOKEN_DIGITS, &temp_data32, 1)) {
+            token_info_free(tokenInfo);
+            continue;
+        }
+
+        token_info_set_digits_from_int(tokenInfo, temp_data32);
+
+        FURI_LOG_D(LOGGING_TAG, "Found token \"%s\"", tokenInfo->name);
+
+        if(plugin_state->tokens_list == NULL) {
+            plugin_state->tokens_list = list_init_head(tokenInfo);
+        } else {
+            list_add(plugin_state->tokens_list, tokenInfo);
+        }
+
+        index++;
+    }
+
+    plugin_state->tokens_count = index;
+    plugin_state->token_list_loaded = true;
+
+    FURI_LOG_D(LOGGING_TAG, "Found %d tokens", index);
+
+    furi_string_free(temp_str);
+    totp_close_config_file(fff_data_file);
+    totp_close_storage();
+
+    if(has_any_plain_secret) {
+        totp_full_save_config_file(plugin_state);
+    }
+}
+
+void totp_close_config_file(FlipperFormat* file) {
+    if(file == NULL) return;
+    flipper_format_file_close(file);
+    flipper_format_free(file);
+}

applications/plugins/totp/services/config/config.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <flipper_format/flipper_format.h>
+#include <furi.h>
+#include "../../types/plugin_state.h"
+#include "../../types/token_info.h"
+#include "constants.h"
+
+Storage* totp_open_storage();
+void totp_close_storage();
+FlipperFormat* totp_open_config_file(Storage* storage);
+void totp_close_config_file(FlipperFormat* file);
+void totp_full_save_config_file(PluginState* const plugin_state);
+void totp_config_file_load_base(PluginState* const plugin_state);
+void totp_config_file_load_tokens(PluginState* const plugin_state);
+void totp_config_file_save_new_token(FlipperFormat* file, TokenInfo* token_info);

applications/plugins/totp/services/config/constants.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#define CONFIG_FILE_HEADER "Flipper TOTP plugin config file"
+#define CONFIG_FILE_ACTUAL_VERSION 2
+
+#define TOTP_CONFIG_KEY_TIMEZONE "Timezone"
+#define TOTP_CONFIG_KEY_TOKEN_NAME "TokenName"
+#define TOTP_CONFIG_KEY_TOKEN_SECRET "TokenSecret"
+#define TOTP_CONFIG_KEY_TOKEN_ALGO "TokenAlgo"
+#define TOTP_CONFIG_KEY_TOKEN_DIGITS "TokenDigits"
+#define TOTP_CONFIG_KEY_CRYPTO_VERIFY "Crypto"
+#define TOTP_CONFIG_KEY_BASE_IV "BaseIV"
+
+#define TOTP_CONFIG_TOKEN_ALGO_SHA1_NAME "sha1"
+#define TOTP_CONFIG_TOKEN_ALGO_SHA256_NAME "sha256"
+#define TOTP_CONFIG_TOKEN_ALGO_SHA512_NAME "sha512"

applications/plugins/totp/services/config/migrations/config_migration_v1_to_v2.c

@@ -0,0 +1,46 @@
+#include "config_migration_v1_to_v2.h"
+#include <flipper_format/flipper_format.h>
+#include "../constants.h"
+
+#define NEW_VERSION 2
+
+bool totp_config_migrate_v1_to_v2(
+    FlipperFormat* fff_data_file,
+    FlipperFormat* fff_backup_data_file) {
+    flipper_format_write_header_cstr(fff_data_file, CONFIG_FILE_HEADER, NEW_VERSION);
+
+    FuriString* temp_str = furi_string_alloc();
+
+    if(flipper_format_read_string(fff_backup_data_file, TOTP_CONFIG_KEY_BASE_IV, temp_str)) {
+        flipper_format_write_string(fff_data_file, TOTP_CONFIG_KEY_BASE_IV, temp_str);
+    }
+
+    if(flipper_format_read_string(fff_backup_data_file, TOTP_CONFIG_KEY_CRYPTO_VERIFY, temp_str)) {
+        flipper_format_write_string(fff_data_file, TOTP_CONFIG_KEY_CRYPTO_VERIFY, temp_str);
+    }
+
+    if(flipper_format_read_string(fff_backup_data_file, TOTP_CONFIG_KEY_TIMEZONE, temp_str)) {
+        flipper_format_write_string(fff_data_file, TOTP_CONFIG_KEY_TIMEZONE, temp_str);
+    }
+
+    while(true) {
+        if(!flipper_format_read_string(
+               fff_backup_data_file, TOTP_CONFIG_KEY_TOKEN_NAME, temp_str)) {
+            break;
+        }
+
+        flipper_format_write_string(fff_data_file, TOTP_CONFIG_KEY_TOKEN_NAME, temp_str);
+
+        flipper_format_read_string(fff_backup_data_file, TOTP_CONFIG_KEY_TOKEN_SECRET, temp_str);
+        flipper_format_write_string(fff_data_file, TOTP_CONFIG_KEY_TOKEN_SECRET, temp_str);
+
+        flipper_format_write_string_cstr(
+            fff_data_file, TOTP_CONFIG_KEY_TOKEN_ALGO, TOTP_CONFIG_TOKEN_ALGO_SHA1_NAME);
+        uint32_t default_digits = 6;
+        flipper_format_write_uint32(
+            fff_data_file, TOTP_CONFIG_KEY_TOKEN_DIGITS, &default_digits, 1);
+    }
+
+    furi_string_free(temp_str);
+    return true;
+}

applications/plugins/totp/services/config/migrations/config_migration_v1_to_v2.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <flipper_format/flipper_format.h>
+
+bool totp_config_migrate_v1_to_v2(
+    FlipperFormat* fff_data_file,
+    FlipperFormat* fff_backup_data_file);

applications/plugins/totp/services/hmac/byteswap.c

@@ -0,0 +1,12 @@
+#include "byteswap.h"
+
+uint32_t swap_uint32(uint32_t val) {
+    val = ((val << 8) & 0xFF00FF00) | ((val >> 8) & 0xFF00FF);
+    return (val << 16) | (val >> 16);
+}
+
+uint64_t swap_uint64(uint64_t val) {
+    val = ((val << 8) & 0xFF00FF00FF00FF00ULL) | ((val >> 8) & 0x00FF00FF00FF00FFULL);
+    val = ((val << 16) & 0xFFFF0000FFFF0000ULL) | ((val >> 16) & 0x0000FFFF0000FFFFULL);
+    return (val << 32) | (val >> 32);
+}

applications/plugins/totp/services/hmac/byteswap.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <stdint.h>
+
+uint32_t swap_uint32(uint32_t val);
+uint64_t swap_uint64(uint64_t val);

applications/plugins/totp/services/hmac/hmac_common.h

@@ -0,0 +1,64 @@
+#include <string.h>
+#include "sha256.h"
+#include "memxor.h"
+
+#define IPAD 0x36
+#define OPAD 0x5c
+
+/* Concatenate two preprocessor tokens.  */
+#define _GLHMAC_CONCAT_(prefix, suffix) prefix##suffix
+#define _GLHMAC_CONCAT(prefix, suffix) _GLHMAC_CONCAT_(prefix, suffix)
+
+#if GL_HMAC_NAME == 5
+#define HMAC_ALG md5
+#else
+#define HMAC_ALG _GLHMAC_CONCAT(sha, GL_HMAC_NAME)
+#endif
+
+#define GL_HMAC_CTX _GLHMAC_CONCAT(HMAC_ALG, _ctx)
+#define GL_HMAC_FN _GLHMAC_CONCAT(hmac_, HMAC_ALG)
+#define GL_HMAC_FN_INIT _GLHMAC_CONCAT(HMAC_ALG, _init_ctx)
+#define GL_HMAC_FN_BLOC _GLHMAC_CONCAT(HMAC_ALG, _process_block)
+#define GL_HMAC_FN_PROC _GLHMAC_CONCAT(HMAC_ALG, _process_bytes)
+#define GL_HMAC_FN_FINI _GLHMAC_CONCAT(HMAC_ALG, _finish_ctx)
+
+static void
+    hmac_hash(const void* key, size_t keylen, const void* in, size_t inlen, int pad, void* resbuf) {
+    struct GL_HMAC_CTX hmac_ctx;
+    char block[GL_HMAC_BLOCKSIZE];
+
+    memset(block, pad, sizeof block);
+    memxor(block, key, keylen);
+
+    GL_HMAC_FN_INIT(&hmac_ctx);
+    GL_HMAC_FN_BLOC(block, sizeof block, &hmac_ctx);
+    GL_HMAC_FN_PROC(in, inlen, &hmac_ctx);
+    GL_HMAC_FN_FINI(&hmac_ctx, resbuf);
+}
+
+int GL_HMAC_FN(const void* key, size_t keylen, const void* in, size_t inlen, void* resbuf) {
+    char optkeybuf[GL_HMAC_HASHSIZE];
+    char innerhash[GL_HMAC_HASHSIZE];
+
+    /* Ensure key size is <= block size.  */
+    if(keylen > GL_HMAC_BLOCKSIZE) {
+        struct GL_HMAC_CTX keyhash;
+
+        GL_HMAC_FN_INIT(&keyhash);
+        GL_HMAC_FN_PROC(key, keylen, &keyhash);
+        GL_HMAC_FN_FINI(&keyhash, optkeybuf);
+
+        key = optkeybuf;
+        /* zero padding of the key to the block size
+         is implicit in the memxor.  */
+        keylen = sizeof optkeybuf;
+    }
+
+    /* Compute INNERHASH from KEY and IN.  */
+    hmac_hash(key, keylen, in, inlen, IPAD, innerhash);
+
+    /* Compute result from KEY and INNERHASH.  */
+    hmac_hash(key, keylen, innerhash, sizeof innerhash, OPAD, resbuf);
+
+    return 0;
+}

applications/plugins/totp/services/hmac/hmac_sha1.c

@@ -0,0 +1,24 @@
+/* hmac_sha1.c -- hashed message authentication codes
+   Copyright (C) 2018-2022 Free Software Foundation, Inc.
+
+   This file is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as
+   published by the Free Software Foundation; either version 2.1 of the
+   License, or (at your option) any later version.
+
+   This file is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
+
+#include "hmac_sha1.h"
+
+#include "sha1.h"
+
+#define GL_HMAC_NAME 1
+#define GL_HMAC_BLOCKSIZE 64
+#define GL_HMAC_HASHSIZE 20
+#include "hmac_common.h"

applications/plugins/totp/services/hmac/hmac_sha1.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <stddef.h>
+
+#define HMAC_SHA1_RESULT_SIZE 20
+
+/* Compute Hashed Message Authentication Code with SHA-1, over BUFFER
+   data of BUFLEN bytes using the KEY of KEYLEN bytes, writing the
+   output to pre-allocated 20 byte minimum RESBUF buffer.  Return 0 on
+   success.  */
+int hmac_sha1(const void* key, size_t keylen, const void* in, size_t inlen, void* restrict resbuf);

applications/plugins/totp/services/hmac/hmac_sha256.c

@@ -0,0 +1,23 @@
+/* hmac_sha256.c -- hashed message authentication codes
+   Copyright (C) 2018-2022 Free Software Foundation, Inc.
+
+   This file is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as
+   published by the Free Software Foundation; either version 2.1 of the
+   License, or (at your option) any later version.
+
+   This file is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
+
+#include "hmac_sha256.h"
+
+#define GL_HMAC_NAME 256
+#define GL_HMAC_BLOCKSIZE 64
+#define GL_HMAC_HASHSIZE 32
+
+#include "hmac_common.h"

applications/plugins/totp/services/hmac/hmac_sha256.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <stddef.h>
+
+#define HMAC_SHA256_RESULT_SIZE 32
+
+/* Compute Hashed Message Authentication Code with SHA-256, over BUFFER
+   data of BUFLEN bytes using the KEY of KEYLEN bytes, writing the
+   output to pre-allocated 32 byte minimum RESBUF buffer.  Return 0 on
+   success.  */
+int hmac_sha256(const void* key, size_t keylen, const void* in, size_t inlen, void* restrict resbuf);

applications/plugins/totp/services/hmac/hmac_sha512.c

@@ -0,0 +1,24 @@
+/* hmac_sha512.c -- hashed message authentication codes
+   Copyright (C) 2018-2022 Free Software Foundation, Inc.
+
+   This file is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as
+   published by the Free Software Foundation; either version 2.1 of the
+   License, or (at your option) any later version.
+
+   This file is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
+
+#include "hmac_sha512.h"
+
+#include "sha512.h"
+
+#define GL_HMAC_NAME 512
+#define GL_HMAC_BLOCKSIZE 128
+#define GL_HMAC_HASHSIZE 64
+#include "hmac_common.h"

applications/plugins/totp/services/hmac/hmac_sha512.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <stddef.h>
+
+#define HMAC_SHA512_RESULT_SIZE 64
+
+/* Compute Hashed Message Authentication Code with SHA-512, over BUFFER
+   data of BUFLEN bytes using the KEY of KEYLEN bytes, writing the
+   output to pre-allocated 64 byte minimum RESBUF buffer.  Return 0 on
+   success.  */
+int hmac_sha512(const void* key, size_t keylen, const void* in, size_t inlen, void* restrict resbuf);

applications/plugins/totp/services/hmac/memxor.c

@@ -0,0 +1,32 @@
+/* memxor.c -- perform binary exclusive OR operation of two memory blocks.
+   Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
+
+/* Written by Simon Josefsson.  The interface was inspired by memxor
+   in Niels Möller's Nettle. */
+
+/* #include <config.h> */
+
+#include "memxor.h"
+
+void* memxor(void* /*restrict*/ dest, const void* /*restrict*/ src, size_t n) {
+    char const* s = (char const*)src;
+    char* d = (char*)dest;
+
+    for(; n > 0; n--) *d++ ^= *s++;
+
+    return dest;
+}

applications/plugins/totp/services/hmac/memxor.h

@@ -0,0 +1,28 @@
+/* memxor.h -- perform binary exclusive OR operation on memory blocks.
+   Copyright (C) 2005 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
+
+/* Written by Simon Josefsson.  The interface was inspired by memxor
+   in Niels Möller's Nettle. */
+
+#pragma once
+
+#include <stddef.h>
+
+/* Compute binary exclusive OR of memory areas DEST and SRC, putting
+   the result in DEST, of length N bytes.  Returns a pointer to
+   DEST. */
+void* memxor(void* /*restrict*/ dest, const void* /*restrict*/ src, size_t n);

applications/plugins/totp/services/hmac/sha1.c

@@ -0,0 +1,331 @@
+/* sha1.c - Functions to compute SHA1 message digest of files or
+   memory blocks according to the NIST specification FIPS-180-1.
+
+   Copyright (C) 2000-2001, 2003-2006, 2008-2022 Free Software Foundation, Inc.
+
+   This file is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as
+   published by the Free Software Foundation; either version 2.1 of the
+   License, or (at your option) any later version.
+
+   This file is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
+
+/* Written by Scott G. Miller
+   Credits:
+      Robert Klep <robert@ilse.nl>  -- Expansion function fix
+*/
+
+/* Specification.  */
+#if HAVE_OPENSSL_SHA1
+#define GL_OPENSSL_INLINE _GL_EXTERN_INLINE
+#endif
+#include "sha1.h"
+
+#include <stdint.h>
+#include <string.h>
+
+#ifdef WORDS_BIGENDIAN
+#define SWAP(n) (n)
+#else
+#include "byteswap.h"
+#define SWAP(n) swap_uint32(n)
+#endif
+
+#if !HAVE_OPENSSL_SHA1
+
+/* This array contains the bytes used to pad the buffer to the next
+   64-byte boundary.  (RFC 1321, 3.1: Step 1)  */
+static const unsigned char fillbuf[64] = {0x80, 0 /* , 0, 0, ...  */};
+
+/* Take a pointer to a 160 bit block of data (five 32 bit ints) and
+   initialize it to the start constants of the SHA1 algorithm.  This
+   must be called before using hash in the call to sha1_hash.  */
+void sha1_init_ctx(struct sha1_ctx* ctx) {
+    ctx->A = 0x67452301;
+    ctx->B = 0xefcdab89;
+    ctx->C = 0x98badcfe;
+    ctx->D = 0x10325476;
+    ctx->E = 0xc3d2e1f0;
+
+    ctx->total[0] = ctx->total[1] = 0;
+    ctx->buflen = 0;
+}
+
+/* Copy the 4 byte value from v into the memory location pointed to by *cp,
+   If your architecture allows unaligned access this is equivalent to
+   * (uint32_t *) cp = v  */
+static void set_uint32(char* cp, uint32_t v) {
+    memcpy(cp, &v, sizeof v);
+}
+
+/* Put result from CTX in first 20 bytes following RESBUF.  The result
+   must be in little endian byte order.  */
+void* sha1_read_ctx(const struct sha1_ctx* ctx, void* resbuf) {
+    char* r = resbuf;
+    set_uint32(r + 0 * sizeof ctx->A, SWAP(ctx->A));
+    set_uint32(r + 1 * sizeof ctx->B, SWAP(ctx->B));
+    set_uint32(r + 2 * sizeof ctx->C, SWAP(ctx->C));
+    set_uint32(r + 3 * sizeof ctx->D, SWAP(ctx->D));
+    set_uint32(r + 4 * sizeof ctx->E, SWAP(ctx->E));
+
+    return resbuf;
+}
+
+/* Process the remaining bytes in the internal buffer and the usual
+   prolog according to the standard and write the result to RESBUF.  */
+void* sha1_finish_ctx(struct sha1_ctx* ctx, void* resbuf) {
+    /* Take yet unprocessed bytes into account.  */
+    uint32_t bytes = ctx->buflen;
+    size_t size = (bytes < 56) ? 64 / 4 : 64 * 2 / 4;
+
+    /* Now count remaining bytes.  */
+    ctx->total[0] += bytes;
+    if(ctx->total[0] < bytes) ++ctx->total[1];
+
+    /* Put the 64-bit file length in *bits* at the end of the buffer.  */
+    ctx->buffer[size - 2] = SWAP((ctx->total[1] << 3) | (ctx->total[0] >> 29));
+    ctx->buffer[size - 1] = SWAP(ctx->total[0] << 3);
+
+    memcpy(&((char*)ctx->buffer)[bytes], fillbuf, (size - 2) * 4 - bytes);
+
+    /* Process last bytes.  */
+    sha1_process_block(ctx->buffer, size * 4, ctx);
+
+    return sha1_read_ctx(ctx, resbuf);
+}
+
+/* Compute SHA1 message digest for LEN bytes beginning at BUFFER.  The
+   result is always in little endian byte order, so that a byte-wise
+   output yields to the wanted ASCII representation of the message
+   digest.  */
+void* sha1_buffer(const char* buffer, size_t len, void* resblock) {
+    struct sha1_ctx ctx;
+
+    /* Initialize the computation context.  */
+    sha1_init_ctx(&ctx);
+
+    /* Process whole buffer but last len % 64 bytes.  */
+    sha1_process_bytes(buffer, len, &ctx);
+
+    /* Put result in desired memory area.  */
+    return sha1_finish_ctx(&ctx, resblock);
+}
+
+void sha1_process_bytes(const void* buffer, size_t len, struct sha1_ctx* ctx) {
+    /* When we already have some bits in our internal buffer concatenate
+     both inputs first.  */
+    if(ctx->buflen != 0) {
+        size_t left_over = ctx->buflen;
+        size_t add = 128 - left_over > len ? len : 128 - left_over;
+
+        memcpy(&((char*)ctx->buffer)[left_over], buffer, add);
+        ctx->buflen += add;
+
+        if(ctx->buflen > 64) {
+            sha1_process_block(ctx->buffer, ctx->buflen & ~63, ctx);
+
+            ctx->buflen &= 63;
+            /* The regions in the following copy operation cannot overlap,
+             because ctx->buflen < 64 ≤ (left_over + add) & ~63.  */
+            memcpy(ctx->buffer, &((char*)ctx->buffer)[(left_over + add) & ~63], ctx->buflen);
+        }
+
+        buffer = (const char*)buffer + add;
+        len -= add;
+    }
+
+    /* Process available complete blocks.  */
+    if(len >= 64) {
+#if !(_STRING_ARCH_unaligned || _STRING_INLINE_unaligned)
+#define UNALIGNED_P(p) ((uintptr_t)(p) % sizeof(uint32_t) != 0)
+        if(UNALIGNED_P(buffer))
+            while(len > 64) {
+                sha1_process_block(memcpy(ctx->buffer, buffer, 64), 64, ctx);
+                buffer = (const char*)buffer + 64;
+                len -= 64;
+            }
+        else
+#endif
+        {
+            sha1_process_block(buffer, len & ~63, ctx);
+            buffer = (const char*)buffer + (len & ~63);
+            len &= 63;
+        }
+    }
+
+    /* Move remaining bytes in internal buffer.  */
+    if(len > 0) {
+        size_t left_over = ctx->buflen;
+
+        memcpy(&((char*)ctx->buffer)[left_over], buffer, len);
+        left_over += len;
+        if(left_over >= 64) {
+            sha1_process_block(ctx->buffer, 64, ctx);
+            left_over -= 64;
+            /* The regions in the following copy operation cannot overlap,
+             because left_over ≤ 64.  */
+            memcpy(ctx->buffer, &ctx->buffer[16], left_over);
+        }
+        ctx->buflen = left_over;
+    }
+}
+
+/* --- Code below is the primary difference between md5.c and sha1.c --- */
+
+/* SHA1 round constants */
+#define K1 0x5a827999
+#define K2 0x6ed9eba1
+#define K3 0x8f1bbcdc
+#define K4 0xca62c1d6
+
+/* Round functions.  Note that F2 is the same as F4.  */
+#define F1(B, C, D) (D ^ (B & (C ^ D)))
+#define F2(B, C, D) (B ^ C ^ D)
+#define F3(B, C, D) ((B & C) | (D & (B | C)))
+#define F4(B, C, D) (B ^ C ^ D)
+
+/* Process LEN bytes of BUFFER, accumulating context into CTX.
+   It is assumed that LEN % 64 == 0.
+   Most of this code comes from GnuPG's cipher/sha1.c.  */
+
+void sha1_process_block(const void* buffer, size_t len, struct sha1_ctx* ctx) {
+    const uint32_t* words = buffer;
+    size_t nwords = len / sizeof(uint32_t);
+    const uint32_t* endp = words + nwords;
+    uint32_t x[16];
+    uint32_t a = ctx->A;
+    uint32_t b = ctx->B;
+    uint32_t c = ctx->C;
+    uint32_t d = ctx->D;
+    uint32_t e = ctx->E;
+    uint32_t lolen = len;
+
+    /* First increment the byte count.  RFC 1321 specifies the possible
+     length of the file up to 2^64 bits.  Here we only compute the
+     number of bytes.  Do a double word increment.  */
+    ctx->total[0] += lolen;
+    ctx->total[1] += (len >> 31 >> 1) + (ctx->total[0] < lolen);
+
+#define rol(x, n) (((x) << (n)) | ((uint32_t)(x) >> (32 - (n))))
+
+#define M(I)                                                                        \
+    (tm = x[I & 0x0f] ^ x[(I - 14) & 0x0f] ^ x[(I - 8) & 0x0f] ^ x[(I - 3) & 0x0f], \
+     (x[I & 0x0f] = rol(tm, 1)))
+
+#define R(A, B, C, D, E, F, K, M)            \
+    do {                                     \
+        E += rol(A, 5) + F(B, C, D) + K + M; \
+        B = rol(B, 30);                      \
+    } while(0)
+
+    while(words < endp) {
+        uint32_t tm;
+        int t;
+        for(t = 0; t < 16; t++) {
+            x[t] = SWAP(*words);
+            words++;
+        }
+
+        R(a, b, c, d, e, F1, K1, x[0]);
+        R(e, a, b, c, d, F1, K1, x[1]);
+        R(d, e, a, b, c, F1, K1, x[2]);
+        R(c, d, e, a, b, F1, K1, x[3]);
+        R(b, c, d, e, a, F1, K1, x[4]);
+        R(a, b, c, d, e, F1, K1, x[5]);
+        R(e, a, b, c, d, F1, K1, x[6]);
+        R(d, e, a, b, c, F1, K1, x[7]);
+        R(c, d, e, a, b, F1, K1, x[8]);
+        R(b, c, d, e, a, F1, K1, x[9]);
+        R(a, b, c, d, e, F1, K1, x[10]);
+        R(e, a, b, c, d, F1, K1, x[11]);
+        R(d, e, a, b, c, F1, K1, x[12]);
+        R(c, d, e, a, b, F1, K1, x[13]);
+        R(b, c, d, e, a, F1, K1, x[14]);
+        R(a, b, c, d, e, F1, K1, x[15]);
+        R(e, a, b, c, d, F1, K1, M(16));
+        R(d, e, a, b, c, F1, K1, M(17));
+        R(c, d, e, a, b, F1, K1, M(18));
+        R(b, c, d, e, a, F1, K1, M(19));
+        R(a, b, c, d, e, F2, K2, M(20));
+        R(e, a, b, c, d, F2, K2, M(21));
+        R(d, e, a, b, c, F2, K2, M(22));
+        R(c, d, e, a, b, F2, K2, M(23));
+        R(b, c, d, e, a, F2, K2, M(24));
+        R(a, b, c, d, e, F2, K2, M(25));
+        R(e, a, b, c, d, F2, K2, M(26));
+        R(d, e, a, b, c, F2, K2, M(27));
+        R(c, d, e, a, b, F2, K2, M(28));
+        R(b, c, d, e, a, F2, K2, M(29));
+        R(a, b, c, d, e, F2, K2, M(30));
+        R(e, a, b, c, d, F2, K2, M(31));
+        R(d, e, a, b, c, F2, K2, M(32));
+        R(c, d, e, a, b, F2, K2, M(33));
+        R(b, c, d, e, a, F2, K2, M(34));
+        R(a, b, c, d, e, F2, K2, M(35));
+        R(e, a, b, c, d, F2, K2, M(36));
+        R(d, e, a, b, c, F2, K2, M(37));
+        R(c, d, e, a, b, F2, K2, M(38));
+        R(b, c, d, e, a, F2, K2, M(39));
+        R(a, b, c, d, e, F3, K3, M(40));
+        R(e, a, b, c, d, F3, K3, M(41));
+        R(d, e, a, b, c, F3, K3, M(42));
+        R(c, d, e, a, b, F3, K3, M(43));
+        R(b, c, d, e, a, F3, K3, M(44));
+        R(a, b, c, d, e, F3, K3, M(45));
+        R(e, a, b, c, d, F3, K3, M(46));
+        R(d, e, a, b, c, F3, K3, M(47));
+        R(c, d, e, a, b, F3, K3, M(48));
+        R(b, c, d, e, a, F3, K3, M(49));
+        R(a, b, c, d, e, F3, K3, M(50));
+        R(e, a, b, c, d, F3, K3, M(51));
+        R(d, e, a, b, c, F3, K3, M(52));
+        R(c, d, e, a, b, F3, K3, M(53));
+        R(b, c, d, e, a, F3, K3, M(54));
+        R(a, b, c, d, e, F3, K3, M(55));
+        R(e, a, b, c, d, F3, K3, M(56));
+        R(d, e, a, b, c, F3, K3, M(57));
+        R(c, d, e, a, b, F3, K3, M(58));
+        R(b, c, d, e, a, F3, K3, M(59));
+        R(a, b, c, d, e, F4, K4, M(60));
+        R(e, a, b, c, d, F4, K4, M(61));
+        R(d, e, a, b, c, F4, K4, M(62));
+        R(c, d, e, a, b, F4, K4, M(63));
+        R(b, c, d, e, a, F4, K4, M(64));
+        R(a, b, c, d, e, F4, K4, M(65));
+        R(e, a, b, c, d, F4, K4, M(66));
+        R(d, e, a, b, c, F4, K4, M(67));
+        R(c, d, e, a, b, F4, K4, M(68));
+        R(b, c, d, e, a, F4, K4, M(69));
+        R(a, b, c, d, e, F4, K4, M(70));
+        R(e, a, b, c, d, F4, K4, M(71));
+        R(d, e, a, b, c, F4, K4, M(72));
+        R(c, d, e, a, b, F4, K4, M(73));
+        R(b, c, d, e, a, F4, K4, M(74));
+        R(a, b, c, d, e, F4, K4, M(75));
+        R(e, a, b, c, d, F4, K4, M(76));
+        R(d, e, a, b, c, F4, K4, M(77));
+        R(c, d, e, a, b, F4, K4, M(78));
+        R(b, c, d, e, a, F4, K4, M(79));
+
+        a = ctx->A += a;
+        b = ctx->B += b;
+        c = ctx->C += c;
+        d = ctx->D += d;
+        e = ctx->E += e;
+    }
+}
+
+#endif
+
+/*
+ * Hey Emacs!
+ * Local Variables:
+ * coding: utf-8
+ * End:
+ */

applications/plugins/totp/services/hmac/sha1.h

@@ -0,0 +1,105 @@
+/* Declarations of functions and data types used for SHA1 sum
+   library functions.
+   Copyright (C) 2000-2001, 2003, 2005-2006, 2008-2022 Free Software
+   Foundation, Inc.
+
+   This file is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as
+   published by the Free Software Foundation; either version 2.1 of the
+   License, or (at your option) any later version.
+
+   This file is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
+
+#pragma once
+
+#include <stdio.h>
+#include <stdint.h>
+
+#if HAVE_OPENSSL_SHA1
+#ifndef OPENSSL_API_COMPAT
+#define OPENSSL_API_COMPAT 0x10101000L /* FIXME: Use OpenSSL 1.1+ API.  */
+#endif
+#include <openssl/sha.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SHA1_DIGEST_SIZE 20
+
+#if HAVE_OPENSSL_SHA1
+#define GL_OPENSSL_NAME 1
+#include "gl_openssl.h"
+#else
+/* Structure to save state of computation between the single steps.  */
+struct sha1_ctx {
+    uint32_t A;
+    uint32_t B;
+    uint32_t C;
+    uint32_t D;
+    uint32_t E;
+
+    uint32_t total[2];
+    uint32_t buflen; /* ≥ 0, ≤ 128 */
+    uint32_t buffer[32]; /* 128 bytes; the first buflen bytes are in use */
+};
+
+/* Initialize structure containing state of computation. */
+extern void sha1_init_ctx(struct sha1_ctx* ctx);
+
+/* Starting with the result of former calls of this function (or the
+   initialization function update the context for the next LEN bytes
+   starting at BUFFER.
+   It is necessary that LEN is a multiple of 64!!! */
+extern void sha1_process_block(const void* buffer, size_t len, struct sha1_ctx* ctx);
+
+/* Starting with the result of former calls of this function (or the
+   initialization function update the context for the next LEN bytes
+   starting at BUFFER.
+   It is NOT required that LEN is a multiple of 64.  */
+extern void sha1_process_bytes(const void* buffer, size_t len, struct sha1_ctx* ctx);
+
+/* Process the remaining bytes in the buffer and put result from CTX
+   in first 20 bytes following RESBUF.  The result is always in little
+   endian byte order, so that a byte-wise output yields to the wanted
+   ASCII representation of the message digest.  */
+extern void* sha1_finish_ctx(struct sha1_ctx* ctx, void* restrict resbuf);
+
+/* Put result from CTX in first 20 bytes following RESBUF.  The result is
+   always in little endian byte order, so that a byte-wise output yields
+   to the wanted ASCII representation of the message digest.  */
+extern void* sha1_read_ctx(const struct sha1_ctx* ctx, void* restrict resbuf);
+
+/* Compute SHA1 message digest for LEN bytes beginning at BUFFER.  The
+   result is always in little endian byte order, so that a byte-wise
+   output yields to the wanted ASCII representation of the message
+   digest.  */
+extern void* sha1_buffer(const char* buffer, size_t len, void* restrict resblock);
+
+#endif
+
+/* Compute SHA1 message digest for bytes read from STREAM.
+   STREAM is an open file stream.  Regular files are handled more efficiently.
+   The contents of STREAM from its current position to its end will be read.
+   The case that the last operation on STREAM was an 'ungetc' is not supported.
+   The resulting message digest number will be written into the 20 bytes
+   beginning at RESBLOCK.  */
+extern int sha1_stream(FILE* stream, void* resblock);
+
+#ifdef __cplusplus
+}
+#endif
+
+/*
+ * Hey Emacs!
+ * Local Variables:
+ * coding: utf-8
+ * End:
+ */

applications/plugins/totp/services/hmac/sha256.c

@@ -0,0 +1,385 @@
+/* sha256.c - Functions to compute SHA256 and SHA224 message digest of files or
+   memory blocks according to the NIST specification FIPS-180-2.
+
+   Copyright (C) 2005-2006, 2008-2022 Free Software Foundation, Inc.
+
+   This file is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as
+   published by the Free Software Foundation; either version 2.1 of the
+   License, or (at your option) any later version.
+
+   This file is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
+
+/* Written by David Madore, considerably copypasting from
+   Scott G. Miller's sha1.c
+*/
+
+/* Specification.  */
+#if HAVE_OPENSSL_SHA256
+#define GL_OPENSSL_INLINE _GL_EXTERN_INLINE
+#endif
+#include "sha256.h"
+
+#include <stdint.h>
+#include <string.h>
+
+#ifdef WORDS_BIGENDIAN
+#define SWAP(n) (n)
+#else
+#include "byteswap.h"
+#define SWAP(n) swap_uint32(n)
+#endif
+
+#if !HAVE_OPENSSL_SHA256
+
+/* This array contains the bytes used to pad the buffer to the next
+   64-byte boundary.  */
+static const unsigned char fillbuf[64] = {0x80, 0 /* , 0, 0, ...  */};
+
+/*
+  Takes a pointer to a 256 bit block of data (eight 32 bit ints) and
+  initializes it to the start constants of the SHA256 algorithm.  This
+  must be called before using hash in the call to sha256_hash
+*/
+void sha256_init_ctx(struct sha256_ctx* ctx) {
+    ctx->state[0] = 0x6a09e667UL;
+    ctx->state[1] = 0xbb67ae85UL;
+    ctx->state[2] = 0x3c6ef372UL;
+    ctx->state[3] = 0xa54ff53aUL;
+    ctx->state[4] = 0x510e527fUL;
+    ctx->state[5] = 0x9b05688cUL;
+    ctx->state[6] = 0x1f83d9abUL;
+    ctx->state[7] = 0x5be0cd19UL;
+
+    ctx->total[0] = ctx->total[1] = 0;
+    ctx->buflen = 0;
+}
+
+void sha224_init_ctx(struct sha256_ctx* ctx) {
+    ctx->state[0] = 0xc1059ed8UL;
+    ctx->state[1] = 0x367cd507UL;
+    ctx->state[2] = 0x3070dd17UL;
+    ctx->state[3] = 0xf70e5939UL;
+    ctx->state[4] = 0xffc00b31UL;
+    ctx->state[5] = 0x68581511UL;
+    ctx->state[6] = 0x64f98fa7UL;
+    ctx->state[7] = 0xbefa4fa4UL;
+
+    ctx->total[0] = ctx->total[1] = 0;
+    ctx->buflen = 0;
+}
+
+/* Copy the value from v into the memory location pointed to by *CP,
+   If your architecture allows unaligned access, this is equivalent to
+   * (__typeof__ (v) *) cp = v  */
+static void set_uint32(char* cp, uint32_t v) {
+    memcpy(cp, &v, sizeof v);
+}
+
+/* Put result from CTX in first 32 bytes following RESBUF.
+   The result must be in little endian byte order.  */
+void* sha256_read_ctx(const struct sha256_ctx* ctx, void* resbuf) {
+    int i;
+    char* r = resbuf;
+
+    for(i = 0; i < 8; i++) set_uint32(r + i * sizeof ctx->state[0], SWAP(ctx->state[i]));
+
+    return resbuf;
+}
+
+void* sha224_read_ctx(const struct sha256_ctx* ctx, void* resbuf) {
+    int i;
+    char* r = resbuf;
+
+    for(i = 0; i < 7; i++) set_uint32(r + i * sizeof ctx->state[0], SWAP(ctx->state[i]));
+
+    return resbuf;
+}
+
+/* Process the remaining bytes in the internal buffer and the usual
+   prolog according to the standard and write the result to RESBUF.  */
+static void sha256_conclude_ctx(struct sha256_ctx* ctx) {
+    /* Take yet unprocessed bytes into account.  */
+    size_t bytes = ctx->buflen;
+    size_t size = (bytes < 56) ? 64 / 4 : 64 * 2 / 4;
+
+    /* Now count remaining bytes.  */
+    ctx->total[0] += bytes;
+    if(ctx->total[0] < bytes) ++ctx->total[1];
+
+    /* Put the 64-bit file length in *bits* at the end of the buffer.
+     Use set_uint32 rather than a simple assignment, to avoid risk of
+     unaligned access.  */
+    set_uint32((char*)&ctx->buffer[size - 2], SWAP((ctx->total[1] << 3) | (ctx->total[0] >> 29)));
+    set_uint32((char*)&ctx->buffer[size - 1], SWAP(ctx->total[0] << 3));
+
+    memcpy(&((char*)ctx->buffer)[bytes], fillbuf, (size - 2) * 4 - bytes);
+
+    /* Process last bytes.  */
+    sha256_process_block(ctx->buffer, size * 4, ctx);
+}
+
+void* sha256_finish_ctx(struct sha256_ctx* ctx, void* resbuf) {
+    sha256_conclude_ctx(ctx);
+    return sha256_read_ctx(ctx, resbuf);
+}
+
+void* sha224_finish_ctx(struct sha256_ctx* ctx, void* resbuf) {
+    sha256_conclude_ctx(ctx);
+    return sha224_read_ctx(ctx, resbuf);
+}
+
+/* Compute SHA256 message digest for LEN bytes beginning at BUFFER.  The
+   result is always in little endian byte order, so that a byte-wise
+   output yields to the wanted ASCII representation of the message
+   digest.  */
+void* sha256_buffer(const char* buffer, size_t len, void* resblock) {
+    struct sha256_ctx ctx;
+
+    /* Initialize the computation context.  */
+    sha256_init_ctx(&ctx);
+
+    /* Process whole buffer but last len % 64 bytes.  */
+    sha256_process_bytes(buffer, len, &ctx);
+
+    /* Put result in desired memory area.  */
+    return sha256_finish_ctx(&ctx, resblock);
+}
+
+void* sha224_buffer(const char* buffer, size_t len, void* resblock) {
+    struct sha256_ctx ctx;
+
+    /* Initialize the computation context.  */
+    sha224_init_ctx(&ctx);
+
+    /* Process whole buffer but last len % 64 bytes.  */
+    sha256_process_bytes(buffer, len, &ctx);
+
+    /* Put result in desired memory area.  */
+    return sha224_finish_ctx(&ctx, resblock);
+}
+
+void sha256_process_bytes(const void* buffer, size_t len, struct sha256_ctx* ctx) {
+    /* When we already have some bits in our internal buffer concatenate
+     both inputs first.  */
+    if(ctx->buflen != 0) {
+        size_t left_over = ctx->buflen;
+        size_t add = 128 - left_over > len ? len : 128 - left_over;
+
+        memcpy(&((char*)ctx->buffer)[left_over], buffer, add);
+        ctx->buflen += add;
+
+        if(ctx->buflen > 64) {
+            sha256_process_block(ctx->buffer, ctx->buflen & ~63, ctx);
+
+            ctx->buflen &= 63;
+            /* The regions in the following copy operation cannot overlap,
+             because ctx->buflen < 64 ≤ (left_over + add) & ~63.  */
+            memcpy(ctx->buffer, &((char*)ctx->buffer)[(left_over + add) & ~63], ctx->buflen);
+        }
+
+        buffer = (const char*)buffer + add;
+        len -= add;
+    }
+
+    /* Process available complete blocks.  */
+    if(len >= 64) {
+#if !(_STRING_ARCH_unaligned || _STRING_INLINE_unaligned)
+#define UNALIGNED_P(p) ((uintptr_t)(p) % sizeof(uint32_t) != 0)
+        if(UNALIGNED_P(buffer))
+            while(len > 64) {
+                sha256_process_block(memcpy(ctx->buffer, buffer, 64), 64, ctx);
+                buffer = (const char*)buffer + 64;
+                len -= 64;
+            }
+        else
+#endif
+        {
+            sha256_process_block(buffer, len & ~63, ctx);
+            buffer = (const char*)buffer + (len & ~63);
+            len &= 63;
+        }
+    }
+
+    /* Move remaining bytes in internal buffer.  */
+    if(len > 0) {
+        size_t left_over = ctx->buflen;
+
+        memcpy(&((char*)ctx->buffer)[left_over], buffer, len);
+        left_over += len;
+        if(left_over >= 64) {
+            sha256_process_block(ctx->buffer, 64, ctx);
+            left_over -= 64;
+            /* The regions in the following copy operation cannot overlap,
+             because left_over ≤ 64.  */
+            memcpy(ctx->buffer, &ctx->buffer[16], left_over);
+        }
+        ctx->buflen = left_over;
+    }
+}
+
+/* --- Code below is the primary difference between sha1.c and sha256.c --- */
+
+/* SHA256 round constants */
+#define K(I) sha256_round_constants[I]
+static const uint32_t sha256_round_constants[64] = {
+    0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL, 0x3956c25bUL, 0x59f111f1UL,
+    0x923f82a4UL, 0xab1c5ed5UL, 0xd807aa98UL, 0x12835b01UL, 0x243185beUL, 0x550c7dc3UL,
+    0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL, 0xc19bf174UL, 0xe49b69c1UL, 0xefbe4786UL,
+    0x0fc19dc6UL, 0x240ca1ccUL, 0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL,
+    0x983e5152UL, 0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL, 0xc6e00bf3UL, 0xd5a79147UL,
+    0x06ca6351UL, 0x14292967UL, 0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL, 0x53380d13UL,
+    0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL, 0xa2bfe8a1UL, 0xa81a664bUL,
+    0xc24b8b70UL, 0xc76c51a3UL, 0xd192e819UL, 0xd6990624UL, 0xf40e3585UL, 0x106aa070UL,
+    0x19a4c116UL, 0x1e376c08UL, 0x2748774cUL, 0x34b0bcb5UL, 0x391c0cb3UL, 0x4ed8aa4aUL,
+    0x5b9cca4fUL, 0x682e6ff3UL, 0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL,
+    0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL,
+};
+
+/* Round functions.  */
+#define F2(A, B, C) ((A & B) | (C & (A | B)))
+#define F1(E, F, G) (G ^ (E & (F ^ G)))
+
+/* Process LEN bytes of BUFFER, accumulating context into CTX.
+   It is assumed that LEN % 64 == 0.
+   Most of this code comes from GnuPG's cipher/sha1.c.  */
+
+void sha256_process_block(const void* buffer, size_t len, struct sha256_ctx* ctx) {
+    const uint32_t* words = buffer;
+    size_t nwords = len / sizeof(uint32_t);
+    const uint32_t* endp = words + nwords;
+    uint32_t x[16];
+    uint32_t a = ctx->state[0];
+    uint32_t b = ctx->state[1];
+    uint32_t c = ctx->state[2];
+    uint32_t d = ctx->state[3];
+    uint32_t e = ctx->state[4];
+    uint32_t f = ctx->state[5];
+    uint32_t g = ctx->state[6];
+    uint32_t h = ctx->state[7];
+    uint32_t lolen = len;
+
+    /* First increment the byte count.  FIPS PUB 180-2 specifies the possible
+     length of the file up to 2^64 bits.  Here we only compute the
+     number of bytes.  Do a double word increment.  */
+    ctx->total[0] += lolen;
+    ctx->total[1] += (len >> 31 >> 1) + (ctx->total[0] < lolen);
+
+#define rol(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
+#define S0(x) (rol(x, 25) ^ rol(x, 14) ^ (x >> 3))
+#define S1(x) (rol(x, 15) ^ rol(x, 13) ^ (x >> 10))
+#define SS0(x) (rol(x, 30) ^ rol(x, 19) ^ rol(x, 10))
+#define SS1(x) (rol(x, 26) ^ rol(x, 21) ^ rol(x, 7))
+
+#define M(I)                                                                                \
+    (tm = S1(x[(I - 2) & 0x0f]) + x[(I - 7) & 0x0f] + S0(x[(I - 15) & 0x0f]) + x[I & 0x0f], \
+     x[I & 0x0f] = tm)
+
+#define R(A, B, C, D, E, F, G, H, K, M)        \
+    do {                                       \
+        t0 = SS0(A) + F2(A, B, C);             \
+        t1 = H + SS1(E) + F1(E, F, G) + K + M; \
+        D += t1;                               \
+        H = t0 + t1;                           \
+    } while(0)
+
+    while(words < endp) {
+        uint32_t tm;
+        uint32_t t0, t1;
+        int t;
+        /* FIXME: see sha1.c for a better implementation.  */
+        for(t = 0; t < 16; t++) {
+            x[t] = SWAP(*words);
+            words++;
+        }
+
+        R(a, b, c, d, e, f, g, h, K(0), x[0]);
+        R(h, a, b, c, d, e, f, g, K(1), x[1]);
+        R(g, h, a, b, c, d, e, f, K(2), x[2]);
+        R(f, g, h, a, b, c, d, e, K(3), x[3]);
+        R(e, f, g, h, a, b, c, d, K(4), x[4]);
+        R(d, e, f, g, h, a, b, c, K(5), x[5]);
+        R(c, d, e, f, g, h, a, b, K(6), x[6]);
+        R(b, c, d, e, f, g, h, a, K(7), x[7]);
+        R(a, b, c, d, e, f, g, h, K(8), x[8]);
+        R(h, a, b, c, d, e, f, g, K(9), x[9]);
+        R(g, h, a, b, c, d, e, f, K(10), x[10]);
+        R(f, g, h, a, b, c, d, e, K(11), x[11]);
+        R(e, f, g, h, a, b, c, d, K(12), x[12]);
+        R(d, e, f, g, h, a, b, c, K(13), x[13]);
+        R(c, d, e, f, g, h, a, b, K(14), x[14]);
+        R(b, c, d, e, f, g, h, a, K(15), x[15]);
+        R(a, b, c, d, e, f, g, h, K(16), M(16));
+        R(h, a, b, c, d, e, f, g, K(17), M(17));
+        R(g, h, a, b, c, d, e, f, K(18), M(18));
+        R(f, g, h, a, b, c, d, e, K(19), M(19));
+        R(e, f, g, h, a, b, c, d, K(20), M(20));
+        R(d, e, f, g, h, a, b, c, K(21), M(21));
+        R(c, d, e, f, g, h, a, b, K(22), M(22));
+        R(b, c, d, e, f, g, h, a, K(23), M(23));
+        R(a, b, c, d, e, f, g, h, K(24), M(24));
+        R(h, a, b, c, d, e, f, g, K(25), M(25));
+        R(g, h, a, b, c, d, e, f, K(26), M(26));
+        R(f, g, h, a, b, c, d, e, K(27), M(27));
+        R(e, f, g, h, a, b, c, d, K(28), M(28));
+        R(d, e, f, g, h, a, b, c, K(29), M(29));
+        R(c, d, e, f, g, h, a, b, K(30), M(30));
+        R(b, c, d, e, f, g, h, a, K(31), M(31));
+        R(a, b, c, d, e, f, g, h, K(32), M(32));
+        R(h, a, b, c, d, e, f, g, K(33), M(33));
+        R(g, h, a, b, c, d, e, f, K(34), M(34));
+        R(f, g, h, a, b, c, d, e, K(35), M(35));
+        R(e, f, g, h, a, b, c, d, K(36), M(36));
+        R(d, e, f, g, h, a, b, c, K(37), M(37));
+        R(c, d, e, f, g, h, a, b, K(38), M(38));
+        R(b, c, d, e, f, g, h, a, K(39), M(39));
+        R(a, b, c, d, e, f, g, h, K(40), M(40));
+        R(h, a, b, c, d, e, f, g, K(41), M(41));
+        R(g, h, a, b, c, d, e, f, K(42), M(42));
+        R(f, g, h, a, b, c, d, e, K(43), M(43));
+        R(e, f, g, h, a, b, c, d, K(44), M(44));
+        R(d, e, f, g, h, a, b, c, K(45), M(45));
+        R(c, d, e, f, g, h, a, b, K(46), M(46));
+        R(b, c, d, e, f, g, h, a, K(47), M(47));
+        R(a, b, c, d, e, f, g, h, K(48), M(48));
+        R(h, a, b, c, d, e, f, g, K(49), M(49));
+        R(g, h, a, b, c, d, e, f, K(50), M(50));
+        R(f, g, h, a, b, c, d, e, K(51), M(51));
+        R(e, f, g, h, a, b, c, d, K(52), M(52));
+        R(d, e, f, g, h, a, b, c, K(53), M(53));
+        R(c, d, e, f, g, h, a, b, K(54), M(54));
+        R(b, c, d, e, f, g, h, a, K(55), M(55));
+        R(a, b, c, d, e, f, g, h, K(56), M(56));
+        R(h, a, b, c, d, e, f, g, K(57), M(57));
+        R(g, h, a, b, c, d, e, f, K(58), M(58));
+        R(f, g, h, a, b, c, d, e, K(59), M(59));
+        R(e, f, g, h, a, b, c, d, K(60), M(60));
+        R(d, e, f, g, h, a, b, c, K(61), M(61));
+        R(c, d, e, f, g, h, a, b, K(62), M(62));
+        R(b, c, d, e, f, g, h, a, K(63), M(63));
+
+        a = ctx->state[0] += a;
+        b = ctx->state[1] += b;
+        c = ctx->state[2] += c;
+        d = ctx->state[3] += d;
+        e = ctx->state[4] += e;
+        f = ctx->state[5] += f;
+        g = ctx->state[6] += g;
+        h = ctx->state[7] += h;
+    }
+}
+
+#endif
+
+/*
+ * Hey Emacs!
+ * Local Variables:
+ * coding: utf-8
+ * End:
+ */

applications/plugins/totp/services/hmac/sha256.h

@@ -0,0 +1,108 @@
+/* Declarations of functions and data types used for SHA256 and SHA224 sum
+   library functions.
+   Copyright (C) 2005-2006, 2008-2022 Free Software Foundation, Inc.
+
+   This file is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as
+   published by the Free Software Foundation; either version 2.1 of the
+   License, or (at your option) any later version.
+
+   This file is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
+
+#pragma once
+
+#include <stdio.h>
+#include <stdint.h>
+
+#if HAVE_OPENSSL_SHA256
+#ifndef OPENSSL_API_COMPAT
+#define OPENSSL_API_COMPAT 0x10101000L /* FIXME: Use OpenSSL 1.1+ API.  */
+#endif
+#include <openssl/sha.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum { SHA224_DIGEST_SIZE = 224 / 8 };
+enum { SHA256_DIGEST_SIZE = 256 / 8 };
+
+#if HAVE_OPENSSL_SHA256
+#define GL_OPENSSL_NAME 224
+#include "gl_openssl.h"
+#define GL_OPENSSL_NAME 256
+#include "gl_openssl.h"
+#else
+/* Structure to save state of computation between the single steps.  */
+struct sha256_ctx {
+    uint32_t state[8];
+
+    uint32_t total[2];
+    size_t buflen; /* ≥ 0, ≤ 128 */
+    uint32_t buffer[32]; /* 128 bytes; the first buflen bytes are in use */
+};
+
+/* Initialize structure containing state of computation. */
+extern void sha256_init_ctx(struct sha256_ctx* ctx);
+extern void sha224_init_ctx(struct sha256_ctx* ctx);
+
+/* Starting with the result of former calls of this function (or the
+   initialization function update the context for the next LEN bytes
+   starting at BUFFER.
+   It is necessary that LEN is a multiple of 64!!! */
+extern void sha256_process_block(const void* buffer, size_t len, struct sha256_ctx* ctx);
+
+/* Starting with the result of former calls of this function (or the
+   initialization function update the context for the next LEN bytes
+   starting at BUFFER.
+   It is NOT required that LEN is a multiple of 64.  */
+extern void sha256_process_bytes(const void* buffer, size_t len, struct sha256_ctx* ctx);
+
+/* Process the remaining bytes in the buffer and put result from CTX
+   in first 32 (28) bytes following RESBUF.  The result is always in little
+   endian byte order, so that a byte-wise output yields to the wanted
+   ASCII representation of the message digest.  */
+extern void* sha256_finish_ctx(struct sha256_ctx* ctx, void* restrict resbuf);
+extern void* sha224_finish_ctx(struct sha256_ctx* ctx, void* restrict resbuf);
+
+/* Put result from CTX in first 32 (28) bytes following RESBUF.  The result is
+   always in little endian byte order, so that a byte-wise output yields
+   to the wanted ASCII representation of the message digest.  */
+extern void* sha256_read_ctx(const struct sha256_ctx* ctx, void* restrict resbuf);
+extern void* sha224_read_ctx(const struct sha256_ctx* ctx, void* restrict resbuf);
+
+/* Compute SHA256 (SHA224) message digest for LEN bytes beginning at BUFFER.
+   The result is always in little endian byte order, so that a byte-wise
+   output yields to the wanted ASCII representation of the message
+   digest.  */
+extern void* sha256_buffer(const char* buffer, size_t len, void* restrict resblock);
+extern void* sha224_buffer(const char* buffer, size_t len, void* restrict resblock);
+
+#endif
+
+/* Compute SHA256 (SHA224) message digest for bytes read from STREAM.
+   STREAM is an open file stream.  Regular files are handled more efficiently.
+   The contents of STREAM from its current position to its end will be read.
+   The case that the last operation on STREAM was an 'ungetc' is not supported.
+   The resulting message digest number will be written into the 32 (28) bytes
+   beginning at RESBLOCK.  */
+extern int sha256_stream(FILE* stream, void* resblock);
+extern int sha224_stream(FILE* stream, void* resblock);
+
+#ifdef __cplusplus
+}
+#endif
+
+/*
+ * Hey Emacs!
+ * Local Variables:
+ * coding: utf-8
+ * End:
+ */

applications/plugins/totp/services/hmac/sha512.c

@@ -0,0 +1,430 @@
+/* sha512.c - Functions to compute SHA512 and SHA384 message digest of files or
+   memory blocks according to the NIST specification FIPS-180-2.
+
+   Copyright (C) 2005-2006, 2008-2022 Free Software Foundation, Inc.
+
+   This file is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as
+   published by the Free Software Foundation; either version 2.1 of the
+   License, or (at your option) any later version.
+
+   This file is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
+
+/* Written by David Madore, considerably copypasting from
+   Scott G. Miller's sha1.c
+*/
+
+/* Specification.  */
+#if HAVE_OPENSSL_SHA512
+#define GL_OPENSSL_INLINE _GL_EXTERN_INLINE
+#endif
+#include "sha512.h"
+
+#include <stdint.h>
+#include <string.h>
+
+#ifdef WORDS_BIGENDIAN
+#define SWAP(n) (n)
+#else
+#include "byteswap.h"
+#define SWAP(n) swap_uint64(n)
+#endif
+
+#if !HAVE_OPENSSL_SHA512
+
+/* This array contains the bytes used to pad the buffer to the next
+   128-byte boundary.  */
+static const unsigned char fillbuf[128] = {0x80, 0 /* , 0, 0, ...  */};
+
+/*
+  Takes a pointer to a 512 bit block of data (eight 64 bit ints) and
+  initializes it to the start constants of the SHA512 algorithm.  This
+  must be called before using hash in the call to sha512_hash
+*/
+void sha512_init_ctx(struct sha512_ctx* ctx) {
+    ctx->state[0] = u64hilo(0x6a09e667, 0xf3bcc908);
+    ctx->state[1] = u64hilo(0xbb67ae85, 0x84caa73b);
+    ctx->state[2] = u64hilo(0x3c6ef372, 0xfe94f82b);
+    ctx->state[3] = u64hilo(0xa54ff53a, 0x5f1d36f1);
+    ctx->state[4] = u64hilo(0x510e527f, 0xade682d1);
+    ctx->state[5] = u64hilo(0x9b05688c, 0x2b3e6c1f);
+    ctx->state[6] = u64hilo(0x1f83d9ab, 0xfb41bd6b);
+    ctx->state[7] = u64hilo(0x5be0cd19, 0x137e2179);
+
+    ctx->total[0] = ctx->total[1] = u64lo(0);
+    ctx->buflen = 0;
+}
+
+void sha384_init_ctx(struct sha512_ctx* ctx) {
+    ctx->state[0] = u64hilo(0xcbbb9d5d, 0xc1059ed8);
+    ctx->state[1] = u64hilo(0x629a292a, 0x367cd507);
+    ctx->state[2] = u64hilo(0x9159015a, 0x3070dd17);
+    ctx->state[3] = u64hilo(0x152fecd8, 0xf70e5939);
+    ctx->state[4] = u64hilo(0x67332667, 0xffc00b31);
+    ctx->state[5] = u64hilo(0x8eb44a87, 0x68581511);
+    ctx->state[6] = u64hilo(0xdb0c2e0d, 0x64f98fa7);
+    ctx->state[7] = u64hilo(0x47b5481d, 0xbefa4fa4);
+
+    ctx->total[0] = ctx->total[1] = u64lo(0);
+    ctx->buflen = 0;
+}
+
+/* Copy the value from V into the memory location pointed to by *CP,
+   If your architecture allows unaligned access, this is equivalent to
+   * (__typeof__ (v) *) cp = v  */
+static void set_uint64(char* cp, u64 v) {
+    memcpy(cp, &v, sizeof v);
+}
+
+/* Put result from CTX in first 64 bytes following RESBUF.
+   The result must be in little endian byte order.  */
+void* sha512_read_ctx(const struct sha512_ctx* ctx, void* resbuf) {
+    int i;
+    char* r = resbuf;
+
+    for(i = 0; i < 8; i++) set_uint64(r + i * sizeof ctx->state[0], SWAP(ctx->state[i]));
+
+    return resbuf;
+}
+
+void* sha384_read_ctx(const struct sha512_ctx* ctx, void* resbuf) {
+    int i;
+    char* r = resbuf;
+
+    for(i = 0; i < 6; i++) set_uint64(r + i * sizeof ctx->state[0], SWAP(ctx->state[i]));
+
+    return resbuf;
+}
+
+/* Process the remaining bytes in the internal buffer and the usual
+   prolog according to the standard and write the result to RESBUF.  */
+static void sha512_conclude_ctx(struct sha512_ctx* ctx) {
+    /* Take yet unprocessed bytes into account.  */
+    size_t bytes = ctx->buflen;
+    size_t size = (bytes < 112) ? 128 / 8 : 128 * 2 / 8;
+
+    /* Now count remaining bytes.  */
+    ctx->total[0] = u64plus(ctx->total[0], u64lo(bytes));
+    if(u64lt(ctx->total[0], u64lo(bytes))) ctx->total[1] = u64plus(ctx->total[1], u64lo(1));
+
+    /* Put the 128-bit file length in *bits* at the end of the buffer.
+     Use set_uint64 rather than a simple assignment, to avoid risk of
+     unaligned access.  */
+    set_uint64(
+        (char*)&ctx->buffer[size - 2],
+        SWAP(u64or(u64shl(ctx->total[1], 3), u64shr(ctx->total[0], 61))));
+    set_uint64((char*)&ctx->buffer[size - 1], SWAP(u64shl(ctx->total[0], 3)));
+
+    memcpy(&((char*)ctx->buffer)[bytes], fillbuf, (size - 2) * 8 - bytes);
+
+    /* Process last bytes.  */
+    sha512_process_block(ctx->buffer, size * 8, ctx);
+}
+
+void* sha512_finish_ctx(struct sha512_ctx* ctx, void* resbuf) {
+    sha512_conclude_ctx(ctx);
+    return sha512_read_ctx(ctx, resbuf);
+}
+
+void* sha384_finish_ctx(struct sha512_ctx* ctx, void* resbuf) {
+    sha512_conclude_ctx(ctx);
+    return sha384_read_ctx(ctx, resbuf);
+}
+
+/* Compute SHA512 message digest for LEN bytes beginning at BUFFER.  The
+   result is always in little endian byte order, so that a byte-wise
+   output yields to the wanted ASCII representation of the message
+   digest.  */
+void* sha512_buffer(const char* buffer, size_t len, void* resblock) {
+    struct sha512_ctx ctx;
+
+    /* Initialize the computation context.  */
+    sha512_init_ctx(&ctx);
+
+    /* Process whole buffer but last len % 128 bytes.  */
+    sha512_process_bytes(buffer, len, &ctx);
+
+    /* Put result in desired memory area.  */
+    return sha512_finish_ctx(&ctx, resblock);
+}
+
+void* sha384_buffer(const char* buffer, size_t len, void* resblock) {
+    struct sha512_ctx ctx;
+
+    /* Initialize the computation context.  */
+    sha384_init_ctx(&ctx);
+
+    /* Process whole buffer but last len % 128 bytes.  */
+    sha512_process_bytes(buffer, len, &ctx);
+
+    /* Put result in desired memory area.  */
+    return sha384_finish_ctx(&ctx, resblock);
+}
+
+void sha512_process_bytes(const void* buffer, size_t len, struct sha512_ctx* ctx) {
+    /* When we already have some bits in our internal buffer concatenate
+     both inputs first.  */
+    if(ctx->buflen != 0) {
+        size_t left_over = ctx->buflen;
+        size_t add = 256 - left_over > len ? len : 256 - left_over;
+
+        memcpy(&((char*)ctx->buffer)[left_over], buffer, add);
+        ctx->buflen += add;
+
+        if(ctx->buflen > 128) {
+            sha512_process_block(ctx->buffer, ctx->buflen & ~127, ctx);
+
+            ctx->buflen &= 127;
+            /* The regions in the following copy operation cannot overlap,
+             because ctx->buflen < 128 ≤ (left_over + add) & ~127.  */
+            memcpy(ctx->buffer, &((char*)ctx->buffer)[(left_over + add) & ~127], ctx->buflen);
+        }
+
+        buffer = (const char*)buffer + add;
+        len -= add;
+    }
+
+    /* Process available complete blocks.  */
+    if(len >= 128) {
+#if !(_STRING_ARCH_unaligned || _STRING_INLINE_unaligned)
+#define UNALIGNED_P(p) ((uintptr_t)(p) % sizeof(u64) != 0)
+        if(UNALIGNED_P(buffer))
+            while(len > 128) {
+                sha512_process_block(memcpy(ctx->buffer, buffer, 128), 128, ctx);
+                buffer = (const char*)buffer + 128;
+                len -= 128;
+            }
+        else
+#endif
+        {
+            sha512_process_block(buffer, len & ~127, ctx);
+            buffer = (const char*)buffer + (len & ~127);
+            len &= 127;
+        }
+    }
+
+    /* Move remaining bytes in internal buffer.  */
+    if(len > 0) {
+        size_t left_over = ctx->buflen;
+
+        memcpy(&((char*)ctx->buffer)[left_over], buffer, len);
+        left_over += len;
+        if(left_over >= 128) {
+            sha512_process_block(ctx->buffer, 128, ctx);
+            left_over -= 128;
+            /* The regions in the following copy operation cannot overlap,
+             because left_over ≤ 128.  */
+            memcpy(ctx->buffer, &ctx->buffer[16], left_over);
+        }
+        ctx->buflen = left_over;
+    }
+}
+
+/* --- Code below is the primary difference between sha1.c and sha512.c --- */
+
+/* SHA512 round constants */
+#define K(I) sha512_round_constants[I]
+static u64 const sha512_round_constants[80] = {
+    u64init(0x428a2f98, 0xd728ae22), u64init(0x71374491, 0x23ef65cd),
+    u64init(0xb5c0fbcf, 0xec4d3b2f), u64init(0xe9b5dba5, 0x8189dbbc),
+    u64init(0x3956c25b, 0xf348b538), u64init(0x59f111f1, 0xb605d019),
+    u64init(0x923f82a4, 0xaf194f9b), u64init(0xab1c5ed5, 0xda6d8118),
+    u64init(0xd807aa98, 0xa3030242), u64init(0x12835b01, 0x45706fbe),
+    u64init(0x243185be, 0x4ee4b28c), u64init(0x550c7dc3, 0xd5ffb4e2),
+    u64init(0x72be5d74, 0xf27b896f), u64init(0x80deb1fe, 0x3b1696b1),
+    u64init(0x9bdc06a7, 0x25c71235), u64init(0xc19bf174, 0xcf692694),
+    u64init(0xe49b69c1, 0x9ef14ad2), u64init(0xefbe4786, 0x384f25e3),
+    u64init(0x0fc19dc6, 0x8b8cd5b5), u64init(0x240ca1cc, 0x77ac9c65),
+    u64init(0x2de92c6f, 0x592b0275), u64init(0x4a7484aa, 0x6ea6e483),
+    u64init(0x5cb0a9dc, 0xbd41fbd4), u64init(0x76f988da, 0x831153b5),
+    u64init(0x983e5152, 0xee66dfab), u64init(0xa831c66d, 0x2db43210),
+    u64init(0xb00327c8, 0x98fb213f), u64init(0xbf597fc7, 0xbeef0ee4),
+    u64init(0xc6e00bf3, 0x3da88fc2), u64init(0xd5a79147, 0x930aa725),
+    u64init(0x06ca6351, 0xe003826f), u64init(0x14292967, 0x0a0e6e70),
+    u64init(0x27b70a85, 0x46d22ffc), u64init(0x2e1b2138, 0x5c26c926),
+    u64init(0x4d2c6dfc, 0x5ac42aed), u64init(0x53380d13, 0x9d95b3df),
+    u64init(0x650a7354, 0x8baf63de), u64init(0x766a0abb, 0x3c77b2a8),
+    u64init(0x81c2c92e, 0x47edaee6), u64init(0x92722c85, 0x1482353b),
+    u64init(0xa2bfe8a1, 0x4cf10364), u64init(0xa81a664b, 0xbc423001),
+    u64init(0xc24b8b70, 0xd0f89791), u64init(0xc76c51a3, 0x0654be30),
+    u64init(0xd192e819, 0xd6ef5218), u64init(0xd6990624, 0x5565a910),
+    u64init(0xf40e3585, 0x5771202a), u64init(0x106aa070, 0x32bbd1b8),
+    u64init(0x19a4c116, 0xb8d2d0c8), u64init(0x1e376c08, 0x5141ab53),
+    u64init(0x2748774c, 0xdf8eeb99), u64init(0x34b0bcb5, 0xe19b48a8),
+    u64init(0x391c0cb3, 0xc5c95a63), u64init(0x4ed8aa4a, 0xe3418acb),
+    u64init(0x5b9cca4f, 0x7763e373), u64init(0x682e6ff3, 0xd6b2b8a3),
+    u64init(0x748f82ee, 0x5defb2fc), u64init(0x78a5636f, 0x43172f60),
+    u64init(0x84c87814, 0xa1f0ab72), u64init(0x8cc70208, 0x1a6439ec),
+    u64init(0x90befffa, 0x23631e28), u64init(0xa4506ceb, 0xde82bde9),
+    u64init(0xbef9a3f7, 0xb2c67915), u64init(0xc67178f2, 0xe372532b),
+    u64init(0xca273ece, 0xea26619c), u64init(0xd186b8c7, 0x21c0c207),
+    u64init(0xeada7dd6, 0xcde0eb1e), u64init(0xf57d4f7f, 0xee6ed178),
+    u64init(0x06f067aa, 0x72176fba), u64init(0x0a637dc5, 0xa2c898a6),
+    u64init(0x113f9804, 0xbef90dae), u64init(0x1b710b35, 0x131c471b),
+    u64init(0x28db77f5, 0x23047d84), u64init(0x32caab7b, 0x40c72493),
+    u64init(0x3c9ebe0a, 0x15c9bebc), u64init(0x431d67c4, 0x9c100d4c),
+    u64init(0x4cc5d4be, 0xcb3e42b6), u64init(0x597f299c, 0xfc657e2a),
+    u64init(0x5fcb6fab, 0x3ad6faec), u64init(0x6c44198c, 0x4a475817),
+};
+
+/* Round functions.  */
+#define F2(A, B, C) u64or(u64and(A, B), u64and(C, u64or(A, B)))
+#define F1(E, F, G) u64xor(G, u64and(E, u64xor(F, G)))
+
+/* Process LEN bytes of BUFFER, accumulating context into CTX.
+   It is assumed that LEN % 128 == 0.
+   Most of this code comes from GnuPG's cipher/sha1.c.  */
+
+void sha512_process_block(const void* buffer, size_t len, struct sha512_ctx* ctx) {
+    u64 const* words = buffer;
+    u64 const* endp = words + len / sizeof(u64);
+    u64 x[16];
+    u64 a = ctx->state[0];
+    u64 b = ctx->state[1];
+    u64 c = ctx->state[2];
+    u64 d = ctx->state[3];
+    u64 e = ctx->state[4];
+    u64 f = ctx->state[5];
+    u64 g = ctx->state[6];
+    u64 h = ctx->state[7];
+    u64 lolen = u64size(len);
+
+    /* First increment the byte count.  FIPS PUB 180-2 specifies the possible
+     length of the file up to 2^128 bits.  Here we only compute the
+     number of bytes.  Do a double word increment.  */
+    ctx->total[0] = u64plus(ctx->total[0], lolen);
+    ctx->total[1] = u64plus(
+        ctx->total[1], u64plus(u64size(len >> 31 >> 31 >> 2), u64lo(u64lt(ctx->total[0], lolen))));
+
+#define S0(x) u64xor(u64rol(x, 63), u64xor(u64rol(x, 56), u64shr(x, 7)))
+#define S1(x) u64xor(u64rol(x, 45), u64xor(u64rol(x, 3), u64shr(x, 6)))
+#define SS0(x) u64xor(u64rol(x, 36), u64xor(u64rol(x, 30), u64rol(x, 25)))
+#define SS1(x) u64xor(u64rol(x, 50), u64xor(u64rol(x, 46), u64rol(x, 23)))
+
+#define M(I)              \
+    (x[(I)&15] = u64plus( \
+         x[(I)&15],       \
+         u64plus(S1(x[((I)-2) & 15]), u64plus(x[((I)-7) & 15], S0(x[((I)-15) & 15])))))
+
+#define R(A, B, C, D, E, F, G, H, K, M)                                            \
+    do {                                                                           \
+        u64 t0 = u64plus(SS0(A), F2(A, B, C));                                     \
+        u64 t1 = u64plus(H, u64plus(SS1(E), u64plus(F1(E, F, G), u64plus(K, M)))); \
+        D = u64plus(D, t1);                                                        \
+        H = u64plus(t0, t1);                                                       \
+    } while(0)
+
+    while(words < endp) {
+        int t;
+        /* FIXME: see sha1.c for a better implementation.  */
+        for(t = 0; t < 16; t++) {
+            x[t] = SWAP(*words);
+            words++;
+        }
+
+        R(a, b, c, d, e, f, g, h, K(0), x[0]);
+        R(h, a, b, c, d, e, f, g, K(1), x[1]);
+        R(g, h, a, b, c, d, e, f, K(2), x[2]);
+        R(f, g, h, a, b, c, d, e, K(3), x[3]);
+        R(e, f, g, h, a, b, c, d, K(4), x[4]);
+        R(d, e, f, g, h, a, b, c, K(5), x[5]);
+        R(c, d, e, f, g, h, a, b, K(6), x[6]);
+        R(b, c, d, e, f, g, h, a, K(7), x[7]);
+        R(a, b, c, d, e, f, g, h, K(8), x[8]);
+        R(h, a, b, c, d, e, f, g, K(9), x[9]);
+        R(g, h, a, b, c, d, e, f, K(10), x[10]);
+        R(f, g, h, a, b, c, d, e, K(11), x[11]);
+        R(e, f, g, h, a, b, c, d, K(12), x[12]);
+        R(d, e, f, g, h, a, b, c, K(13), x[13]);
+        R(c, d, e, f, g, h, a, b, K(14), x[14]);
+        R(b, c, d, e, f, g, h, a, K(15), x[15]);
+        R(a, b, c, d, e, f, g, h, K(16), M(16));
+        R(h, a, b, c, d, e, f, g, K(17), M(17));
+        R(g, h, a, b, c, d, e, f, K(18), M(18));
+        R(f, g, h, a, b, c, d, e, K(19), M(19));
+        R(e, f, g, h, a, b, c, d, K(20), M(20));
+        R(d, e, f, g, h, a, b, c, K(21), M(21));
+        R(c, d, e, f, g, h, a, b, K(22), M(22));
+        R(b, c, d, e, f, g, h, a, K(23), M(23));
+        R(a, b, c, d, e, f, g, h, K(24), M(24));
+        R(h, a, b, c, d, e, f, g, K(25), M(25));
+        R(g, h, a, b, c, d, e, f, K(26), M(26));
+        R(f, g, h, a, b, c, d, e, K(27), M(27));
+        R(e, f, g, h, a, b, c, d, K(28), M(28));
+        R(d, e, f, g, h, a, b, c, K(29), M(29));
+        R(c, d, e, f, g, h, a, b, K(30), M(30));
+        R(b, c, d, e, f, g, h, a, K(31), M(31));
+        R(a, b, c, d, e, f, g, h, K(32), M(32));
+        R(h, a, b, c, d, e, f, g, K(33), M(33));
+        R(g, h, a, b, c, d, e, f, K(34), M(34));
+        R(f, g, h, a, b, c, d, e, K(35), M(35));
+        R(e, f, g, h, a, b, c, d, K(36), M(36));
+        R(d, e, f, g, h, a, b, c, K(37), M(37));
+        R(c, d, e, f, g, h, a, b, K(38), M(38));
+        R(b, c, d, e, f, g, h, a, K(39), M(39));
+        R(a, b, c, d, e, f, g, h, K(40), M(40));
+        R(h, a, b, c, d, e, f, g, K(41), M(41));
+        R(g, h, a, b, c, d, e, f, K(42), M(42));
+        R(f, g, h, a, b, c, d, e, K(43), M(43));
+        R(e, f, g, h, a, b, c, d, K(44), M(44));
+        R(d, e, f, g, h, a, b, c, K(45), M(45));
+        R(c, d, e, f, g, h, a, b, K(46), M(46));
+        R(b, c, d, e, f, g, h, a, K(47), M(47));
+        R(a, b, c, d, e, f, g, h, K(48), M(48));
+        R(h, a, b, c, d, e, f, g, K(49), M(49));
+        R(g, h, a, b, c, d, e, f, K(50), M(50));
+        R(f, g, h, a, b, c, d, e, K(51), M(51));
+        R(e, f, g, h, a, b, c, d, K(52), M(52));
+        R(d, e, f, g, h, a, b, c, K(53), M(53));
+        R(c, d, e, f, g, h, a, b, K(54), M(54));
+        R(b, c, d, e, f, g, h, a, K(55), M(55));
+        R(a, b, c, d, e, f, g, h, K(56), M(56));
+        R(h, a, b, c, d, e, f, g, K(57), M(57));
+        R(g, h, a, b, c, d, e, f, K(58), M(58));
+        R(f, g, h, a, b, c, d, e, K(59), M(59));
+        R(e, f, g, h, a, b, c, d, K(60), M(60));
+        R(d, e, f, g, h, a, b, c, K(61), M(61));
+        R(c, d, e, f, g, h, a, b, K(62), M(62));
+        R(b, c, d, e, f, g, h, a, K(63), M(63));
+        R(a, b, c, d, e, f, g, h, K(64), M(64));
+        R(h, a, b, c, d, e, f, g, K(65), M(65));
+        R(g, h, a, b, c, d, e, f, K(66), M(66));
+        R(f, g, h, a, b, c, d, e, K(67), M(67));
+        R(e, f, g, h, a, b, c, d, K(68), M(68));
+        R(d, e, f, g, h, a, b, c, K(69), M(69));
+        R(c, d, e, f, g, h, a, b, K(70), M(70));
+        R(b, c, d, e, f, g, h, a, K(71), M(71));
+        R(a, b, c, d, e, f, g, h, K(72), M(72));
+        R(h, a, b, c, d, e, f, g, K(73), M(73));
+        R(g, h, a, b, c, d, e, f, K(74), M(74));
+        R(f, g, h, a, b, c, d, e, K(75), M(75));
+        R(e, f, g, h, a, b, c, d, K(76), M(76));
+        R(d, e, f, g, h, a, b, c, K(77), M(77));
+        R(c, d, e, f, g, h, a, b, K(78), M(78));
+        R(b, c, d, e, f, g, h, a, K(79), M(79));
+
+        a = ctx->state[0] = u64plus(ctx->state[0], a);
+        b = ctx->state[1] = u64plus(ctx->state[1], b);
+        c = ctx->state[2] = u64plus(ctx->state[2], c);
+        d = ctx->state[3] = u64plus(ctx->state[3], d);
+        e = ctx->state[4] = u64plus(ctx->state[4], e);
+        f = ctx->state[5] = u64plus(ctx->state[5], f);
+        g = ctx->state[6] = u64plus(ctx->state[6], g);
+        h = ctx->state[7] = u64plus(ctx->state[7], h);
+    }
+}
+
+#endif
+
+/*
+ * Hey Emacs!
+ * Local Variables:
+ * coding: utf-8
+ * End:
+ */

applications/plugins/totp/services/hmac/sha512.h

@@ -0,0 +1,111 @@
+/* Declarations of functions and data types used for SHA512 and SHA384 sum
+   library functions.
+   Copyright (C) 2005-2006, 2008-2022 Free Software Foundation, Inc.
+
+   This file is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as
+   published by the Free Software Foundation; either version 2.1 of the
+   License, or (at your option) any later version.
+
+   This file is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
+
+#pragma once
+
+#include <stdio.h>
+#include "u64.h"
+
+#if HAVE_OPENSSL_SHA512
+#ifndef OPENSSL_API_COMPAT
+#define OPENSSL_API_COMPAT 0x10101000L /* FIXME: Use OpenSSL 1.1+ API.  */
+#endif
+#include <openssl/sha.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum { SHA384_DIGEST_SIZE = 384 / 8 };
+enum { SHA512_DIGEST_SIZE = 512 / 8 };
+
+#if HAVE_OPENSSL_SHA512
+#define GL_OPENSSL_NAME 384
+#include "gl_openssl.h"
+#define GL_OPENSSL_NAME 512
+#include "gl_openssl.h"
+#else
+/* Structure to save state of computation between the single steps.  */
+struct sha512_ctx {
+    u64 state[8];
+
+    u64 total[2];
+    size_t buflen; /* ≥ 0, ≤ 256 */
+    u64 buffer[32]; /* 256 bytes; the first buflen bytes are in use */
+};
+
+/* Initialize structure containing state of computation. */
+extern void sha512_init_ctx(struct sha512_ctx* ctx);
+extern void sha384_init_ctx(struct sha512_ctx* ctx);
+
+/* Starting with the result of former calls of this function (or the
+   initialization function update the context for the next LEN bytes
+   starting at BUFFER.
+   It is necessary that LEN is a multiple of 128!!! */
+extern void sha512_process_block(const void* buffer, size_t len, struct sha512_ctx* ctx);
+
+/* Starting with the result of former calls of this function (or the
+   initialization function update the context for the next LEN bytes
+   starting at BUFFER.
+   It is NOT required that LEN is a multiple of 128.  */
+extern void sha512_process_bytes(const void* buffer, size_t len, struct sha512_ctx* ctx);
+
+/* Process the remaining bytes in the buffer and put result from CTX
+   in first 64 (48) bytes following RESBUF.  The result is always in little
+   endian byte order, so that a byte-wise output yields to the wanted
+   ASCII representation of the message digest.  */
+extern void* sha512_finish_ctx(struct sha512_ctx* ctx, void* restrict resbuf);
+extern void* sha384_finish_ctx(struct sha512_ctx* ctx, void* restrict resbuf);
+
+/* Put result from CTX in first 64 (48) bytes following RESBUF.  The result is
+   always in little endian byte order, so that a byte-wise output yields
+   to the wanted ASCII representation of the message digest.
+
+   IMPORTANT: On some systems it is required that RESBUF is correctly
+   aligned for a 32 bits value.  */
+extern void* sha512_read_ctx(const struct sha512_ctx* ctx, void* restrict resbuf);
+extern void* sha384_read_ctx(const struct sha512_ctx* ctx, void* restrict resbuf);
+
+/* Compute SHA512 (SHA384) message digest for LEN bytes beginning at BUFFER.
+   The result is always in little endian byte order, so that a byte-wise
+   output yields to the wanted ASCII representation of the message
+   digest.  */
+extern void* sha512_buffer(const char* buffer, size_t len, void* restrict resblock);
+extern void* sha384_buffer(const char* buffer, size_t len, void* restrict resblock);
+
+#endif
+
+/* Compute SHA512 (SHA384) message digest for bytes read from STREAM.
+   STREAM is an open file stream.  Regular files are handled more efficiently.
+   The contents of STREAM from its current position to its end will be read.
+   The case that the last operation on STREAM was an 'ungetc' is not supported.
+   The resulting message digest number will be written into the 64 (48) bytes
+   beginning at RESBLOCK.  */
+extern int sha512_stream(FILE* stream, void* resblock);
+extern int sha384_stream(FILE* stream, void* resblock);
+
+#ifdef __cplusplus
+}
+#endif
+
+/*
+ * Hey Emacs!
+ * Local Variables:
+ * coding: utf-8
+ * End:
+ */

applications/plugins/totp/services/hmac/u64.c

@@ -0,0 +1,20 @@
+/* uint64_t-like operations that work even on hosts lacking uint64_t
+
+   Copyright (C) 2012-2022 Free Software Foundation, Inc.
+
+   This file is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as
+   published by the Free Software Foundation; either version 2.1 of the
+   License, or (at your option) any later version.
+
+   This file is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
+
+#define _GL_U64_INLINE _GL_EXTERN_INLINE
+#include "u64.h"
+typedef int dummy;

applications/plugins/totp/services/hmac/u64.h

@@ -0,0 +1,44 @@
+/* uint64_t-like operations that work even on hosts lacking uint64_t
+
+   Copyright (C) 2006, 2009-2022 Free Software Foundation, Inc.
+
+   This file is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as
+   published by the Free Software Foundation; either version 2.1 of the
+   License, or (at your option) any later version.
+
+   This file is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
+
+/* Written by Paul Eggert.  */
+
+#pragma once
+
+#include <stdint.h>
+
+#ifndef _GL_U64_INLINE
+#define _GL_U64_INLINE _GL_INLINE
+#endif
+
+/* Return X rotated left by N bits, where 0 < N < 64.  */
+#define u64rol(x, n) u64or(u64shl(x, n), u64shr(x, 64 - n))
+
+/* Native implementations are trivial.  See below for comments on what
+   these operations do.  */
+typedef uint64_t u64;
+#define u64hilo(hi, lo) ((u64)(((u64)(hi) << 32) + (lo)))
+#define u64init(hi, lo) u64hilo(hi, lo)
+#define u64lo(x) ((u64)(x))
+#define u64size(x) u64lo(x)
+#define u64lt(x, y) ((x) < (y))
+#define u64and(x, y) ((x) & (y))
+#define u64or(x, y) ((x) | (y))
+#define u64xor(x, y) ((x) ^ (y))
+#define u64plus(x, y) ((x) + (y))
+#define u64shl(x, n) ((x) << (n))
+#define u64shr(x, n) ((x) >> (n))

applications/plugins/totp/services/list/list.c

@@ -0,0 +1,72 @@
+#include "list.h"
+
+ListNode* list_init_head(void* data) {
+    ListNode* new = (ListNode*)malloc(sizeof(ListNode));
+    new->data = data;
+    new->next = NULL;
+    return new;
+}
+
+ListNode* list_add(ListNode* head, void* data) {
+    ListNode* new = (ListNode*)malloc(sizeof(ListNode));
+    new->data = data;
+    new->next = NULL;
+
+    if(head == NULL)
+        head = new;
+    else {
+        ListNode* it;
+
+        for(it = head; it->next != NULL; it = it->next)
+            ;
+
+        it->next = new;
+    }
+
+    return head;
+}
+
+ListNode* list_find(ListNode* head, void* data) {
+    ListNode* it;
+
+    for(it = head; it != NULL; it = it->next)
+        if(it->data == data) break;
+
+    return it;
+}
+
+ListNode* list_element_at(ListNode* head, uint16_t index) {
+    ListNode* it;
+    uint16_t i;
+    for(it = head, i = 0; it != NULL && i < index; it = it->next, i++)
+        ;
+    return it;
+}
+
+ListNode* list_remove(ListNode* head, ListNode* ep) {
+    if(head == ep) {
+        ListNode* new_head = head->next;
+        free(head);
+        return new_head;
+    }
+
+    ListNode* it;
+
+    for(it = head; it->next != ep; it = it->next)
+        ;
+
+    it->next = ep->next;
+    free(ep);
+
+    return head;
+}
+
+void list_free(ListNode* head) {
+    ListNode *it = head, *tmp;
+
+    while(it != NULL) {
+        tmp = it;
+        it = it->next;
+        free(tmp);
+    }
+}

applications/plugins/totp/services/list/list.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <stdlib.h>
+#include <inttypes.h>
+
+typedef struct ListNode {
+    void* data;
+    struct ListNode* next;
+} ListNode;
+
+ListNode* list_init_head(void* data);
+ListNode* list_add(
+    ListNode* head,
+    void* data); /* adds element with specified data to the end of the list and returns new head node. */
+ListNode* list_find(
+    ListNode* head,
+    void* data); /* returns pointer of element with specified data in list. */
+ListNode* list_element_at(
+    ListNode* head,
+    uint16_t index); /* returns pointer of element with specified index in list. */
+ListNode* list_remove(
+    ListNode* head,
+    ListNode* ep); /* removes element from the list and returns new head node. */
+void list_free(ListNode* head); /* deletes all elements of the list. */

applications/plugins/totp/services/timezone_utils/timezone_utils.c

@@ -0,0 +1,16 @@
+#include "timezone_utils.h"
+
+int32_t timezone_offset_from_hours(float hours) {
+    return hours * 3600.0f;
+}
+
+uint64_t timezone_offset_apply(uint64_t time, int32_t offset) {
+    uint64_t for_time_adjusted;
+    if(offset > 0) {
+        for_time_adjusted = time - offset;
+    } else {
+        for_time_adjusted = time + (-offset);
+    }
+
+    return for_time_adjusted;
+}

applications/plugins/totp/services/timezone_utils/timezone_utils.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <inttypes.h>
+
+int32_t timezone_offset_from_hours(float hours);
+uint64_t timezone_offset_apply(uint64_t time, int32_t offset);

applications/plugins/totp/services/totp/totp.c

@@ -0,0 +1,150 @@
+#include "totp.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <math.h>
+#include "../hmac/hmac_sha1.h"
+#include "../hmac/hmac_sha256.h"
+#include "../hmac/hmac_sha512.h"
+#include "../timezone_utils/timezone_utils.h"
+
+#define UINT64_GET_BYTE(integer, index) ((integer >> (8 * index)) & 0xFF)
+
+/*
+	Generates the timeblock for a time in seconds.
+	
+	Timeblocks are the amount of intervals in a given time. For example,
+	if 1,000,000 seconds has passed for 30 second intervals, you would get
+	33,333 timeblocks (intervals), where timeblock++ is effectively +30 seconds.
+	
+	for_time is a time in seconds to get the current timeblocks
+	
+	Returns
+			timeblock given for_time, using data->interval
+		error, 0
+*/
+uint64_t totp_timecode(uint8_t interval, uint64_t for_time) {
+    return for_time / interval;
+}
+
+/*
+	Converts an integer into an 8 byte array.
+	
+	out_bytes is the null-terminated output string already allocated
+*/
+void otp_num_to_bytes(uint64_t integer, uint8_t* out_bytes) {
+    out_bytes[7] = UINT64_GET_BYTE(integer, 0);
+    out_bytes[6] = UINT64_GET_BYTE(integer, 1);
+    out_bytes[5] = UINT64_GET_BYTE(integer, 2);
+    out_bytes[4] = UINT64_GET_BYTE(integer, 3);
+    out_bytes[3] = UINT64_GET_BYTE(integer, 4);
+    out_bytes[2] = UINT64_GET_BYTE(integer, 5);
+    out_bytes[1] = UINT64_GET_BYTE(integer, 6);
+    out_bytes[0] = UINT64_GET_BYTE(integer, 7);
+}
+
+/*
+	Generates an OTP (One Time Password).
+	
+	input is a number used to generate the OTP
+	out_str is the null-terminated output string already allocated
+	
+	Returns
+			OTP code if otp code was successfully generated
+		0 otherwise
+*/
+uint32_t otp_generate(
+    TOTP_ALGO algo,
+    uint8_t digits,
+    const uint8_t* plain_secret,
+    uint8_t plain_secret_length,
+    uint64_t input) {
+    uint8_t* bytes = malloc(8);
+    memset(bytes, 0, 8);
+    uint8_t* hmac = malloc(64);
+    memset(hmac, 0, 64);
+
+    otp_num_to_bytes(input, bytes);
+
+    int hmac_len = (*(algo))(plain_secret, plain_secret_length, bytes, 8, hmac);
+    if(hmac_len == 0) {
+        free(hmac);
+        free(bytes);
+        return OTP_ERROR;
+    }
+
+    uint64_t offset = (hmac[hmac_len - 1] & 0xF);
+    uint64_t i_code =
+        ((hmac[offset] & 0x7F) << 24 | (hmac[offset + 1] & 0xFF) << 16 |
+         (hmac[offset + 2] & 0xFF) << 8 | (hmac[offset + 3] & 0xFF));
+    i_code %= (uint64_t)pow(10, digits);
+
+    free(hmac);
+    free(bytes);
+    return i_code;
+}
+
+/*
+	Generates a OTP key using the totp algorithm.
+	
+	for_time is the time the generated key will be created for
+	offset is a timeblock adjustment for the generated key
+	out_str is the null-terminated output string already allocated
+	
+	Returns
+			TOTP code if otp code was successfully generated
+		0 otherwise
+*/
+uint32_t totp_at(
+    TOTP_ALGO algo,
+    uint8_t digits,
+    const uint8_t* plain_secret,
+    uint8_t plain_secret_length,
+    uint64_t for_time,
+    float timezone,
+    uint8_t interval) {
+    uint64_t for_time_adjusted =
+        timezone_offset_apply(for_time, timezone_offset_from_hours(timezone));
+    return otp_generate(
+        algo,
+        digits,
+        plain_secret,
+        plain_secret_length,
+        totp_timecode(interval, for_time_adjusted));
+}
+
+static int totp_algo_sha1(
+    const uint8_t* key,
+    uint8_t key_length,
+    const uint8_t* input,
+    uint8_t input_length,
+    uint8_t* output) {
+    hmac_sha1(key, key_length, input, input_length, output);
+    return HMAC_SHA1_RESULT_SIZE;
+}
+
+static int totp_algo_sha256(
+    const uint8_t* key,
+    uint8_t key_length,
+    const uint8_t* input,
+    uint8_t input_length,
+    uint8_t* output) {
+    hmac_sha256(key, key_length, input, input_length, output);
+    return HMAC_SHA256_RESULT_SIZE;
+}
+
+static int totp_algo_sha512(
+    const uint8_t* key,
+    uint8_t key_length,
+    const uint8_t* input,
+    uint8_t input_length,
+    uint8_t* output) {
+    hmac_sha512(key, key_length, input, input_length, output);
+    return HMAC_SHA512_RESULT_SIZE;
+}
+
+const TOTP_ALGO TOTP_ALGO_SHA1 = (TOTP_ALGO)(&totp_algo_sha1);
+const TOTP_ALGO TOTP_ALGO_SHA256 = (TOTP_ALGO)(&totp_algo_sha256);
+const TOTP_ALGO TOTP_ALGO_SHA512 = (TOTP_ALGO)(&totp_algo_sha512);

applications/plugins/totp/services/totp/totp.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <stdlib.h>
+#include <stdint.h>
+
+#define OTP_ERROR (0)
+
+/*
+	Must compute HMAC using passed arguments,
+	  output as char array through output.
+	
+	key is secret key.
+	input is input number.
+	output is an output buffer of the resulting HMAC operation.
+	
+	Must return 0 if error, or the length in bytes of the HMAC operation.
+*/
+typedef int (*TOTP_ALGO)(
+    const uint8_t* key,
+    uint8_t key_length,
+    const uint8_t* input,
+    uint8_t input_length,
+    uint8_t* output);
+
+/*
+    Computes HMAC using SHA1
+*/
+extern const TOTP_ALGO TOTP_ALGO_SHA1;
+
+/*
+    Computes HMAC using SHA256
+*/
+extern const TOTP_ALGO TOTP_ALGO_SHA256;
+
+/*
+    Computes HMAC using SHA512
+*/
+extern const TOTP_ALGO TOTP_ALGO_SHA512;
+
+/*
+	Computes TOTP token
+    Returns:
+        TOTP token on success
+        0 otherwise
+*/
+uint32_t totp_at(
+    TOTP_ALGO algo,
+    uint8_t digits,
+    const uint8_t* plain_secret,
+    uint8_t plain_secret_length,
+    uint64_t for_time,
+    float timezone,
+    uint8_t interval);

applications/plugins/totp/services/ui/constants.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#define SCREEN_WIDTH 128
+#define SCREEN_HEIGHT 64
+#define SCREEN_WIDTH_CENTER (SCREEN_WIDTH >> 1)
+#define SCREEN_HEIGHT_CENTER (SCREEN_HEIGHT >> 1)

applications/plugins/totp/services/ui/icons.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <inttypes.h>
+
+#define ICON_ARROW_LEFT_8x9_WIDTH 8
+#define ICON_ARROW_LEFT_8x9_HEIGHT 9
+static const uint8_t ICON_ARROW_LEFT_8x9[] = {0x80, 0xe0, 0xf8, 0xfe, 0xff, 0xfe, 0xf8, 0xe0, 0x80};
+
+#define ICON_ARROW_RIGHT_8x9_WIDTH 8
+#define ICON_ARROW_RIGHT_8x9_HEIGHT 9
+static const uint8_t ICON_ARROW_RIGHT_8x9[] =
+    {0x01, 0x07, 0x1f, 0x7f, 0xff, 0x7f, 0x1f, 0x07, 0x01};

applications/plugins/totp/services/ui/ui_controls.c

@@ -0,0 +1,114 @@
+#include "ui_controls.h"
+#include "constants.h"
+#include "icons.h"
+
+#define TEXT_BOX_HEIGHT 13
+#define TEXT_BOX_MARGIN 4
+
+void ui_control_text_box_render(Canvas* const canvas, int8_t y, char* text, bool is_selected) {
+    if(y < -TEXT_BOX_HEIGHT) {
+        return;
+    }
+
+    if(is_selected) {
+        canvas_draw_rframe(
+            canvas,
+            TEXT_BOX_MARGIN,
+            TEXT_BOX_MARGIN + y,
+            SCREEN_WIDTH - TEXT_BOX_MARGIN - TEXT_BOX_MARGIN,
+            TEXT_BOX_HEIGHT,
+            0);
+        canvas_draw_rframe(
+            canvas,
+            TEXT_BOX_MARGIN - 1,
+            TEXT_BOX_MARGIN + y - 1,
+            SCREEN_WIDTH - TEXT_BOX_MARGIN - TEXT_BOX_MARGIN + 2,
+            TEXT_BOX_HEIGHT + 2,
+            1);
+    } else {
+        canvas_draw_rframe(
+            canvas,
+            TEXT_BOX_MARGIN,
+            TEXT_BOX_MARGIN + y,
+            SCREEN_WIDTH - TEXT_BOX_MARGIN - TEXT_BOX_MARGIN,
+            TEXT_BOX_HEIGHT,
+            1);
+    }
+
+    canvas_draw_str_aligned(
+        canvas, TEXT_BOX_MARGIN + 2, TEXT_BOX_MARGIN + 3 + y, AlignLeft, AlignTop, text);
+}
+
+void ui_control_select_render(Canvas* const canvas, int8_t y, char* text, bool is_selected) {
+    if(y < -TEXT_BOX_HEIGHT) {
+        return;
+    }
+
+    if(is_selected) {
+        canvas_draw_rframe(
+            canvas,
+            TEXT_BOX_MARGIN,
+            TEXT_BOX_MARGIN + y,
+            SCREEN_WIDTH - TEXT_BOX_MARGIN - TEXT_BOX_MARGIN,
+            TEXT_BOX_HEIGHT,
+            0);
+        canvas_draw_rframe(
+            canvas,
+            TEXT_BOX_MARGIN - 1,
+            TEXT_BOX_MARGIN + y - 1,
+            SCREEN_WIDTH - TEXT_BOX_MARGIN - TEXT_BOX_MARGIN + 2,
+            TEXT_BOX_HEIGHT + 2,
+            1);
+    } else {
+        canvas_draw_rframe(
+            canvas,
+            TEXT_BOX_MARGIN,
+            TEXT_BOX_MARGIN + y,
+            SCREEN_WIDTH - TEXT_BOX_MARGIN - TEXT_BOX_MARGIN,
+            TEXT_BOX_HEIGHT,
+            1);
+    }
+
+    canvas_draw_str_aligned(
+        canvas, SCREEN_WIDTH_CENTER, TEXT_BOX_MARGIN + 3 + y, AlignCenter, AlignTop, text);
+    canvas_draw_xbm(
+        canvas,
+        TEXT_BOX_MARGIN + 2,
+        TEXT_BOX_MARGIN + 2 + y,
+        ICON_ARROW_LEFT_8x9_WIDTH,
+        ICON_ARROW_LEFT_8x9_HEIGHT,
+        &ICON_ARROW_LEFT_8x9[0]);
+    canvas_draw_xbm(
+        canvas,
+        SCREEN_WIDTH - TEXT_BOX_MARGIN - 10,
+        TEXT_BOX_MARGIN + 2 + y,
+        ICON_ARROW_RIGHT_8x9_WIDTH,
+        ICON_ARROW_RIGHT_8x9_HEIGHT,
+        &ICON_ARROW_RIGHT_8x9[0]);
+}
+
+void ui_control_button_render(
+    Canvas* const canvas,
+    uint8_t x,
+    int8_t y,
+    uint8_t width,
+    uint8_t height,
+    char* text,
+    bool is_selected) {
+    if(y < -height) {
+        return;
+    }
+
+    if(is_selected) {
+        canvas_draw_rbox(canvas, x, y, width, height, 1);
+        canvas_set_color(canvas, ColorWhite);
+    } else {
+        canvas_draw_rframe(canvas, x, y, width, height, 1);
+    }
+
+    canvas_draw_str_aligned(
+        canvas, x + (width >> 1), y + (height >> 1) + 1, AlignCenter, AlignCenter, text);
+    if(is_selected) {
+        canvas_set_color(canvas, ColorBlack);
+    }
+}

applications/plugins/totp/services/ui/ui_controls.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <inttypes.h>
+#include <gui/gui.h>
+
+void ui_control_text_box_render(Canvas* const canvas, int8_t y, char* text, bool is_selected);
+void ui_control_button_render(
+    Canvas* const canvas,
+    uint8_t x,
+    int8_t y,
+    uint8_t width,
+    uint8_t height,
+    char* text,
+    bool is_selected);
+void ui_control_select_render(Canvas* const canvas, int8_t y, char* text, bool is_selected);

applications/plugins/totp/totp_app.c

@@ -0,0 +1,126 @@
+#include <furi.h>
+#include <furi_hal.h>
+#include <gui/gui.h>
+#include <input/input.h>
+#include <dialogs/dialogs.h>
+#include <stdlib.h>
+#include <flipper_format/flipper_format.h>
+#include <notification/notification.h>
+#include <notification/notification_messages.h>
+#include "services/base32/base32.h"
+#include "services/list/list.h"
+#include "services/config/config.h"
+#include "types/plugin_state.h"
+#include "types/token_info.h"
+#include "types/plugin_event.h"
+#include "types/event_type.h"
+#include "types/common.h"
+#include "scenes/scene_director.h"
+
+#define IDLE_TIMEOUT 60000
+
+static void render_callback(Canvas* const canvas, void* ctx) {
+    PluginState* plugin_state = acquire_mutex((ValueMutex*)ctx, 25);
+    if(plugin_state != NULL && !plugin_state->changing_scene) {
+        totp_scene_director_render(canvas, plugin_state);
+    }
+
+    release_mutex((ValueMutex*)ctx, plugin_state);
+}
+
+static void input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
+    furi_assert(event_queue);
+
+    PluginEvent event = {.type = EventTypeKey, .input = *input_event};
+    furi_message_queue_put(event_queue, &event, FuriWaitForever);
+}
+
+static void totp_state_init(PluginState* const plugin_state) {
+    plugin_state->gui = furi_record_open(RECORD_GUI);
+    plugin_state->notification = furi_record_open(RECORD_NOTIFICATION);
+    plugin_state->dialogs = furi_record_open(RECORD_DIALOGS);
+    totp_config_file_load_base(plugin_state);
+
+    totp_scene_director_init_scenes(plugin_state);
+    totp_scene_director_activate_scene(plugin_state, TotpSceneAuthentication, NULL);
+}
+
+static void dispose_plugin_state(PluginState* plugin_state) {
+    totp_scene_director_deactivate_active_scene(plugin_state);
+
+    totp_scene_director_dispose(plugin_state);
+
+    furi_record_close(RECORD_GUI);
+    furi_record_close(RECORD_NOTIFICATION);
+    furi_record_close(RECORD_DIALOGS);
+
+    ListNode* node = plugin_state->tokens_list;
+    ListNode* tmp;
+    while(node != NULL) {
+        tmp = node->next;
+        TokenInfo* tokenInfo = (TokenInfo*)node->data;
+        token_info_free(tokenInfo);
+        free(node);
+        node = tmp;
+    }
+
+    if(plugin_state->crypto_verify_data != NULL) {
+        free(plugin_state->crypto_verify_data);
+    }
+    free(plugin_state);
+}
+
+int32_t totp_app() {
+    FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(PluginEvent));
+    PluginState* plugin_state = malloc(sizeof(PluginState));
+
+    totp_state_init(plugin_state);
+
+    ValueMutex state_mutex;
+    if(!init_mutex(&state_mutex, plugin_state, sizeof(PluginState))) {
+        FURI_LOG_E(LOGGING_TAG, "Cannot create mutex\r\n");
+        dispose_plugin_state(plugin_state);
+        return 255;
+    }
+
+    // Set system callbacks
+    ViewPort* view_port = view_port_alloc();
+    view_port_draw_callback_set(view_port, render_callback, &state_mutex);
+    view_port_input_callback_set(view_port, input_callback, event_queue);
+
+    // Open GUI and register view_port
+    gui_add_view_port(plugin_state->gui, view_port, GuiLayerFullscreen);
+
+    PluginEvent event;
+    bool processing = true;
+    uint32_t last_user_interaction_time = furi_get_tick();
+    while(processing) {
+        if(plugin_state->changing_scene) continue;
+        FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
+
+        PluginState* plugin_state = (PluginState*)acquire_mutex_block(&state_mutex);
+
+        if(event_status == FuriStatusOk) {
+            if(event.type == EventTypeKey) {
+                last_user_interaction_time = furi_get_tick();
+            }
+
+            processing = totp_scene_director_handle_event(&event, plugin_state);
+        } else if(
+            plugin_state->current_scene != TotpSceneAuthentication &&
+            furi_get_tick() - last_user_interaction_time > IDLE_TIMEOUT) {
+            totp_scene_director_activate_scene(plugin_state, TotpSceneAuthentication, NULL);
+        }
+
+        view_port_update(view_port);
+        release_mutex(&state_mutex, plugin_state);
+    }
+
+    view_port_enabled_set(view_port, false);
+    gui_remove_view_port(plugin_state->gui, view_port);
+    view_port_free(view_port);
+    furi_message_queue_free(event_queue);
+    delete_mutex(&state_mutex);
+    dispose_plugin_state(plugin_state);
+    return 0;
+}

applications/plugins/totp/types/common.h

@@ -0,0 +1,4 @@
+#pragma once
+
+#define LOGGING_TAG "TOTP APP"
+#define CRYPTO_KEY_SLOT 2