PasswordImporter Class Reference

#include <PasswordImporter.hpp>

Static Public Member Functions
static std::vector< ImportedCredential >	importFromFile (const std::string &path, std::string &errorMsg)
static BrowserFormat	detectFormat (const std::string &headerLine)
static PasswordEntry	toPasswordEntry (const ImportedCredential &cred)
static std::string	domainFromUrl (const std::string &url)

Static Private Member Functions
static std::vector< ImportedCredential >	parseChrome (const std::vector< std::string > &lines)
static std::vector< ImportedCredential >	parseFirefox (const std::vector< std::string > &lines)
static std::vector< ImportedCredential >	parseSafari (const std::vector< std::string > &lines)
static std::vector< std::string >	splitCsvLine (const std::string &line)
static std::string	unquoteCsv (const std::string &field)

Detailed Description

Definition at line 43 of file PasswordImporter.hpp.

Member Function Documentation

detectFormat()

BrowserFormat PasswordImporter::detectFormat ( const std::string & headerLine )

static

Definition at line 77 of file PasswordImporter.cpp.

                                                                    {
    std::string h = header;
    std::transform(h.begin(), h.end(), h.begin(), ::tolower);
    if (h.find("httprealm") != std::string::npos ||
        h.find("formactionorigin") != std::string::npos)
        return BrowserFormat::Firefox;
    if (h.find("otpauth") != std::string::npos ||
        (h.find("title") != std::string::npos && h.find("notes") != std::string::npos))
        return BrowserFormat::Safari;
    if (h.find("name") != std::string::npos &&
        h.find("url") != std::string::npos &&
        h.find("username") != std::string::npos &&
        h.find("password") != std::string::npos)
        return BrowserFormat::Chrome;
 
    return BrowserFormat::Unknown;
}

References Chrome, Firefox, Safari, and Unknown.

Referenced by importFromFile(), and PasswordImportDialog::loadFile().

domainFromUrl()

std::string PasswordImporter::domainFromUrl ( const std::string & url )

static

Definition at line 288 of file PasswordImporter.cpp.

                                                              {
    if (url.empty()) return "";
    std::string s = url;
    const auto schema_end = s.find("://");
    if (schema_end != std::string::npos)
        s = s.substr(schema_end + 3);
    const auto slash = s.find('/');
    if (slash != std::string::npos)
        s = s.substr(0, slash);
    const auto colon = s.find(':');
    if (colon != std::string::npos)
        s = s.substr(0, colon);
    if (s.substr(0, 4) == "www.")
        s = s.substr(4);
 
    return s;
}

Referenced by parseFirefox(), PasswordImportDialog::populatePreview(), and toPasswordEntry().

importFromFile()

std::vector< ImportedCredential > PasswordImporter::importFromFile ( const std::string & path, std::string & errorMsg )

static

Definition at line 29 of file PasswordImporter.cpp.

{
    std::ifstream in(path);
    if (!in.is_open()) {
        errorMsg = "Impossibile aprire il file: " + path;
        return {};
    }
 
    std::vector<std::string> lines;
    std::string line;
    while (std::getline(in, line)) {
        if (!lines.empty() == false && line.size() >= 3 &&
            static_cast<unsigned char>(line[0]) == 0xEF &&
            static_cast<unsigned char>(line[1]) == 0xBB &&
            static_cast<unsigned char>(line[2]) == 0xBF) {
            line = line.substr(3);
        }
        if (!line.empty() && line.back() == '\r')
            line.pop_back();
        if (!line.empty())
            lines.push_back(line);
    }
 
    if (lines.empty()) {
        errorMsg = "Il file è vuoto.";
        return {};
    }
 
    const BrowserFormat fmt = detectFormat(lines[0]);
 
    switch (fmt) {
        case BrowserFormat::Chrome:
        case BrowserFormat::Edge:
            return parseChrome(lines);
        case BrowserFormat::Firefox:
            return parseFirefox(lines);
        case BrowserFormat::Safari:
            return parseSafari(lines);
        default:
            errorMsg = "Formato CSV non riconosciuto.\n"
                       "Header trovato: " + lines[0] + "\n"
                       "Formati supportati: Chrome, Edge, Firefox, Safari.";
            return {};
    }
}

