RulesPage.cpp

Go to the documentation of this file.

/*
 * BastionGuard™ Secure Connection
 * Copyright (C) 2025–2026 Calogero Scarnà
 * GPL-3.0 — BastionGuard™ is a trademark of Calogero Scarnà.
 */
 
#include "RulesPage.hpp"
 
#include <glibmm/i18n.h>
#include <glibmm/main.h>
#include <gtkmm/cellrenderercombo.h>
#include <gtkmm/cellrenderertoggle.h>
#include <gtkmm/dialog.h>
#include <gtkmm/entry.h>
#include <gtkmm/checkbutton.h>
#include <gtkmm/comboboxtext.h>
#include <gtkmm/grid.h>
 
#include <cstdlib>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <regex>
#include <sstream>
#include <memory>
#include <unistd.h>
 
static const char* RULES_DIR = "/etc/bastionguard-secure-connectiond/rules/";
 
RulesPage::RulesPage()
    : Gtk::Box(Gtk::Orientation::VERTICAL, 0)
{
    buildComboModels();
    buildToolbar();
    buildTreeView();
 
    m_scroll.set_child(m_treeView);
    m_scroll.set_vexpand(true);
 
    append(m_toolbar);
    append(m_scroll);
 
    loadRules();
}
 
// ---------------------------------------------------------------------------
// Modelli per i combo Azione / Durata
// ---------------------------------------------------------------------------
 
void RulesPage::buildComboModels()
{
    // ── Azione: allow | deny ────────────────────────────────────────────
    m_actionModel = Gtk::ListStore::create(m_comboColumns);
    for (const char* v : { "allow", "deny" }) {
        auto row = *m_actionModel->append();
        row[m_comboColumns.col_value] = v;
    }
 
    // ── Durata: once | always ───────────────────────────────────────────
    m_durationModel = Gtk::ListStore::create(m_comboColumns);
    for (const char* v : { "once", "always" }) {
        auto row = *m_durationModel->append();
        row[m_comboColumns.col_value] = v;
    }
}
 
// ---------------------------------------------------------------------------
// Toolbar
// ---------------------------------------------------------------------------
 
void RulesPage::buildToolbar()
{
    m_toolbar.set_margin_top(8);
    m_toolbar.set_margin_bottom(8);
    m_toolbar.set_margin_start(8);
    m_toolbar.set_margin_end(8);
 
    m_createBtn.set_label(_("➕ Crea regola"));
    m_createBtn.get_style_context()->add_class("suggested-action");
    m_createBtn.signal_clicked().connect(
        sigc::mem_fun(*this, &RulesPage::onCreateRule));
    m_toolbar.append(m_createBtn);
 
    m_reloadBtn.set_label(_("🔄 Ricarica"));
    m_reloadBtn.signal_clicked().connect(
        sigc::mem_fun(*this, &RulesPage::loadRules));
    m_toolbar.append(m_reloadBtn);
 
    m_deleteBtn.set_label(_("🗑 Elimina"));
    m_deleteBtn.get_style_context()->add_class("destructive-action");
    m_deleteBtn.signal_clicked().connect(
        sigc::mem_fun(*this, &RulesPage::onDelete));
    m_toolbar.append(m_deleteBtn);
 
    auto spacer = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    spacer->set_hexpand(true);
    m_toolbar.append(*spacer);
 
    m_countLabel.set_markup("<small>0 regole</small>");
    m_countLabel.set_halign(Gtk::Align::END);
    m_toolbar.append(m_countLabel);
}
 
// ---------------------------------------------------------------------------
// TreeView
// ---------------------------------------------------------------------------
 
