PasswordImporter.cpp

Go to the documentation of this file.

/*
 * BastionGuard™
 * Copyright (C) 2025–2026 Calogero Scarnà
 *
 * 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, version 3.
 *
 * 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/>.
 *
 * BastionGuard™ is a trademark of Calogero Scarnà.
 * The BastionGuard™ name and branding are not licensed under the GPL.
 */
 
#include "PasswordImporter.hpp"
 
#include <fstream>
#include <sstream>
#include <algorithm>
#include <regex>
 
 
std::vector<ImportedCredential> PasswordImporter::importFromFile(
    const std::string& path,
    std::string&       errorMsg)
{
    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 {};
    }
}
 
BrowserFormat PasswordImporter::detectFormat(const std::string& header) {
    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;
}
 
 
PasswordEntry PasswordImporter::toPasswordEntry(const ImportedCredential& cred) {
    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;
}
 
 
std::vector<ImportedCredential> PasswordImporter::parseChrome(
    const std::vector<std::string>& lines)
{
    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;
}
 
 
std::vector<ImportedCredential> PasswordImporter::parseFirefox(
    const std::vector<std::string>& lines)
{
    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;
}
 
 
std::vector<ImportedCredential> PasswordImporter::parseSafari(
    const std::vector<std::string>& lines)
{
    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;
}
 
 
std::vector<std::string> PasswordImporter::splitCsvLine(const std::string& line) {
    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;
}
 
 
std::string PasswordImporter::unquoteCsv(const std::string& f) {
    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;
}
 
 
std::string PasswordImporter::domainFromUrl(const std::string& url) {
    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;
}