Momentum-Apps/passgen/passgen.c

#include <furi.h>
#include <furi_hal_random.h>
#include <gui/gui.h>
#include <gui/elements.h>
#include <input/input.h>
#include <notification/notification_messages.h>
#include <stdlib.h>
#include <passgen_icons.h>

#define PASSGEN_MAX_LENGTH 16
#define PASSGEN_CHARACTERS_LENGTH (26 * 4)

#define PASSGEN_DIGITS "0123456789"
#define PASSGEN_LETTERS_LOW "abcdefghijklmnopqrstuvwxyz"
#define PASSGEN_LETTERS_UP "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
#define PASSGEN_SPECIAL "!#$%^&*.-_"

typedef enum PassGen_Alphabet {
    Digits = 1,
    Lowercase = 2,

    Uppercase = 4,
    Special = 8,

    DigitsLower = Digits | Lowercase,
    DigitsAllLetters = Digits | Lowercase | Uppercase,
    Mixed = DigitsAllLetters | Special
} PassGen_Alphabet;

const char* const PassGen_AlphabetChars[16] = {
    "0", // invalid value
    /*    PASSGEN_SPECIAL    PASSGEN_LETTERS_UP    PASSGEN_LETTERS_LOW */ PASSGEN_DIGITS,
    /*    PASSGEN_SPECIAL    PASSGEN_LETTERS_UP */ PASSGEN_LETTERS_LOW /* PASSGEN_DIGITS */,
    /*    PASSGEN_SPECIAL    PASSGEN_LETTERS_UP */ PASSGEN_LETTERS_LOW PASSGEN_DIGITS,
    /*    PASSGEN_SPECIAL */ PASSGEN_LETTERS_UP /* PASSGEN_LETTERS_LOW    PASSGEN_DIGITS */,
    /*    PASSGEN_SPECIAL */ PASSGEN_LETTERS_UP /* PASSGEN_LETTERS_LOW */ PASSGEN_DIGITS,
    /*    PASSGEN_SPECIAL */ PASSGEN_LETTERS_UP PASSGEN_LETTERS_LOW /* PASSGEN_DIGITS */,
    /*    PASSGEN_SPECIAL */ PASSGEN_LETTERS_UP PASSGEN_LETTERS_LOW PASSGEN_DIGITS,
    PASSGEN_SPECIAL /* PASSGEN_LETTERS_UP    PASSGEN_LETTERS_LOW    PASSGEN_DIGITS */,
    PASSGEN_SPECIAL /* PASSGEN_LETTERS_UP    PASSGEN_LETTERS_LOW */ PASSGEN_DIGITS,
    PASSGEN_SPECIAL /* PASSGEN_LETTERS_UP */ PASSGEN_LETTERS_LOW /* PASSGEN_DIGITS */,
    PASSGEN_SPECIAL /* PASSGEN_LETTERS_UP */ PASSGEN_LETTERS_LOW PASSGEN_DIGITS,
    PASSGEN_SPECIAL PASSGEN_LETTERS_UP /* PASSGEN_LETTERS_LOW    PASSGEN_DIGITS */,
    PASSGEN_SPECIAL PASSGEN_LETTERS_UP /* PASSGEN_LETTERS_LOW */ PASSGEN_DIGITS,
    PASSGEN_SPECIAL PASSGEN_LETTERS_UP PASSGEN_LETTERS_LOW /* PASSGEN_DIGITS */,
    PASSGEN_SPECIAL PASSGEN_LETTERS_UP PASSGEN_LETTERS_LOW PASSGEN_DIGITS,
};

const int AlphabetLevels[] = {Digits, Lowercase, DigitsLower, DigitsAllLetters, Mixed};
const char* AlphabetLevelNames[] = {"1234", "abcd", "ab12", "Ab12", "Ab1#"};
const int AlphabetLevelsCount = sizeof(AlphabetLevels) / sizeof(int);

const NotificationSequence PassGen_Alert_vibro = {
    &message_vibro_on,
    &message_blue_255,
    &message_delay_50,
    &message_vibro_off,
    NULL,
};

typedef struct {
    FuriMessageQueue* input_queue;
    ViewPort* view_port;
    Gui* gui;
    FuriMutex** mutex;
    NotificationApp* notify;
    const char* alphabet;
    char password[PASSGEN_MAX_LENGTH + 1];
    int length; // must be <= PASSGEN_MAX_LENGTH
    int level;
} PassGen;

void state_free(PassGen* app) {
    // NOTE: would have preferred if a "safe" memset() was available...
    //       but, since cannot prevent optimization from removing
    //       memset(), fill with random data instead.
    furi_hal_random_fill_buf((void*)(app->password), PASSGEN_MAX_LENGTH);

    gui_remove_view_port(app->gui, app->view_port);
    furi_record_close(RECORD_GUI);
    view_port_free(app->view_port);
    furi_message_queue_free(app->input_queue);
    furi_mutex_free(app->mutex);
    furi_record_close(RECORD_NOTIFICATION);
    free(app);
}

static void input_callback(InputEvent* input_event, void* ctx) {
    PassGen* app = ctx;
    if(input_event->type == InputTypeShort) {
        furi_message_queue_put(app->input_queue, input_event, 0);
    }
}

