PasswordModule.cpp

Go to the documentation of this file.

#include "mod_password/PasswordModule.h"
#include "mod_password/PasswordStore.h"
#include "cdc_core/ModuleRegistry.h"
#include "cdc_core/StringUtils.h"
#include "cdc_core/TropicStorage.h"
#include "cdc_ui/BackupImport.h"
#include "cdc_core/IKeyboardProvider.h"
#include "cJSON.h"
#include "cdc_hal/ISecureElement.h"
#include "esp_random.h"
#include "cdc_ui/I18n.h"
#include "cdc_ui/ViewStack.h"
#include "cdc_views/ListView.h"
#include "cdc_views/ContextMenuView.h"
#include "cdc_views/T9InputView.h"
#include "cdc_views/InfoView.h"
#include "cdc_views/ConfirmView.h"
#include "cdc_views/ToastView.h"
#include "serial_cmd/ICommandRegistry.h"
#include "serial_cmd/SubCommand.h"
#include "serial_cmd/Console.h"
#include "cdc_log.h"
#include "esp_attr.h"
#include <cctype>
#include <cstring>
#include <strings.h>
#include <new>
#include <memory>
#include <cstdio>
 
static const char* TAG = "PASSWORD";
 
namespace cdc::mod_password {
 
constexpr ui::I18nEntry kStrings[] = {
    {"mod_password.title",          "Passwords"},
    {"mod_password.new_entry",      "New Entry"},
    {"mod_password.field_title",    "Title"},
    {"mod_password.username",       "Username"},
    {"mod_password.password",       "Password"},
    {"mod_password.url",            "URL"},
    {"mod_password.totp_slot",      "TOTP Slot (optional)"},
    {"mod_password.notes",          "Notes"},
    {"mod_password.view",           "View"},
    {"mod_password.edit",           "Edit"},
    {"mod_password.actions",        "Actions"},
    {"mod_password.invalid_input",  "Invalid input"},
    {"mod_password.slot_error",     "Slot map error"},
    {"mod_password.hint_list",      "[Y] View  [3] Menu  [N] Back"},
    {"mod_password.confirm_delete", "Delete entry?"},
    {"mod_password.hint_type",      "[Y] Type  [2/8] Scroll  [N] Back"},
    {"mod_password.no_keyboard",    "No keyboard connected"},
};
 
static void registerStrings() {
    ui::I18n::instance().registerEnglishTable(kStrings, std::size(kStrings));
}

 
static constexpr const char* CMD_MODULE = "password";
static bool s_commandsRegistered = false;
 
using cdc::core::skipSpaces;
using cdc::core::nextToken;

static bool isValidSlot(uint16_t slot) {
    auto& store = PasswordStore::instance();
    return store.hasSlotRange() && slot < store.capacity();
}

static void cmd_password_list(const char* args) {
    (void)args;
    auto& store = PasswordStore::instance();
    if (!store.hasSlotRange()) {
        cdc::serial::Console::printf("ERROR: slot map not configured\r\n");
        return;
    }
    uint16_t cap = store.capacity();
    if (cap == 0) {
        cdc::serial::Console::printf("(no entries)\r\n");
        return;
    }
    auto list = std::unique_ptr<PasswordStore::EntryIndex[]>(new (std::nothrow) PasswordStore::EntryIndex[cap]);
    if (!list) {
        cdc::serial::Console::printf("ERROR: out of memory\r\n");
        return;
    }
    uint16_t count = 0;
    if (!store.listEntriesSorted(list.get(), cap, &count)) {
        cdc::serial::Console::printf("ERROR: list failed\r\n");
        return;
    }
    if (count == 0) {
        cdc::serial::Console::printf("(no entries)\r\n");
        return;
    }
    for (uint16_t i = 0; i < count; i++) {
        cdc::serial::Console::printf("slot %u: %s\r\n", list[i].slot, list[i].title);
    }
}

static void cmd_password_get(const char* args) {
    char slotBuf[8] = {};
    const char* p = nextToken(args, slotBuf, sizeof(slotBuf));
    if (!p || !slotBuf[0]) {
        cdc::serial::Console::printf("Usage: PASSWORD GET <slot>\r\n");
        return;
    }
    uint16_t slot = static_cast<uint16_t>(atoi(slotBuf));
    if (!isValidSlot(slot)) {
        cdc::serial::Console::printf("ERROR: slot out of range\r\n");
        return;
    }
    PasswordEntry entry = {};
    if (!PasswordStore::instance().readEntry(slot, &entry)) {
        cdc::serial::Console::printf("ERROR: empty slot or read failed\r\n");
        return;
    }
    cdc::serial::Console::printf("Title: %s\r\n", entry.title);
    cdc::serial::Console::printf("Username: %s\r\n", entry.username);
    cdc::serial::Console::printf("Password: %s\r\n", entry.password);
    cdc::serial::Console::printf("URL: %s\r\n", entry.url);
    if (entry.totpSlot == PasswordStore::TOTP_SLOT_NONE) {
        cdc::serial::Console::printf("TOTP Slot: none\r\n");
    } else {
        cdc::serial::Console::printf("TOTP Slot: %u\r\n", entry.totpSlot);
    }
    cdc::serial::Console::printf("Notes: %s\r\n", entry.notes);
}

static bool isPlaceholder(const char* s) {
    return s && s[0] && s[1] == '\0' && (s[0] == 'x' || s[0] == 'X' || s[0] == '-');
}

static void generateRandomPassword(char* out, size_t outSize) {
    static const char charset[] =
        "abcdefghijklmnopqrstuvwxyz"
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        "0123456789"
        "$!%=";
    constexpr size_t charsetLen = sizeof(charset) - 1;
    constexpr uint8_t charCount = 16;
    if (outSize < charCount + 1) return;
 
    uint8_t rand[charCount] = {};
    auto* se = cdc::hal::getSecureElementInstance();
    bool gotRand = se && se->getRandom(rand, sizeof(rand));
    if (!gotRand) {
        for (uint8_t i = 0; i < charCount; i++) {
            rand[i] = static_cast<uint8_t>(esp_random() & 0xFF);
        }
    }
 
    for (uint8_t i = 0; i < charCount; i++) {
        out[i] = charset[rand[i] % charsetLen];
    }
    out[charCount] = '\0';
}
 
static void cmd_password_add(const char* args) {
    PasswordEntry entry = {};
    entry.totpSlot = PasswordStore::TOTP_SLOT_NONE;
 
    char slotBuf[8] = {};
    char title[PasswordStore::TITLE_LEN + 1] = {};
    char username[PasswordStore::USERNAME_LEN + 1] = {};
    char password[PasswordStore::PASSWORD_LEN + 1] = {};
    char url[PasswordStore::URL_LEN + 1] = {};
    char totpBuf[8] = {};
 
    static constexpr const char* USAGE =
        "Usage: PASSWORD ADD <slot|x> <title> <username|x> <password|x> <url|x> <totp|-> [notes]\r\n"
        "  <slot>: target RMEM slot, or 'x' for next free. Overwrites if occupied.\r\n"
        "  <password>: value, or 'x' to generate a random 16-char password.\r\n"
        "  <totp>: linked TOTP slot number, or '-' for no link.\r\n"
        "  Use 'x' for username/url to skip them. Use '\\\\ ' for spaces inside fields.\r\n";
 
    const char* p = nextToken(args, slotBuf, sizeof(slotBuf));
    if (!p || !slotBuf[0]) {
        cdc::serial::Console::printf("%s", USAGE);
        return;
    }
    p = nextToken(p, title, sizeof(title));
    p = nextToken(p, username, sizeof(username));
    p = nextToken(p, password, sizeof(password));
    p = nextToken(p, url, sizeof(url));
    p = nextToken(p, totpBuf, sizeof(totpBuf));
    if (!title[0] || !username[0] || !password[0] || !url[0] || !totpBuf[0]) {
        cdc::serial::Console::printf("%s", USAGE);
        return;
    }
 
    const char* notes = skipSpaces(p);
 
    auto& store = PasswordStore::instance();
 
    uint16_t slot = 0;
    if (isPlaceholder(slotBuf)) {
        if (!store.findFreeLogicalSlot(&slot)) {
            cdc::serial::Console::printf("ERROR: no free slots\r\n");
            return;
        }
    } else {
        slot = static_cast<uint16_t>(atoi(slotBuf));
        if (!isValidSlot(slot)) {
            cdc::serial::Console::printf("ERROR: slot out of range\r\n");
            return;
        }
    }
 
    strncpy(entry.title, title, sizeof(entry.title) - 1);
    if (!isPlaceholder(username)) {
        strncpy(entry.username, username, sizeof(entry.username) - 1);
    }
 
    char generatedPassword[40] = {};
    if (password[0] == 'x' && password[1] == '\0') {
        generateRandomPassword(generatedPassword, sizeof(generatedPassword));
        strncpy(entry.password, generatedPassword, sizeof(entry.password) - 1);
    } else if (!isPlaceholder(password)) {
        strncpy(entry.password, password, sizeof(entry.password) - 1);
    }
 
    if (!isPlaceholder(url)) {
        strncpy(entry.url, url, sizeof(entry.url) - 1);
    }
 
    if (totpBuf[0] != '-' || totpBuf[1] != '\0') {
        int totp = atoi(totpBuf);
        if (totp < 0 || totp > 254) {
            cdc::serial::Console::printf("ERROR: totp slot out of range (0-254 or '-')\r\n");
            return;
        }
        entry.totpSlot = static_cast<uint8_t>(totp);
    }
 
    if (notes && notes[0]) {
        strncpy(entry.notes, notes, sizeof(entry.notes) - 1);
        cdc::core::unescapeSpaces(entry.notes);
    }
 
    bool ok = store.updateEntry(slot, entry);
    if (ok) {
        if (generatedPassword[0]) {
            cdc::serial::Console::printf("Generated password: %s\r\n", generatedPassword);
        }
        cdc::serial::Console::printf("OK (slot %u)\r\n", slot);
    } else {
        cdc::serial::Console::printf("ERROR\r\n");
    }
}

static void cmd_password_edit(const char* args) {
    char slotBuf[8] = {};
    char field[16] = {};
    const char* usage =
        "Usage: PASSWORD EDIT <slot> <title|username|password|url|totp|notes> <value>\r\n"
        "  Use '\\\\ ' for spaces inside values.\r\n";
 
    const char* p = nextToken(args, slotBuf, sizeof(slotBuf));
    if (!p || !slotBuf[0]) {
        cdc::serial::Console::printf("%s", usage);
        return;
    }
    p = nextToken(p, field, sizeof(field));
    if (!field[0]) {
        cdc::serial::Console::printf("%s", usage);
        return;
    }
 
    uint16_t slot = static_cast<uint16_t>(atoi(slotBuf));
    if (!isValidSlot(slot)) {
        cdc::serial::Console::printf("ERROR: slot out of range\r\n");
        return;
    }
 
    PasswordEntry entry = {};
    if (!PasswordStore::instance().readEntry(slot, &entry)) {
        cdc::serial::Console::printf("ERROR: empty slot or read failed\r\n");
        return;
    }
 
    const char* value = skipSpaces(p);
    if (!value || !value[0]) {
        cdc::serial::Console::printf("ERROR: empty value\r\n");
        return;
    }
 
    if (strcasecmp(field, "title") == 0) {
        if (strlen(value) > PasswordStore::TITLE_LEN) {
            cdc::serial::Console::printf("ERROR: title too long (max %u)\r\n", PasswordStore::TITLE_LEN);
            return;
        }
        memset(entry.title, 0, sizeof(entry.title));
        strncpy(entry.title, value, sizeof(entry.title) - 1);
        cdc::core::unescapeSpaces(entry.title);
    } else if (strcasecmp(field, "username") == 0) {
        if (strlen(value) > PasswordStore::USERNAME_LEN) {
            cdc::serial::Console::printf("ERROR: username too long (max %u)\r\n", PasswordStore::USERNAME_LEN);
            return;
        }
        memset(entry.username, 0, sizeof(entry.username));
        strncpy(entry.username, value, sizeof(entry.username) - 1);
        cdc::core::unescapeSpaces(entry.username);
    } else if (strcasecmp(field, "password") == 0) {
        if (strlen(value) > PasswordStore::PASSWORD_LEN) {
            cdc::serial::Console::printf("ERROR: password too long (max %u)\r\n", PasswordStore::PASSWORD_LEN);
            return;
        }
        memset(entry.password, 0, sizeof(entry.password));
        strncpy(entry.password, value, sizeof(entry.password) - 1);
        cdc::core::unescapeSpaces(entry.password);
    } else if (strcasecmp(field, "url") == 0) {
        if (strlen(value) > PasswordStore::URL_LEN) {
            cdc::serial::Console::printf("ERROR: url too long (max %u)\r\n", PasswordStore::URL_LEN);
            return;
        }
        memset(entry.url, 0, sizeof(entry.url));
        strncpy(entry.url, value, sizeof(entry.url) - 1);
        cdc::core::unescapeSpaces(entry.url);
    } else if (strcasecmp(field, "totp") == 0) {
        int totp = atoi(value);
        if (totp < 0 || totp > 254) {
            cdc::serial::Console::printf("ERROR: totp slot out of range (0-254)\r\n");
            return;
        }
        entry.totpSlot = static_cast<uint8_t>(totp);
    } else if (strcasecmp(field, "notes") == 0) {
        if (strlen(value) > PasswordStore::NOTES_LEN) {
            cdc::serial::Console::printf("ERROR: notes too long (max %u)\r\n", static_cast<unsigned>(PasswordStore::NOTES_LEN));
            return;
        }
        memset(entry.notes, 0, sizeof(entry.notes));
        strncpy(entry.notes, value, sizeof(entry.notes) - 1);
        cdc::core::unescapeSpaces(entry.notes);
    } else {
        cdc::serial::Console::printf("%s", usage);
        return;
    }
 
    bool ok = PasswordStore::instance().updateEntry(slot, entry);
    cdc::serial::Console::printf(ok ? "OK\r\n" : "ERROR\r\n");
}

static void cmd_password_del(const char* args) {
    char slotBuf[8] = {};
    const char* p = nextToken(args, slotBuf, sizeof(slotBuf));
    if (!p || !slotBuf[0]) {
        cdc::serial::Console::printf("Usage: PASSWORD DEL <slot>\r\n");
        return;
    }
    uint16_t slot = static_cast<uint16_t>(atoi(slotBuf));
    if (!isValidSlot(slot)) {
        cdc::serial::Console::printf("ERROR: slot out of range\r\n");
        return;
    }
    bool ok = PasswordStore::instance().deleteEntry(slot);
    cdc::serial::Console::printf(ok ? "OK\r\n" : "ERROR\r\n");
}
 
static const cdc::serial::SubCommand kPasswordSubs[] = {
    {"LIST", "",                                                                        "List password entries (sorted by title)", cmd_password_list},
    {"GET",  "<slot>",                                                                  "Show one entry by slot",                  cmd_password_get},
    {"ADD",  "<slot|x> <title> <user|x> <pw|x> <url|x> <totp|-> [notes]",                "Add entry; 'x' for fields skips them",    cmd_password_add},
    {"EDIT", "<slot> <field> <value>",                                                   "Edit one field of an existing entry",     cmd_password_edit},
    {"DEL",  "<slot>",                                                                  "Delete entry by slot",                    cmd_password_del},
    {nullptr, nullptr, nullptr, nullptr},
};
 
static void cmd_password(const char* args) {
    cdc::serial::dispatchSubCommand("PASSWORD", args, kPasswordSubs);
}

static void registerCommands() {
    if (s_commandsRegistered) return;
    s_commandsRegistered = true;
 
    auto& reg = cdc::serial::getCommandRegistry();
    reg.registerCommand({"PASSWORD",
                         "Password vault: LIST/GET/ADD/EDIT/DEL",
                         cmd_password, CMD_MODULE, true, kPasswordSubs});
}

 
static ui::ListView s_listView;
static ui::T9InputView s_t9Input;
static ui::InfoView s_infoView;
static bool s_viewsInitialized = false;
 
static ui::ListItem* s_listItems = nullptr;
static PasswordStore::EntryIndex* s_entries = nullptr;
static uint16_t s_entryCount = 0;
static uint16_t s_capacity = 0;
 
static uint16_t s_activeSlot = 0;
 
struct WizardState {
    PasswordEntry entry;
    bool editMode;
    uint16_t editSlot;
};
 
EXT_RAM_BSS_ATTR static WizardState s_wizard = {};
 
static constexpr uint16_t NOTES_INPUT_MAX =
    (PasswordStore::NOTES_LEN < ui::T9InputView::MAX_TEXT_LEN)
        ? static_cast<uint16_t>(PasswordStore::NOTES_LEN)
        : static_cast<uint16_t>(ui::T9InputView::MAX_TEXT_LEN);

static void freeListBuffers() {
    delete[] s_listItems;
    delete[] s_entries;
    s_listItems = nullptr;
    s_entries = nullptr;
    s_capacity = 0;
    s_entryCount = 0;
}

static bool ensureListBuffers() {
    uint16_t cap = PasswordStore::instance().capacity();
    if (cap == 0) return false;
    if (cap == s_capacity && s_listItems && s_entries) return true;
 
    delete[] s_listItems;
    delete[] s_entries;
    s_listItems = nullptr;
    s_entries = nullptr;
    s_capacity = 0;
 
    s_listItems = new (std::nothrow) ui::ListItem[cap + 1];
    s_entries = new (std::nothrow) PasswordStore::EntryIndex[cap];
    if (!s_listItems || !s_entries) {
        delete[] s_listItems;
        delete[] s_entries;
        s_listItems = nullptr;
        s_entries = nullptr;
        s_capacity = 0;
        return false;
    }
    s_capacity = cap;
    return true;
}

static void rebuildList() {
    if (!PasswordStore::instance().hasSlotRange()) {
        ui::showToastError(ui::tr("mod_password.slot_error"));
        return;
    }
    if (!ensureListBuffers()) {
        cdc::core::ModuleRegistry::instance().reportModuleError(PasswordModule::instance().getName(),
                                                               "Password list allocation failed");
        return;
    }
    s_entryCount = 0;
    s_listItems[0] = {ui::tr("mod_password.new_entry"), 0, false, nullptr};
 
    uint16_t count = 0;
    PasswordStore::instance().listEntriesSorted(s_entries, s_capacity, &count);
    s_entryCount = count;
 
    for (uint16_t i = 0; i < s_entryCount; i++) {
        uint16_t idx = static_cast<uint16_t>(i + 1);
        s_listItems[idx].label = s_entries[i].title;
        s_listItems[idx].icon = 0;
        s_listItems[idx].iconDisabled = false;
        s_listItems[idx].userData = reinterpret_cast<void*>(static_cast<uintptr_t>(s_entries[i].slot));
    }
 
    s_listView.init(ui::tr("mod_password.title"), s_listItems, static_cast<uint16_t>(s_entryCount + 1));
s_listView.setHint(ui::tr("mod_password.hint_list"));
}

static char s_passwordToType[PasswordStore::PASSWORD_LEN + 1] = {};

static void onTypePassword(void* userData) {
    (void)userData;
    auto* kb = core::getKeyboard();
    if (kb && kb->isConnected()) {
        if (s_passwordToType[0]) {
            kb->typeString(s_passwordToType);
            ui::showToastSuccess("Typed");
        }
    } else {
        ui::showToastError(ui::tr("mod_password.no_keyboard"));
    }
}

static void showDetails(uint16_t slot) {
    PasswordEntry entry = {};
    if (!PasswordStore::instance().readEntry(slot, &entry)) {
        ui::showToastError(ui::tr("core.failed"));
        return;
    }
 
    // Store password for type callback
    strncpy(s_passwordToType, entry.password, sizeof(s_passwordToType) - 1);
    s_passwordToType[sizeof(s_passwordToType) - 1] = '\0';
 
    static EXT_RAM_BSS_ATTR char detailText[ui::InfoView::MAX_TEXT_LEN];
    char totpBuf[16] = {};
    const char* emptyText = ui::tr("core.empty");
    char emptyWrapped[16] = {};
    snprintf(emptyWrapped, sizeof(emptyWrapped), "(%s)", emptyText);
    const char* totpText = emptyWrapped;
    if (entry.totpSlot != PasswordStore::TOTP_SLOT_NONE) {
        snprintf(totpBuf, sizeof(totpBuf), "%u", entry.totpSlot);
        totpText = totpBuf;
    }
    const char* usernameText = entry.username[0] ? entry.username : emptyWrapped;
    const char* passwordText = entry.password[0] ? entry.password : emptyWrapped;
    const char* urlText = entry.url[0] ? entry.url : emptyWrapped;
    const char* notesText = entry.notes[0] ? entry.notes : emptyWrapped;
 
    snprintf(detailText, sizeof(detailText),
             "Title: %s\n"
             "Username: %s\n"
             "Password: %s\n"
             "URL: %s\n"
             "TOTP Slot: %s\n"
             "Notes: %s",
             entry.title,
             usernameText,
             passwordText,
             urlText,
             totpText,
             notesText);
 
    s_infoView.init(ui::tr("core.details"), detailText);
 
    // Set up Type callback if keyboard is available
    auto* kb = core::getKeyboard();
    if (kb && kb->isConnected() && s_passwordToType[0]) {
        s_infoView.setYesNoCallbacks(onTypePassword, nullptr, nullptr);
        s_infoView.setHint(ui::tr("mod_password.hint_type"));
    } else {
        s_infoView.setYesNoCallbacks(nullptr, nullptr, nullptr);
        s_infoView.setHint(nullptr);
    }
 
    ui::ViewStack::instance().push(&s_infoView);
}

static void wizardFinish() {
    bool ok = false;
    if (s_wizard.editMode) {
        ok = PasswordStore::instance().updateEntry(s_wizard.editSlot, s_wizard.entry);
    } else {
        ok = PasswordStore::instance().addEntry(s_wizard.entry);
    }
 
    if (ok) {
        ui::showToastSuccess(ui::tr("core.saved"));
        s_listView.preservePosition();
        rebuildList();
        ui::ViewStack::instance().popToAnchor(&s_listView);
    } else {
        ui::showToastError(ui::tr("core.failed"));
    }
}

static void pushT9WizardStep(const char* title, const char* initialText,
                             uint16_t maxLen, ui::T9InputView::SaveCallback onSave) {
    s_t9Input.init(title, initialText, maxLen);
    s_t9Input.setOnSave(onSave);
    ui::ViewStack::instance().push(&s_t9Input);
}
 
static void onWizardTitle(const char* text);
static void onWizardUsername(const char* text);
static void onWizardPassword(const char* text);
static void onWizardUrl(const char* text);
static void onWizardTotp(const char* text);
static void onWizardNotes(const char* text);

static void wizardStart() {
    memset(&s_wizard, 0, sizeof(s_wizard));
    s_wizard.entry.totpSlot = PasswordStore::TOTP_SLOT_NONE;
    s_wizard.editMode = false;
    s_wizard.editSlot = 0;
 
    pushT9WizardStep(ui::tr("mod_password.field_title"), nullptr, PasswordStore::TITLE_LEN, onWizardTitle);
}

static void wizardEdit(uint16_t slot) {
    PasswordEntry entry = {};
    if (!PasswordStore::instance().readEntry(slot, &entry)) {
        ui::showToastError(ui::tr("core.failed"));
        return;
    }
 
    memset(&s_wizard, 0, sizeof(s_wizard));
    s_wizard.entry = entry;
    s_wizard.editMode = true;
    s_wizard.editSlot = slot;
 
    pushT9WizardStep(ui::tr("mod_password.field_title"), s_wizard.entry.title, PasswordStore::TITLE_LEN, onWizardTitle);
}

static void onWizardTitle(const char* text) {
    strncpy(s_wizard.entry.title, text ? text : "", sizeof(s_wizard.entry.title) - 1);
    s_wizard.entry.title[sizeof(s_wizard.entry.title) - 1] = '\0';
    pushT9WizardStep(ui::tr("mod_password.username"), s_wizard.entry.username, PasswordStore::USERNAME_LEN, onWizardUsername);
}

static void onWizardUsername(const char* text) {
    strncpy(s_wizard.entry.username, text ? text : "", sizeof(s_wizard.entry.username) - 1);
    s_wizard.entry.username[sizeof(s_wizard.entry.username) - 1] = '\0';
    s_t9Input.init(ui::tr("mod_password.password"), s_wizard.entry.password, PasswordStore::PASSWORD_LEN);
    s_t9Input.setHint("x=Random Y=OK N=Back");
    s_t9Input.setOnSave(onWizardPassword);
    ui::ViewStack::instance().push(&s_t9Input);
}

static void onWizardPassword(const char* text) {
    if (text && text[0] == 'x' && text[1] == '\0') {
        char generated[40] = {};
        generateRandomPassword(generated, sizeof(generated));
        strncpy(s_wizard.entry.password, generated, sizeof(s_wizard.entry.password) - 1);
    } else {
        strncpy(s_wizard.entry.password, text ? text : "", sizeof(s_wizard.entry.password) - 1);
    }
    s_wizard.entry.password[sizeof(s_wizard.entry.password) - 1] = '\0';
    pushT9WizardStep(ui::tr("mod_password.url"), s_wizard.entry.url, PasswordStore::URL_LEN, onWizardUrl);
}

static void onWizardUrl(const char* text) {
    strncpy(s_wizard.entry.url, text ? text : "", sizeof(s_wizard.entry.url) - 1);
    s_wizard.entry.url[sizeof(s_wizard.entry.url) - 1] = '\0';
 
    char totpBuf[8] = {};
    if (s_wizard.entry.totpSlot != PasswordStore::TOTP_SLOT_NONE) {
        snprintf(totpBuf, sizeof(totpBuf), "%u", s_wizard.entry.totpSlot);
    }
    pushT9WizardStep(ui::tr("mod_password.totp_slot"), totpBuf, 3, onWizardTotp);
}

static void onWizardTotp(const char* text) {
    if (!text || !text[0]) {
        s_wizard.entry.totpSlot = PasswordStore::TOTP_SLOT_NONE;
    } else {
        int value = atoi(text);
        if (value < 0 || value > 254) {
            ui::showToastError(ui::tr("mod_password.invalid_input"));
            pushT9WizardStep(ui::tr("mod_password.totp_slot"), text, 3, onWizardTotp);
            return;
        }
        s_wizard.entry.totpSlot = static_cast<uint8_t>(value);
    }
 
    pushT9WizardStep(ui::tr("mod_password.notes"), s_wizard.entry.notes, NOTES_INPUT_MAX, onWizardNotes);
}

static void onWizardNotes(const char* text) {
    strncpy(s_wizard.entry.notes, text ? text : "", sizeof(s_wizard.entry.notes) - 1);
    s_wizard.entry.notes[sizeof(s_wizard.entry.notes) - 1] = '\0';
    wizardFinish();
}

static void onMenuView() {
    showDetails(s_activeSlot);
}

static void onMenuEdit() {
    wizardEdit(s_activeSlot);
}

static void onMenuDeleteConfirm(void* userData) {
    uint16_t slot = *static_cast<uint16_t*>(userData);
    bool ok = PasswordStore::instance().deleteEntry(slot);
    if (ok) {
        ui::showToastSuccess(ui::tr("core.deleted"));
        s_listView.preservePosition();
        rebuildList();
        ui::ViewStack::instance().popToAnchor(&s_listView);
    } else {
        ui::showToastError(ui::tr("core.failed"));
    }
}

static void onMenuDelete() {
    static uint16_t slot = 0;
    slot = s_activeSlot;
    ui::showConfirm(ui::tr("mod_password.confirm_delete"), onMenuDeleteConfirm, nullptr,
                    ui::ConfirmView::Icon::WARNING, &slot);
}

static void onListMenu(uint16_t index, void* userData) {
    (void)userData;
    if (index == 0) {
        static ui::ContextMenuItem items[] = {
            {ui::tr("mod_password.new_entry"), []() { wizardStart(); }}
        };
        ui::showContextMenu(ui::tr("mod_password.actions"), items, 1);
        return;
    }
    if (index - 1 >= s_entryCount) return;
    s_activeSlot = s_entries[index - 1].slot;
 
    static ui::ContextMenuItem items[] = {
        {ui::tr("mod_password.view"), onMenuView},
        {ui::tr("mod_password.edit"), onMenuEdit},
        {ui::tr("core.delete"), onMenuDelete}
    };
    ui::showContextMenu(ui::tr("mod_password.actions"), items, 3);
}

static void onListSelect(uint16_t index, void* userData) {
    (void)userData;
    if (index == 0) {
        wizardStart();
        return;
    }
    if (index - 1 >= s_entryCount) return;
    s_activeSlot = s_entries[index - 1].slot;
    showDetails(s_activeSlot);
}

PasswordModule& PasswordModule::instance() {
    static PasswordModule inst;
    return inst;
}

bool PasswordModule::init() {
    LOG_I(TAG, "Initializing Password module");
    registerStrings();
    registerCommands();
 
    core::ModuleRegistry::instance().registerModule(this);
    if (slotRange_.hasRmem) {
        PasswordStore::instance().setSlotRange(slotRange_);
        core::ModuleRegistry::instance().clearModuleErrorByName(getName());
    } else {
        core::ModuleRegistry::instance().reportModuleError(getName(), "Password slot range missing");
        state_ = core::ServiceState::ERROR;
        return false;
    }
    state_ = core::ServiceState::INITIALIZED;
    return true;
}

void PasswordModule::stop() {
    freeListBuffers();
    ModuleBase::stop();
}

void PasswordModule::setSlotRange(const core::IModule::SlotRange& range) {
    slotRange_ = range;
}

core::IModule::SlotRequest PasswordModule::getSlotRequest() const {
    core::IModule::SlotRequest req = {};
    req.mapName = getName();
    req.minRmemSlots = 1;
    return req;
}

uint8_t PasswordModule::getMenuItems(core::ModuleMenuItem* items, uint8_t maxItems) {
    if (!items || maxItems == 0) return 0;
 
    items[0] = {ui::tr("mod_password.title"), 55, []() -> ui::IView* {
        if (!s_viewsInitialized) {
            s_listView.setOnSelect(onListSelect);
            s_listView.setOnMenu(onListMenu);
            s_viewsInitialized = true;
        }
        if (!PasswordStore::instance().hasSlotRange()) {
            ui::showToastError(ui::tr("mod_password.slot_error"));
            return nullptr;
        }
        rebuildList();
        return &s_listView;
    }, nullptr, getName(), core::MenuLocation::MAIN_MENU, nullptr};
 
    return 1;
}

static constexpr int kSchemaVer = 1;

bool PasswordModule::exportBackup(cJSON* out) {
    if (!out) return false;
 
    auto& store = PasswordStore::instance();
    if (!store.hasSlotRange()) return false;
 
    cJSON_AddNumberToObject(out, "schema_ver", kSchemaVer);
    cJSON* entries = cJSON_AddArrayToObject(out, "entries");
    if (!entries) return false;
 
    struct ExportCtx {
        cJSON* arr;
        uint16_t count;
    } ctx = { entries, 0 };
 
    auto cb = [](uint16_t slot, const cdc::core::TropicStorage::CacheEntry&, void* user) {
        auto* c = static_cast<ExportCtx*>(user);
        auto& store = PasswordStore::instance();
 
        uint16_t logical = 0;
        if (!store.toLogicalSlot(slot, &logical)) return;
 
        PasswordEntry entry = {};
        if (!store.readEntry(logical, &entry)) return;
 
        cJSON* obj = cJSON_CreateObject();
        if (!obj) return;
 
        cJSON_AddStringToObject(obj, "title",     entry.title);
        cJSON_AddStringToObject(obj, "username",  entry.username);
        cJSON_AddStringToObject(obj, "password",  entry.password);
        cJSON_AddStringToObject(obj, "url",       entry.url);
        cJSON_AddStringToObject(obj, "notes",     entry.notes);
        cJSON_AddNumberToObject(obj, "totp_slot", entry.totpSlot);
 
        cJSON_AddItemToArray(c->arr, obj);
        c->count++;
    };
 
    cdc::core::TropicStorage::instance().forEachSlot(
        store.moduleId(),
        store.rmemStart(),
        store.rmemEnd(),
        cb, &ctx);
 
    return ctx.count > 0;
}

static bool importPasswordEntry(const cJSON* je, void* user) {
    (void)user;
    if (!cJSON_IsObject(je)) return false;
 
    const cJSON* jTitle    = cJSON_GetObjectItemCaseSensitive(je, "title");
    const cJSON* jUsername = cJSON_GetObjectItemCaseSensitive(je, "username");
    const cJSON* jPassword = cJSON_GetObjectItemCaseSensitive(je, "password");
    const cJSON* jUrl      = cJSON_GetObjectItemCaseSensitive(je, "url");
    const cJSON* jNotes    = cJSON_GetObjectItemCaseSensitive(je, "notes");
    const cJSON* jTotpSlot = cJSON_GetObjectItemCaseSensitive(je, "totp_slot");
 
    if (!cJSON_IsString(jTitle) || !jTitle->valuestring || jTitle->valuestring[0] == '\0') {
        LOG_W(TAG, "Password import: skipping entry with no title");
        return false;
    }
 
    PasswordEntry entry = {};
    auto copyField = [](char* dst, size_t dstSize, const cJSON* j) {
        if (cJSON_IsString(j) && j->valuestring) {
            strncpy(dst, j->valuestring, dstSize - 1);
            dst[dstSize - 1] = '\0';
        }
    };
    copyField(entry.title,    sizeof(entry.title),    jTitle);
    copyField(entry.username, sizeof(entry.username), jUsername);
    copyField(entry.password, sizeof(entry.password), jPassword);
    copyField(entry.url,      sizeof(entry.url),      jUrl);
    copyField(entry.notes,    sizeof(entry.notes),    jNotes);
    entry.totpSlot = cJSON_IsNumber(jTotpSlot)
                         ? static_cast<uint8_t>(jTotpSlot->valuedouble)
                         : PasswordStore::TOTP_SLOT_NONE;
 
    auto& store = PasswordStore::instance();
    uint16_t existingSlot = 0;
    if (store.findByTitle(entry.title, &existingSlot)) {
        return store.updateEntry(existingSlot, entry);
    }
    return store.addEntry(entry);
}

core::IModule::BackupResult PasswordModule::importBackup(const cJSON* in) {
    if (!in) return {};
    if (!PasswordStore::instance().hasSlotRange()) return {};
 
    const cJSON* schemaVer = cJSON_GetObjectItemCaseSensitive(in, "schema_ver");
    if (cJSON_IsNumber(schemaVer) && static_cast<int>(schemaVer->valuedouble) != kSchemaVer) {
        LOG_W(TAG, "Password backup schema_ver %d != expected %d, skipping",
              static_cast<int>(schemaVer->valuedouble), kSchemaVer);
        return {};
    }
 
    const cJSON* entries = cJSON_GetObjectItemCaseSensitive(in, "entries");
    return cdc::ui::importJsonArray(entries, importPasswordEntry, nullptr);
}
 
} // namespace cdc::mod_password

extern "C" void mod_password_register() {
    cdc::core::ModuleRegistry::instance().registerInitializer([]() {
        auto& module = cdc::mod_password::PasswordModule::instance();
        module.init();
    });
}