Backend.hpp

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.
 */
 
#pragma once
#include <string>
#include <vector>
#include <memory>
#include <filesystem>
#include <functional>
#include <map>
#include <atomic>
#include <libsmbclient.h>
#include <sigc++/signal.h>
#include "firewall/FirewallEnums.hpp"
#include "AntiRansomEngine.hpp"
#include "phishing/WebProbe.hpp"
#include "Utils.hpp"
 
class Backend {
public:
    static Backend& instance();
    ~Backend();
    static std::string getAppVersion();
    static int getAppBuild();
    static bool enableClamonacc();
    static bool disableClamonacc();
    static bool isClamonaccActive();
    static std::string getClamonaccStatus();
 
    static void setQuarantinePath(const std::string& path);
    static std::string getQuarantinePath();
    void setupAlertListener();
    void moveToQuarantine(const std::string&);
    static std::vector<std::string> getClamonaccLogs();
    static std::string getLastUpdateDate();
    static std::string getDbVersion();
 
    static std::vector<std::string> getOnAccessPaths();
    static std::vector<std::string> getOnAccessEvents();
 
    void sendRansomwareAlert(const std::string& path, const std::string& family);
    static bool installClamdIfMissing();
    bool isSambaScanRunning();
 
    void start_antiransom();
    void stop_antiransom();
    sigc::signal<void(const std::string&)>& signal_antiransom_event();
    bool updateYaraRules(std::function<void(int, int, const std::string&)> progressCallback = nullptr);
    static bool isAntiransomActive();
 
    bool reload_dnsmasq();
    bool updatePhishLists();
    bool isPhishAutoUpdateEnabled();
    bool enablePhishAutoUpdate(bool enable);
 
    std::vector<std::string> getWhitelist() const;
    void addToWhitelist(const std::string& domain);
    void removeFromWhitelist(const std::string& domain);
    void saveWhitelist() const;
    void loadWhitelist();
    void mergeWhitelistSources();
    bool isBankDomain(const std::string& host) const;
    std::function<void(const std::string&)> onBankListReload;
    bool updateBankListFromURL(const std::string& source_url);
 
    std::string checkUrl(const std::string& url);
 
    bool isGoogleSafeEnabled() const { return googleSafeEnabled_; }
    void setGoogleSafeEnabled(bool enabled) { googleSafeEnabled_ = enabled; }
    void setGoogleSafeApiKey(const std::string& key) { googleSafeApiKey_ = key; }
    std::string getGoogleSafeApiKey() const { return googleSafeApiKey_; }
    void saveGoogleSafeConfig();
    bool testGoogleSafeKey();
 
    void start_antiphish();
    void stop_antiphish();
    bool isAntiphishActive();
    sigc::signal<void(const std::string&)>& signal_antiphish_event();
    bool updateSanesecurityDB(std::function<void(int,int,const std::string&)> progressCallback = nullptr);
    void scanSambaDir(const std::string& dir);
    void ensureQuarantinePath();
    void setPhishingPort(int port);
    int getPhishingPort() const;
 
    std::string getSambaConfigPath() const;
    std::vector<std::string> getSambaDirs();
    void saveSambaConfig(bool enabled, const std::vector<std::string>& dirs);
    bool addSambaDir(const std::string& dir);
    bool removeSambaDir(const std::string& dir);
    bool isSambaEnabled();
    void setSambaEnabled(bool enabled);
    void scanAllSambaDirs();
    void resetSambaStop();
    void requestStopSambaScan();
 
    std::atomic<bool> samba_stop_requested { false };
 
    static void smb_auth_fn(SMBCCTX* context,
                            const char* srv, const char* shr,
                            char* wg, int wglen,
                            char* un, int unlen,
                            char* pw, int pwlen);
 
    static bool isValidSMB(const std::string& url);
 
    std::map<std::string, std::pair<std::string,std::string>> smb_credentials;
 
    void saveSMBCredentials(const std::string& url,
                            const std::string& user,
                            const std::string& pass);
 
    std::pair<std::string,std::string> getCreds(const std::string& url);
 
    SMBCCTX* createThreadSmbContext();
 
    // Raccolta ricorsiva file SMB
    void smb_collect_files(SMBCCTX* ctx,
                       const std::string& url,
                       std::vector<std::string>& out);
 
 
    void smb_collect_files_impl(SMBCCTX* ctx,
                                const std::string& url,
                                std::vector<std::string>& out);
 
    bool smb_read_file_with_ctx(SMBCCTX* ctx,
                                const std::string& smbPath,
                                std::function<bool(const char*, size_t)>);
 
    bool smb_copy_file(const std::string& smbPath,
                       const std::filesystem::path& dest);
 
    std::function<void(const std::string&, float)> samba_progress_callback = nullptr;
 
 
    struct ScanStatus
    {
        bool scan_active = false;
        float progress = 0.0f;
        std::string current_scanning;
        std::string temp_dir;
        std::vector<std::string> files;
        size_t infected = 0;
    };
 
    ScanStatus get_current_scan_files();
 
    struct SambaScanState {
        bool scan_active = false;
        std::string current_file;
        std::vector<std::string> log;
        size_t infected = 0;
    };
 
    SambaScanState samba_scan_state;
 
    SambaScanState get_current_scan_files() const { return samba_scan_state; }
 
    static std::string resolveSambaDir(const std::string& path);
 
 
 
    void applyFirewallFromBlacklist(
        const std::vector<std::string>& blacklistLines
    );
    void setFirewallType(FirewallType fw);
    FirewallType getFirewallType() const;
 
    void setFirewallEnabled(bool enabled);
    bool isFirewallEnabled() const;
 
    void loadFirewallConfig();
    void saveFirewallConfig() const;
    void applyFirewallFromPhishingBlacklist();
    void scheduleFirewallApply(const std::string& inputPath);
private:
    Backend();
    Backend(const Backend&) = delete;
    Backend& operator=(const Backend&) = delete;
 
    AntiRansomEngine antiransom_;
    sigc::signal<void(const std::string&)> antiransom_signal_;
    std::function<void(int, int, const std::string&)> progressCallback_;
    std::mutex smb_mutex;
    std::unique_ptr<WebProbe> webprobe_;
    std::vector<std::string> whitelist_;
 
    bool        googleSafeEnabled_ = false;
    std::string googleSafeApiKey_;
    bool firewallEnabled_ = false;
    FirewallType firewallType_ = FirewallType::NONE;
    SMBCCTX* smb_context = nullptr;
    void initSambaClient();
    std::string getSambaCredsPath() const;
    void loadSMBCredentials();
    std::string samba_last_temp_dir;
    float samba_last_progress = 0.0f;
};