References Chrome, detectFormat(), Edge, Firefox, parseChrome(), parseFirefox(), parseSafari(), and Safari.

Referenced by PasswordImportDialog::loadFile().

parseChrome()

std::vector< ImportedCredential > PasswordImporter::parseChrome ( const std::vector< std::string > & lines )

staticprivate

Definition at line 106 of file PasswordImporter.cpp.

{
    std::vector<ImportedCredential> result;
 
    auto header = splitCsvLine(lines[0]);
    int iName = -1, iUrl = -1, iUser = -1, iPass = -1;
 
    for (int i = 0; i < static_cast<int>(header.size()); ++i) {
        std::string col = header[i];
        std::transform(col.begin(), col.end(), col.begin(), ::tolower);
        if (col == "name")     iName = i;
        else if (col == "url") iUrl  = i;
        else if (col == "username") iUser = i;
        else if (col == "password") iPass = i;
    }
 
    if (iUrl < 0 || iUser < 0 || iPass < 0) return result;
 
    for (size_t r = 1; r < lines.size(); ++r) {
        auto fields = splitCsvLine(lines[r]);
        if (fields.size() < 3) continue;
 
        auto get = [&](int idx) -> std::string {
            if (idx < 0 || idx >= static_cast<int>(fields.size())) return "";
            return unquoteCsv(fields[idx]);
        };
 
        ImportedCredential c;
        c.name     = get(iName);
        c.url      = get(iUrl);
        c.username = get(iUser);
        c.password = get(iPass);
 
        if (c.url.empty() && c.username.empty()) continue;
        result.push_back(std::move(c));
    }
 
    return result;
}

References ImportedCredential::name, ImportedCredential::password, splitCsvLine(), unquoteCsv(), ImportedCredential::url, and ImportedCredential::username.

Referenced by importFromFile().

parseFirefox()

std::vector< ImportedCredential > PasswordImporter::parseFirefox ( const std::vector< std::string > & lines )

staticprivate

Definition at line 148 of file PasswordImporter.cpp.

{
    std::vector<ImportedCredential> result;
 
    auto header = splitCsvLine(lines[0]);
    int iUrl = -1, iUser = -1, iPass = -1;
 
    for (int i = 0; i < static_cast<int>(header.size()); ++i) {
        std::string col = header[i];
        std::transform(col.begin(), col.end(), col.begin(), ::tolower);
        if (col == "url")      iUrl  = i;
        else if (col == "username") iUser = i;
        else if (col == "password") iPass = i;
    }
 
    if (iUrl < 0 || iUser < 0 || iPass < 0) return result;
 
    for (size_t r = 1; r < lines.size(); ++r) {
        auto fields = splitCsvLine(lines[r]);
        if (fields.size() < 3) continue;
 
        auto get = [&](int idx) -> std::string {
            if (idx < 0 || idx >= static_cast<int>(fields.size())) return "";
            return unquoteCsv(fields[idx]);
        };
 
        ImportedCredential c;
        c.url      = get(iUrl);
        c.username = get(iUser);
        c.password = get(iPass);
        c.name     = domainFromUrl(c.url);
 
        if (c.url.empty() && c.username.empty()) continue;
        result.push_back(std::move(c));
    }
 
    return result;
}

References domainFromUrl(), ImportedCredential::name, ImportedCredential::password, splitCsvLine(), unquoteCsv(), ImportedCredential::url, and ImportedCredential::username.

Referenced by importFromFile().

parseSafari()

std::vector< ImportedCredential > PasswordImporter::parseSafari ( const std::vector< std::string > & lines )

staticprivate

Definition at line 189 of file PasswordImporter.cpp.