void RulesPage::buildTreeView()
{
    m_store = Gtk::ListStore::create(m_columns);
    m_treeView.set_model(m_store);
    m_treeView.get_style_context()->add_class("bsc-treeview");
    m_treeView.set_grid_lines(Gtk::TreeView::GridLines::HORIZONTAL);
 
    // ── Colonna: Nome (read-only) ───────────────────────────────────────
    m_treeView.append_column(_("Nome"), m_columns.col_name);
 
    // ── Colonna: Azione — CellRendererCombo (allow | deny) ─────────────
    {
        auto* col  = Gtk::make_managed<Gtk::TreeViewColumn>(_("Azione"));
        auto* cell = Gtk::make_managed<Gtk::CellRendererCombo>();
 
        cell->property_model()       = m_actionModel;
        cell->property_text_column() = 0;      // colonna "col_value" nel modello combo
        cell->property_editable()    = true;
        cell->property_has_entry()   = false;  // solo valori dalla lista
 
        cell->signal_edited().connect(
            sigc::mem_fun(*this, &RulesPage::onActionEdited));
 
        col->pack_start(*cell, true);
        col->add_attribute(cell->property_text(), m_columns.col_action);
        m_treeView.append_column(*col);
    }
 
    // ── Colonna: Durata — CellRendererCombo (once | always) ────────────
    {
        auto* col  = Gtk::make_managed<Gtk::TreeViewColumn>(_("Durata"));
        auto* cell = Gtk::make_managed<Gtk::CellRendererCombo>();
 
        cell->property_model()       = m_durationModel;
        cell->property_text_column() = 0;
        cell->property_editable()    = true;
        cell->property_has_entry()   = false;
 
        cell->signal_edited().connect(
            sigc::mem_fun(*this, &RulesPage::onDurationEdited));
 
        col->pack_start(*cell, true);
        col->add_attribute(cell->property_text(), m_columns.col_duration);
        m_treeView.append_column(*col);
    }
 
    // ── Colonna: Operando (read-only) ───────────────────────────────────
    m_treeView.append_column(_("Operando"), m_columns.col_operand);
 
    // ── Colonna: Valore (testo libero editable) ─────────────────────────
    {
        auto* col  = Gtk::make_managed<Gtk::TreeViewColumn>(_("Valore"));
        auto* cell = Gtk::make_managed<Gtk::CellRendererText>();
        cell->property_editable() = true;
        cell->signal_edited().connect(
            sigc::mem_fun(*this, &RulesPage::onDataEdited));
        col->pack_start(*cell, true);
        col->add_attribute(cell->property_text(), m_columns.col_data);
        m_treeView.append_column(*col);
    }
 
    // ── Colonna: Attiva (toggle) ────────────────────────────────────────
    {
        auto* col  = Gtk::make_managed<Gtk::TreeViewColumn>(_("Attiva"));
        auto* cell = Gtk::make_managed<Gtk::CellRendererToggle>();
        cell->property_activatable() = true;
        cell->signal_toggled().connect(
            sigc::mem_fun(*this, &RulesPage::onEnabledToggled));
        col->pack_start(*cell, false);
        col->add_attribute(cell->property_active(), m_columns.col_enabled);
        m_treeView.append_column(*col);
    }
 
    // ── Larghezze minime e ridimensionamento ────────────────────────────
    const int minWidths[] = { 220, 90, 100, 130, 240, 80 };
    for (int i = 0; i < 6; ++i) {
        if (auto* c = m_treeView.get_column(i)) {
            c->set_min_width(minWidths[i]);
            c->set_resizable(true);
        }
    }
}
 
// ---------------------------------------------------------------------------
// Carica regole da filesystem
// ---------------------------------------------------------------------------
 
void RulesPage::loadRules()
{
    m_store->clear();
 
    if (!std::filesystem::exists(RULES_DIR)) {
        std::cerr << "[RulesPage] Dir non trovata: " << RULES_DIR << "\n";
        updateCount();
        return;
    }
 
    for (const auto& entry : std::filesystem::directory_iterator(RULES_DIR)) {
        if (!entry.is_regular_file() || entry.path().extension() != ".json")
            continue;
 
        auto rule = parseRule(entry.path().string());
        if (rule.name.empty())
            continue;
 
        auto row = *m_store->append();
        row[m_columns.col_name]     = rule.name;
        row[m_columns.col_action]   = rule.action;
        row[m_columns.col_duration] = rule.duration;
        row[m_columns.col_operand]  = rule.operand;
        row[m_columns.col_data]     = rule.data;
        row[m_columns.col_enabled]  = rule.enabled;
        row[m_columns.col_filepath] = rule.filepath;
    }
 
    updateCount();
}
 
