BastionGuard-daemon.cpp File Reference

Go to the source code of this file.

Functions
static void	handle_signal (int)
static std::unordered_map< std::string, std::string >	parse_args (int argc, char *argv[])
static std::string	clean_domain (std::string d)
static void	load_list_file (const std::string &path, std::vector< std::string > &out)
static void	ensure_trusted_loaded ()
static bool	is_trusted_domain (const std::string &host)
static void	ensure_log_file (const std::string &log_dir, const std::string &log_file, const char *user_name="BastionGuard", mode_t file_mode=0640)
static bool	can_bind_privileged_ports ()
int	main (int argc, char *argv[])

Variables
static bool	running = true
static std::unordered_set< std::string >	g_trusted
static bool	g_trusted_loaded = false

Function Documentation

can_bind_privileged_ports()

bool can_bind_privileged_ports ( )

static

Definition at line 176 of file BastionGuard-daemon.cpp.

                                        {
    if (geteuid() == 0) return true;
    const auto caps = bg_process::run({"getcap", "/proc/self/exe"});
    const bool ok = caps.ok() && caps.output.find("cap_net_bind_service") != std::string::npos;
    return ok;
}

References can_bind_privileged_ports(), bg_process::Result::ok(), and bg_process::run().

Referenced by can_bind_privileged_ports(), and main().

clean_domain()

std::string clean_domain ( std::string d )

static

Definition at line 70 of file BastionGuard-daemon.cpp.

                                           {
    std::transform(d.begin(), d.end(), d.begin(), ::tolower);
    if (!d.empty() && d.front() == '.') d.erase(0, 1);
    if (d.rfind("www.", 0) == 0) d.erase(0, 4);
    auto p = d.find(':'); if (p != std::string::npos) d.erase(p);
    if (!d.empty() && d.back() == '.') d.pop_back();
    return d;
}

References clean_domain().

Referenced by clean_domain(), clean_domain(), clean_domain(), host_from_url(), is_payment_domain(), is_trusted_domain(), is_trusted_domain(), is_trusted_domain(), load_list_file(), load_list_file(), load_list_file(), and main().

ensure_log_file()

void ensure_log_file ( const std::string & log_dir, const std::string & log_file, const char * user_name = "BastionGuard", mode_t file_mode = 0640 )

static

Definition at line 131 of file BastionGuard-daemon.cpp.

                                                                                                                                              {
    try {
        if (!fs::exists(log_dir)) {
            fs::create_directories(log_dir);
            std::cout << _("[BastionGuard-daemon] 📁 Creata directory log: ") << log_dir << "\n";
        }
 
        if (!fs::exists(log_file)) {
            std::ofstream ofs(log_file, std::ios::trunc);
            ofs << _("[BastionGuard-daemon] Log creato automaticamente.\n");
            ofs.close();
            std::cout << _("[BastionGuard-daemon] 🧾 Creato file log: ") << log_file << "\n";
        }
 
        std::filesystem::permissions(
            log_file,
            std::filesystem::perms::owner_read | std::filesystem::perms::owner_write |
            std::filesystem::perms::group_read,
            std::filesystem::perm_options::replace
        );
 
        if (geteuid() == 0 && user_name != nullptr) {
            struct passwd *pw = getpwnam(user_name);
            if (pw) {
                gid_t gid = pw->pw_gid;
                uid_t uid = pw->pw_uid;
                struct group *gr = getgrnam(user_name);
                if (gr) gid = gr->gr_gid;
                if (chown(log_file.c_str(), uid, gid) == 0) {
                    std::cout << _("[BastionGuard-daemon] 🔐 Proprietario impostato su ")
                              << user_name << ":" << user_name << "\n";
                } else {
                    std::cerr << _("[BastionGuard-daemon] ⚠️ Impossibile cambiare owner del log (")
                              << strerror(errno) << ")\n";
                }
            } else {
                std::cerr << _("[BastionGuard-daemon] ⚠️ Utente '") << user_name
                          << _("' non trovato: skip chown\n");
            }
        }
    } catch (const std::exception& e) {
        std::cerr << _("[BastionGuard-daemon] ⚠️ Errore gestione log: ") << e.what() << "\n";
    }
}