static void render_callback(Canvas* canvas, void* ctx) {
    char str_length[8];
    PassGen* app = ctx;
    furi_check(furi_mutex_acquire(app->mutex, FuriWaitForever) == FuriStatusOk);

    canvas_clear(canvas);
    canvas_draw_box(canvas, 0, 0, 128, 14);
    canvas_set_color(canvas, ColorWhite);
    canvas_set_font(canvas, FontPrimary);
    canvas_draw_str(canvas, 2, 11, "Password Generator");

    canvas_set_color(canvas, ColorBlack);
    canvas_draw_str_aligned(canvas, 64, 35, AlignCenter, AlignCenter, app->password);

    // Navigation menu:
    canvas_set_font(canvas, FontSecondary);
    canvas_draw_icon(canvas, 96, 52, &I_Pin_back_arrow_10x8);
    canvas_draw_str(canvas, 108, 60, "Exit");

    canvas_draw_icon(canvas, 54, 52, &I_Vertical_arrow_7x9);
    canvas_draw_str(canvas, 64, 60, AlphabetLevelNames[app->level]);

    snprintf(str_length, sizeof(str_length), "Len: %d", app->length);
    canvas_draw_icon(canvas, 4, 53, &I_Horizontal_arrow_9x7);
    canvas_draw_str(canvas, 15, 60, str_length);

    furi_mutex_release(app->mutex);
}

void build_alphabet(PassGen* app) {
    PassGen_Alphabet mode = AlphabetLevels[app->level];
    if(mode > 0 && mode < 16) {
        app->alphabet = PassGen_AlphabetChars[mode];
    } else {
        app->alphabet =
            PassGen_AlphabetChars[0]; // Invalid mode ... password will be all zero digits
    }
}

PassGen* state_init() {
    PassGen* app = malloc(sizeof(PassGen));
    _Static_assert(8 <= PASSGEN_MAX_LENGTH, "app->length must be set <= PASSGEN_MAX_LENGTH");
    app->length = 8;
    app->level = 2;
    build_alphabet(app);
    app->input_queue = furi_message_queue_alloc(8, sizeof(InputEvent));
    app->view_port = view_port_alloc();
    app->gui = furi_record_open(RECORD_GUI);
    app->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
    view_port_input_callback_set(app->view_port, input_callback, app);
    view_port_draw_callback_set(app->view_port, render_callback, app);
    gui_add_view_port(app->gui, app->view_port, GuiLayerFullscreen);

    app->notify = furi_record_open(RECORD_NOTIFICATION);

    return app;
}

void generate(PassGen* app) {
    memset(app->password, 0, PASSGEN_MAX_LENGTH + 1);

    int char_option_count = strlen(app->alphabet);
    if(char_option_count < 0) {
        return;
    }

    // determine largest character value that avoids bias
    char ceil = CHAR_MAX - (CHAR_MAX % char_option_count) - 1;

    // iteratively fill the password buffer with random values
    // then keep only values that are in-range (no bias)
    void* remaining_buffer = app->password;
    size_t remaining_length = (app->length * sizeof(char));

    while(remaining_length != 0) {
        // fewer calls to hardware TRNG is more efficient
        furi_hal_random_fill_buf(remaining_buffer, remaining_length);

        // keep only values that are in-range (no bias)
        char* target = remaining_buffer;
        char* source = remaining_buffer;
        size_t valid_count = 0;

        for(size_t i = 0; i < remaining_length; i++) {
            int v = *source;
            // if the generated random value is in range, keep it
            if(v < ceil) {
                v %= char_option_count;
                *target = app->alphabet[v];
                // increment target pointer and count of valid items found
                target++;
                valid_count++;
            }
            // always increment the source pointer
            source++;
        }
        remaining_length -= valid_count;
        remaining_buffer = target;
    }
}

void update_password(PassGen* app, bool vibro) {
    generate(app);

    if(vibro)
        notification_message(app->notify, &PassGen_Alert_vibro);
    else
        notification_message(app->notify, &sequence_blink_blue_100);
    view_port_update(app->view_port);
}

int32_t passgenapp(void) {
    PassGen* app = state_init();
    generate(app);

    while(1) {
        InputEvent input;
        while(furi_message_queue_get(app->input_queue, &input, FuriWaitForever) == FuriStatusOk) {
            furi_check(furi_mutex_acquire(app->mutex, FuriWaitForever) == FuriStatusOk);

            if(input.type == InputTypeShort) {
                switch(input.key) {
                case InputKeyBack:
                    furi_mutex_release(app->mutex);
                    state_free(app);
                    return 0;
                case InputKeyDown:
                    if(app->level > 0) {
                        app->level--;
                        build_alphabet(app);
                        update_password(app, false);
                    } else
                        notification_message(app->notify, &sequence_blink_red_100);
                    break;
                case InputKeyUp:
                    if(app->level < AlphabetLevelsCount - 1) {
                        app->level++;
                        build_alphabet(app);
                        update_password(app, false);
                    } else
                        notification_message(app->notify, &sequence_blink_red_100);
                    break;
                case InputKeyLeft:
                    if(app->length > 1) {
                        app->length--;
                        update_password(app, false);
                    } else
                        notification_message(app->notify, &sequence_blink_red_100);
                    break;
                case InputKeyRight:
                    if(app->length < PASSGEN_MAX_LENGTH) {
                        app->length++;
                        update_password(app, false);
                    } else
                        notification_message(app->notify, &sequence_blink_red_100);
                    break;
                case InputKeyOk:
                    update_password(app, true);
                    break;
                default:
                    break;
                }
            }
            furi_mutex_release(app->mutex);
        }
    }
    state_free(app);
    return 0;
}