// ---------------------------------------------------------------------------
// Parser JSON minimale
// ---------------------------------------------------------------------------
 
RulesPage::Rule RulesPage::parseRule(const std::string& filepath)
{
    Rule r;
    r.filepath = filepath;
 
    std::ifstream f(filepath);
    if (!f.is_open())
        return r;
 
    std::ostringstream ss;
    ss << f.rdbuf();
    const std::string json = ss.str();
 
    r.name     = jsonField(json, "name");
    r.action   = jsonField(json, "action");
    r.duration = jsonField(json, "duration");
    r.operand  = jsonField(json, "operand");
    r.data     = jsonField(json, "data");
 
    const std::string enabled = jsonField(json, "enabled");
    r.enabled = (enabled != "false");
 
    return r;
}
 
std::string RulesPage::jsonField(const std::string& json, const std::string& key)
{
    std::smatch m;
 
    {
        std::regex re("\"" + key + "\"\\s*:\\s*\"([^\"]+)\"");
        if (std::regex_search(json, m, re))
            return m[1].str();
    }
    {
        std::regex re_bool("\"" + key + "\"\\s*:\\s*(true|false)");
        if (std::regex_search(json, m, re_bool))
            return m[1].str();
    }
    {
        std::regex re_num("\"" + key + "\"\\s*:\\s*([0-9]+)");
        if (std::regex_search(json, m, re_num))
            return m[1].str();
    }
 
    return "";
}
 
// ---------------------------------------------------------------------------
// Scrittura JSON (via pkexec per i file in /etc)
// ---------------------------------------------------------------------------
 
bool RulesPage::replaceJsonStringField(const std::string& filepath,
                                       const std::string& key,
                                       const std::string& value)
{
    std::ifstream in(filepath);
    if (!in.is_open())
        return false;
 
    std::ostringstream ss;
    ss << in.rdbuf();
    std::string json = ss.str();
    in.close();
 
    const std::string escaped = escapeJson(value);
    const std::regex  re("\"" + key + "\"\\s*:\\s*\"([^\"]*)\"");
    const std::string replacement = "\"" + key + "\": \"" + escaped + "\"";
 
    if (!std::regex_search(json, re))
        return false;
 
    json = std::regex_replace(json, re, replacement,
                              std::regex_constants::format_first_only);
 
    return writeFileAsRoot(filepath, json);
}
 
bool RulesPage::replaceJsonBoolField(const std::string& filepath,
                                     const std::string& key,
                                     bool value)
{
    std::ifstream in(filepath);
    if (!in.is_open())
        return false;
 
    std::ostringstream ss;
    ss << in.rdbuf();
    std::string json = ss.str();
    in.close();
 
    const std::regex  re("\"" + key + "\"\\s*:\\s*(true|false)");
    const std::string replacement = "\"" + key + "\": " +
                                    std::string(value ? "true" : "false");
 
    if (!std::regex_search(json, re))
        return false;
 
    json = std::regex_replace(json, re, replacement,
                              std::regex_constants::format_first_only);
 
    return writeFileAsRoot(filepath, json);
}
 
bool RulesPage::writeFileAsRoot(const std::string& filepath,
                                const std::string& content)
{
    const std::string tmpfile = "/tmp/bsc-rule-edit-" +
                                std::to_string(::getpid()) + ".json";
    {
        std::ofstream out(tmpfile, std::ios::trunc);
        if (!out.is_open())
            return false;
        out << content;
    }
 
    const std::string cmd =
        "pkexec sh -c 'install -m 0644 \"" + tmpfile + "\" \"" + filepath + "\"'";
 
    const int ret = std::system(cmd.c_str());
    std::filesystem::remove(tmpfile);
    return ret == 0;
}
 