References _, and ensure_log_file().

Referenced by ensure_log_file(), and main().

ensure_trusted_loaded()

void ensure_trusted_loaded ( )

static

Definition at line 105 of file BastionGuard-daemon.cpp.

                                    {
    if (g_trusted_loaded) return;
    std::vector<std::string> tmp;
    load_list_file("/usr/share/BastionGuard/data/bank/banks.json", tmp);
    if (const char* home = std::getenv("HOME"))
        load_list_file(std::string(home) + "/.config/BastionGuard/whitelist.json", tmp);
    for (auto& d : tmp) g_trusted.insert(d);
    g_trusted_loaded = true;
    std::cerr << _("[BastionGuard-daemon] ✅ Whitelist caricata: ") << g_trusted.size() << _(" domini trusted.\n");
}

References _, ensure_trusted_loaded(), g_trusted, g_trusted_loaded, and load_list_file().

Referenced by ensure_trusted_loaded(), ensure_trusted_loaded(), is_trusted_domain(), is_trusted_domain(), and main().

handle_signal()

void handle_signal ( int )

static

Definition at line 48 of file BastionGuard-daemon.cpp.

{ running = false; }

References handle_signal(), and running.

is_trusted_domain()

bool is_trusted_domain ( const std::string & host )

static

Definition at line 116 of file BastionGuard-daemon.cpp.

                                                     {
    ensure_trusted_loaded();
    std::string h = clean_domain(host);
    if (h.empty()) return false;
    if (g_trusted.count(h)) return true;
    auto pos = h.find('.');
    while (pos != std::string::npos) {
        std::string parent = h.substr(pos + 1);
        if (g_trusted.count(parent)) return true;
        pos = h.find('.', pos + 1);
    }
    return false;
}

References clean_domain(), ensure_trusted_loaded(), g_trusted, and is_trusted_domain().

Referenced by is_trusted_domain(), is_trusted_domain(), is_trusted_domain(), and main().

load_list_file()

void load_list_file ( const std::string & path, std::vector< std::string > & out )

static

Definition at line 79 of file BastionGuard-daemon.cpp.

                                                                             {
    if (!fs::exists(path)) return;
    try {
        std::ifstream f(path);
        if (!f.good()) return;
        nlohmann::json j;
        f >> j;
 
        auto push = [&](const std::string& s){
            auto d = clean_domain(s);
            if(!d.empty()) out.push_back(d);
        };
 
        if (j.is_array()) {
            for (auto& v : j) if (v.is_string()) push(v.get<std::string>());
        } else {
            if (j.contains("list") && j["list"].is_array())
                for (auto& v : j["list"]) if (v.is_string()) push(v.get<std::string>());
            if (j.contains("domains") && j["domains"].is_array())
                for (auto& v : j["domains"]) if (v.is_string()) push(v.get<std::string>());
            if (j.contains("whitelist") && j["whitelist"].is_array())
                for (auto& v : j["whitelist"]) if (v.is_string()) push(v.get<std::string>());
        }
    } catch (...) {}
}

References clean_domain(), and load_list_file().