{
    std::vector<ImportedCredential> result;
 
    auto header = splitCsvLine(lines[0]);
    int iTitle = -1, iUrl = -1, iUser = -1, iPass = -1, iNotes = -1;
 
    for (int i = 0; i < static_cast<int>(header.size()); ++i) {
        std::string col = header[i];
        std::transform(col.begin(), col.end(), col.begin(), ::tolower);
        if (col == "title")    iTitle = i;
        else if (col == "url") iUrl   = i;
        else if (col == "username") iUser  = i;
        else if (col == "password") iPass  = i;
        else if (col == "notes")    iNotes = i;
    }
 
    if (iUrl < 0 || iUser < 0 || iPass < 0) return result;
 
    for (size_t r = 1; r < lines.size(); ++r) {
        auto fields = splitCsvLine(lines[r]);
        if (fields.size() < 3) continue;
 
        auto get = [&](int idx) -> std::string {
            if (idx < 0 || idx >= static_cast<int>(fields.size())) return "";
            return unquoteCsv(fields[idx]);
        };
 
        ImportedCredential c;
        c.name     = get(iTitle);
        c.url      = get(iUrl);
        c.username = get(iUser);
        c.password = get(iPass);
        c.notes    = get(iNotes);
 
        if (c.url.empty() && c.username.empty()) continue;
        result.push_back(std::move(c));
    }
 
    return result;
}

References ImportedCredential::name, ImportedCredential::notes, ImportedCredential::password, splitCsvLine(), unquoteCsv(), ImportedCredential::url, and ImportedCredential::username.

Referenced by importFromFile().

splitCsvLine()

std::vector< std::string > PasswordImporter::splitCsvLine ( const std::string & line )

staticprivate

Definition at line 233 of file PasswordImporter.cpp.

                                                                         {
    std::vector<std::string> fields;
    std::string field;
    bool inQuotes = false;
 
    for (size_t i = 0; i < line.size(); ++i) {
        const char c = line[i];
 
        if (inQuotes) {
            if (c == '"') {
                if (i + 1 < line.size() && line[i + 1] == '"') {
                    field += '"';
                    ++i;
                } else {
                    inQuotes = false;
                }
            } else {
                field += c;
            }
        } else {
            if (c == '"') {
                inQuotes = true;
            } else if (c == ',') {
                fields.push_back(field);
                field.clear();
            } else {
                field += c;
            }
        }
    }
    fields.push_back(field);
    return fields;
}

Referenced by parseChrome(), parseFirefox(), and parseSafari().

toPasswordEntry()

PasswordEntry PasswordImporter::toPasswordEntry ( const ImportedCredential & cred )

static

Definition at line 96 of file PasswordImporter.cpp.

                                                                              {
    PasswordEntry e;
    e.name     = cred.name.empty() ? domainFromUrl(cred.url) : cred.name;
    e.url      = cred.url;
    e.username = cred.username;
    e.notes    = cred.notes;
    return e;
}

References domainFromUrl(), ImportedCredential::name, PasswordEntry::name, ImportedCredential::notes, PasswordEntry::notes, ImportedCredential::url, PasswordEntry::url, ImportedCredential::username, and PasswordEntry::username.

Referenced by PasswordImportDialog::onImportClicked().

unquoteCsv()

std::string PasswordImporter::unquoteCsv ( const std::string & field )

staticprivate

Definition at line 268 of file PasswordImporter.cpp.

                                                         {
    if (f.size() >= 2 && f.front() == '"' && f.back() == '"') {
        std::string inner = f.substr(1, f.size() - 2);
        // Unescapa "" → "
        std::string out;
        out.reserve(inner.size());
        for (size_t i = 0; i < inner.size(); ++i) {
            if (inner[i] == '"' && i + 1 < inner.size() && inner[i + 1] == '"') {
                out += '"';
                ++i;
            } else {
                out += inner[i];
            }
        }
        return out;
    }
    return f;
}

Referenced by parseChrome(), parseFirefox(), and parseSafari().

---

The documentation for this class was generated from the following files:

• BastionGuard/src/password_manager/PasswordImporter.hpp
• BastionGuard/src/password_manager/PasswordImporter.cpp