bool RulesPage::createRuleFileAsRoot(const Rule& rule)
{
    std::error_code ec;
    std::filesystem::create_directories(RULES_DIR, ec);
 
    std::string filename = makeSafeFilename(rule.name);
    if (filename.empty())
        filename = "rule";
 
    std::string filepath = std::string(RULES_DIR) + filename + ".json";
    int suffix = 1;
    while (std::filesystem::exists(filepath)) {
        filepath = std::string(RULES_DIR) + filename + "-" + std::to_string(suffix++) + ".json";
    }
 
    const std::string json =
        "{\n"
        "  \"name\": \"" + escapeJson(rule.name) + "\",\n"
        "  \"action\": \"" + escapeJson(rule.action) + "\",\n"
        "  \"duration\": \"" + escapeJson(rule.duration) + "\",\n"
        "  \"operand\": \"" + escapeJson(rule.operand) + "\",\n"
        "  \"data\": \"" + escapeJson(rule.data) + "\",\n"
        "  \"enabled\": " + std::string(rule.enabled ? "true" : "false") + "\n"
        "}\n";
 
    return writeFileAsRoot(filepath, json);
}
 
std::string RulesPage::makeSafeFilename(const std::string& input)
{
    std::string out;
    out.reserve(input.size());
    for (unsigned char c : input) {
        if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
            (c >= '0' && c <= '9')) {
            out += static_cast<char>(c);
        } else if (c == '-' || c == '_') {
            out += static_cast<char>(c);
        } else if (!out.empty() && out.back() != '-') {
            out += '-';
        }
    }
 
    while (!out.empty() && out.back() == '-')
        out.pop_back();
 
    return out;
}
 
std::string RulesPage::escapeJson(const std::string& input)
{
    std::string out;
    out.reserve(input.size());
    for (char c : input) {
        switch (c) {
            case '\\': out += "\\\\"; break;
            case '"':  out += "\\\""; break;
            case '\n': out += "\\n";  break;
            case '\r': out += "\\r";  break;
            case '\t': out += "\\t";  break;
            default:   out += c;      break;
        }
    }
    return out;
}
 
// ---------------------------------------------------------------------------
// Editing — i valori arrivano già validati dal combo (solo allow/deny, once/always)
// ---------------------------------------------------------------------------
 
void RulesPage::onActionEdited(const Glib::ustring& path,
                               const Glib::ustring& new_text)
{
    auto it = m_store->get_iter(path);
    if (!it) return;
 
    // Sicurezza extra: il combo non dovrebbe permettere altri valori
    const std::string value = Glib::ustring(new_text).lowercase();
    if (value != "allow" && value != "deny") return;
 
    const Glib::ustring filepath = (*it)[m_columns.col_filepath];
    if (replaceJsonStringField(filepath, "action", value))
        (*it)[m_columns.col_action] = value;
}
 
void RulesPage::onDurationEdited(const Glib::ustring& path,
                                  const Glib::ustring& new_text)
{
    auto it = m_store->get_iter(path);
    if (!it) return;
 
    const std::string value = Glib::ustring(new_text).lowercase();
    if (value != "once" && value != "always") return;
 
    const Glib::ustring filepath = (*it)[m_columns.col_filepath];
    if (replaceJsonStringField(filepath, "duration", value))
        (*it)[m_columns.col_duration] = value;
}
 
void RulesPage::onDataEdited(const Glib::ustring& path,
                              const Glib::ustring& new_text)
{
    auto it = m_store->get_iter(path);
    if (!it) return;
 
    const Glib::ustring filepath = (*it)[m_columns.col_filepath];
    if (replaceJsonStringField(filepath, "data", new_text))
        (*it)[m_columns.col_data] = new_text;
}
 