Referenced by ensure_trusted_loaded(), ensure_trusted_loaded(), is_payment_domain(), is_trusted_domain(), load_list_file(), load_list_file(), and load_list_file().

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 183 of file BastionGuard-daemon.cpp.

                                 {
    std::signal(SIGINT, handle_signal);
    std::signal(SIGTERM, handle_signal);
 
    std::cout << _("[BastionGuard-daemon] 🚀 Avvio del servizio LocalWarningServer...") << std::endl;
 
    auto args = parse_args(argc, argv);
 
    auto parse_int_arg = [&](const std::string& key, int fallback) {
        if (!args.count(key)) return fallback;
        try {
            return std::stoi(args[key]);
        } catch (...) {
            std::cerr << "[BastionGuard-daemon] ⚠️ "
                      << "--" << key << " non è un intero valido, uso fallback "
                      << fallback << "\n";
            return fallback;
        }
    };
 
    int http_port = parse_int_arg("http-port", 81);
    int https_port = parse_int_arg("https-port", 444);
    std::string bind_address = args.count("bind-address") ? args["bind-address"] : "127.0.0.2";
    std::string page_warning = args.count("page-warning") ? args["page-warning"] : "/usr/share/BastionGuard/data/blocking/block.html";
 
    std::cout << "[BastionGuard-daemon] Configurazione:\n"
              << "  ├─ HTTP port:     " << http_port << "\n"
              << "  ├─ HTTPS port:    " << https_port << "\n"
              << "  ├─ Bind address:  " << bind_address << "\n"
              << "  ├─ Warning page:  " << page_warning << "\n";
 
    if (!can_bind_privileged_ports()) {
        std::cerr << _("[BastionGuard-daemon] ⚠️ Permessi insufficienti per aprire porte 81/444.\n")
                  <<  _( "    Esegui: sudo setcap 'cap_net_bind_service=+ep' /usr/bin/BastionGuard-daemon\n");
    }
 
    const std::string log_dir  = "/var/log/BastionGuard";
    const std::string log_file = log_dir + "/phishing_scanner";
    ensure_log_file(log_dir, log_file, "BastionGuard", 0640);
 
    try {
        ensure_trusted_loaded();
        auto warning_server = std::make_unique<LocalWarningServer>(
            http_port, https_port, bind_address, "", "", page_warning
        );
 
        warning_server->start();
        std::cout << _("[BastionGuard-daemon] ✅ Server attivo su ") << bind_address
                  << ":" << http_port << _(" e ") << https_port << "." << std::endl;
 
        while (running) {
    std::ifstream dnslog("/var/log/BastionGuard/dns_query.log");
    std::string line;
    while (std::getline(dnslog, line)) {
        std::string host = clean_domain(line);
        if (is_trusted_domain(host)) {
            std::cout << _("[BastionGuard-daemon] 🟢 Trusted domain rilevato: ") << host << _(" — bypass redirect.\n");
        } else {
            std::cout << _("[BastionGuard-daemon] 🔴 Sospetto: ") << host << _(" — instradato verso 127.0.0.2.\n");
        }
    }
    dnslog.close();
 
    std::this_thread::sleep_for(std::chrono::seconds(2));
}
 
 
        std::cout << _("[BastionGuard-daemon] 🛑 Arresto in corso...") << std::endl;
        warning_server->stop();
        std::cout << _("[BastionGuard-daemon] ✅ Terminato correttamente.") << std::endl;
    }
    catch (const std::exception& e) {
        std::cerr << _("[BastionGuard-daemon] ❌ Errore fatale: ") << e.what() << std::endl;
        return 1;
    }
    catch (...) {
        std::cerr << _("[BastionGuard-daemon] ❌ Errore sconosciuto.") << std::endl;
        return 1;
    }
 
    return 0;
}

References _, can_bind_privileged_ports(), clean_domain(), ensure_log_file(), ensure_trusted_loaded(), handle_signal(), is_trusted_domain(), main(), parse_args(), and running.

parse_args()

std::unordered_map< std::string, std::string > parse_args ( int argc, char * argv[] )

static

Definition at line 50 of file BastionGuard-daemon.cpp.

                                                                                 {
    std::unordered_map<std::string, std::string> opts;
    for (int i = 1; i < argc; ++i) {
        std::string arg = argv[i];
        if (arg.rfind("--", 0) == 0) {
            size_t eq = arg.find('=');
            if (eq != std::string::npos) {
                std::string key = arg.substr(2, eq - 2);
                std::string value = arg.substr(eq + 1);
                opts[key] = value;
            }
        }
    }
    return opts;
}

References parse_args().

Variable Documentation

g_trusted

std::unordered_set<std::string> g_trusted

static

Definition at line 67 of file BastionGuard-daemon.cpp.

Referenced by ensure_trusted_loaded(), ensure_trusted_loaded(), is_trusted_domain(), and is_trusted_domain().

g_trusted_loaded

bool g_trusted_loaded = false

static

Definition at line 68 of file BastionGuard-daemon.cpp.

Referenced by ensure_trusted_loaded(), and ensure_trusted_loaded().

running

bool running = true

static

Definition at line 47 of file BastionGuard-daemon.cpp.