void RulesPage::onEnabledToggled(const Glib::ustring& path)
{
    auto it = m_store->get_iter(path);
    if (!it) return;
 
    const bool current = (*it)[m_columns.col_enabled];
    const bool next    = !current;
    const Glib::ustring filepath = (*it)[m_columns.col_filepath];
 
    if (replaceJsonBoolField(filepath, "enabled", next))
        (*it)[m_columns.col_enabled] = next;
}
 
// ---------------------------------------------------------------------------
// Crea regola
// ---------------------------------------------------------------------------
 
void RulesPage::onCreateRule()
{
    Gtk::Dialog dialog;
    dialog.set_title("");
    dialog.set_modal(true);
    dialog.set_resizable(false);
    dialog.set_default_size(540, -1);
    dialog.get_style_context()->add_class("bsc-rule-dialog");
 
    if (auto* root = dynamic_cast<Gtk::Window*>(get_root()))
        dialog.set_transient_for(*root);
 
    auto* header = Gtk::make_managed<Gtk::HeaderBar>();
    header->set_show_title_buttons(false);
    header->set_decoration_layout("");
    header->get_style_context()->add_class("custom-headerbar");
 
    auto* titleLabel = Gtk::make_managed<Gtk::Label>();
    titleLabel->set_markup("<b>" + Glib::ustring(_("Nuova regola")) + "</b>");
    titleLabel->get_style_context()->add_class("headerbar-title");
    header->set_title_widget(*titleLabel);
 
    auto* headerRight = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 4);
    headerRight->get_style_context()->add_class("header-right");
 
    auto* closeBtn = Gtk::make_managed<Gtk::Button>("✕");
    closeBtn->get_style_context()->add_class("header-button");
    closeBtn->signal_clicked().connect([&dialog]() {
        dialog.response(Gtk::ResponseType::CANCEL);
    });
    headerRight->append(*closeBtn);
 
    header->pack_end(*headerRight);
    dialog.set_titlebar(*header);
 
    dialog.add_button(_("Annulla"), Gtk::ResponseType::CANCEL);
    dialog.add_button(_("Crea"), Gtk::ResponseType::OK);
 
    if (auto* cancelBtn = dialog.get_widget_for_response(Gtk::ResponseType::CANCEL))
        cancelBtn->get_style_context()->add_class("dialog-secondary");
    if (auto* createBtn = dialog.get_widget_for_response(Gtk::ResponseType::OK))
        createBtn->get_style_context()->add_class("suggested-action");
 
    auto* area = dialog.get_content_area();
    area->set_margin_top(16);
    area->set_margin_bottom(16);
    area->set_margin_start(16);
    area->set_margin_end(16);
    area->set_spacing(12);
    area->get_style_context()->add_class("bsc-rule-dialog-body");
 
    auto* intro = Gtk::make_managed<Gtk::Label>(_("Compila i campi per creare una nuova regola persistente."));
    intro->set_wrap(true);
    intro->set_halign(Gtk::Align::START);
    intro->get_style_context()->add_class("dialog-intro");
    area->append(*intro);
 
    auto* card = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 0);
    card->get_style_context()->add_class("card");
    card->get_style_context()->add_class("rule-dialog-card");
    area->append(*card);
 
    auto* grid = Gtk::make_managed<Gtk::Grid>();
    grid->set_row_spacing(10);
    grid->set_column_spacing(12);
    grid->set_margin_top(14);
    grid->set_margin_bottom(14);
    grid->set_margin_start(14);
    grid->set_margin_end(14);
    grid->set_column_homogeneous(false);
    card->append(*grid);
 
    auto attach_row = [grid](int row, const Glib::ustring& label, Gtk::Widget& widget) {
        auto* lbl = Gtk::make_managed<Gtk::Label>(label);
        lbl->set_halign(Gtk::Align::START);
        lbl->set_valign(Gtk::Align::CENTER);
        lbl->get_style_context()->add_class("dialog-label");
        grid->attach(*lbl, 0, row, 1, 1);
 
        widget.set_hexpand(true);
        widget.set_halign(Gtk::Align::FILL);
        widget.get_style_context()->add_class("dialog-field");
        grid->attach(widget, 1, row, 1, 1);
    };
 
    auto* nameEntry = Gtk::make_managed<Gtk::Entry>();
    nameEntry->set_text(_("Nuova regola"));
    attach_row(0, _("Nome"), *nameEntry);
 
    auto* actionCombo = Gtk::make_managed<Gtk::ComboBoxText>();
    actionCombo->append("allow", "allow");
    actionCombo->append("deny", "deny");
    actionCombo->set_active_id("deny");
    attach_row(1, _("Azione"), *actionCombo);
 
    auto* durationCombo = Gtk::make_managed<Gtk::ComboBoxText>();
    durationCombo->append("once", "once");
    durationCombo->append("always", "always");
    durationCombo->set_active_id("always");
    attach_row(2, _("Durata"), *durationCombo);
 
    auto* operandCombo = Gtk::make_managed<Gtk::ComboBoxText>();
    operandCombo->append("host", "host");
    operandCombo->append("ip", "ip");
    operandCombo->append("app", "app");
    operandCombo->append("port", "port");
    operandCombo->set_active_id("host");
    attach_row(3, _("Operando"), *operandCombo);
 
    auto* valueEntry = Gtk::make_managed<Gtk::Entry>();
    valueEntry->set_text("example.com");
    attach_row(4, _("Valore"), *valueEntry);
 
    auto* enabledCheck = Gtk::make_managed<Gtk::CheckButton>(_("Regola attiva"));
    enabledCheck->set_active(true);
    enabledCheck->set_halign(Gtk::Align::START);
    enabledCheck->get_style_context()->add_class("dialog-check");
    grid->attach(*enabledCheck, 1, 5, 1, 1);
 
    std::shared_ptr<Glib::MainLoop> loop = Glib::MainLoop::create(false);
    int response = Gtk::ResponseType::CANCEL;
 
    dialog.signal_response().connect([&](int id) {
        response = id;
        dialog.hide();
        if (loop->is_running())
            loop->quit();
    });
 
    dialog.present();
    loop->run();
 
    if (response != Gtk::ResponseType::OK)
        return;
 
    Rule rule;
    rule.name = nameEntry->get_text();
    rule.action = actionCombo->get_active_id();
    rule.duration = durationCombo->get_active_id();
    rule.operand = operandCombo->get_active_id();
    rule.data = valueEntry->get_text();
    rule.enabled = enabledCheck->get_active();
 
    if (rule.name.empty() || rule.action.empty() || rule.duration.empty() ||
        rule.operand.empty() || rule.data.empty()) {
        std::cerr << "[RulesPage] Creazione regola annullata: campi mancanti\n";
        return;
    }
 
    if (createRuleFileAsRoot(rule))
        loadRules();
    else
        std::cerr << "[RulesPage] Impossibile creare la regola\n";
}
 
// ---------------------------------------------------------------------------
// Elimina regola
// ---------------------------------------------------------------------------
 
void RulesPage::onDelete()
{
    auto sel = m_treeView.get_selection();
    auto it  = sel->get_selected();
    if (!it) return;
 
    const Glib::ustring path = (*it)[m_columns.col_filepath];
    if (path.empty()) return;
 
    const std::string cmd = "pkexec rm -f \"" + std::string(path) + "\"";
    if (std::system(cmd.c_str()) == 0) {
        m_store->erase(it);
        updateCount();
    } else {
        std::cerr << "[RulesPage] Impossibile eliminare: " << path << "\n";
    }
}
 
void RulesPage::updateCount()
{
    const int n = static_cast<int>(m_store->children().size());
    m_countLabel.set_markup(
        "<small>" + std::to_string(n) +
        (n == 1 ? " regola" : " regole") + "</small>");
}