WireguardBackend.hpp

Go to the documentation of this file.

/*
 * BastionGuard™
 * Copyright (C) 2025–2026 Calogero Scarnà
 *
 * GPL v3. BastionGuard™ is a trademark of Calogero Scarnà.
 */
 
#pragma once
 
#include <string>
#include <vector>
#include <optional>
#include <cstdint>
 
namespace BastionGuard {
 
// Coppia di chiavi WireGuard del client.
struct WgKeyPair {
    std::string private_key;
    std::string public_key;
};
 
// Parametri di un peer (lato server) come letti dal .conf.
struct WgPeer {
    std::string public_key;
    std::string preshared_key;          // opzionale
    std::string endpoint;               // host:port
    std::string allowed_ips;            // "0.0.0.0/0, ::/0" tipico
    std::string persistent_keepalive;   // numero in secondi (stringa)
};
 
// Specifica completa di un tunnel, ottenuta dal parser di un .conf.
// È l'unica "fonte di verità": niente file in /etc/wireguard/.
struct WgTunnelSpec {
    // [Interface]
    std::string private_key;
    std::vector<std::string> addresses; // es. {"10.104.3.74/32"}
    std::vector<std::string> dns;       // es. {"1.1.1.1","8.8.8.8"}
    std::string listen_port;            // opzionale, lato client di solito vuoto
    int mtu = 0;                        // 0 = default
 
    // [Peer] (uno o più)
    std::vector<WgPeer> peers;
 
    bool valid() const {
        return !private_key.empty() && !addresses.empty() && !peers.empty()
               && !peers[0].public_key.empty() && !peers[0].endpoint.empty();
    }
};
 
// Stato sintetico dell'interfaccia WireGuard.
struct WgStatus {
    bool        up = false;
    std::string interface;
    std::string endpoint;
    std::string last_handshake;
    std::uint64_t rx_bytes = 0;
    std::uint64_t tx_bytes = 0;
};
 
// Parametri opzionali per costruire una WgTunnelSpec dalla UI "Configurazione".
struct WgConfigParams {
    std::string private_key;
    std::string address;
    std::string dns;
    std::string listen_port;
    std::string server_public_key;
    std::string endpoint;
    std::string allowed_ips = "0.0.0.0/0, ::/0";
    std::string persistent_keepalive = "25";
};
 
// Risultato di un'operazione (per la UI).
struct OpResult {
    bool        ok = false;
    int         exit_code = 0;
    std::string output;
};
 
/*
 * WireguardBackend
 * ----------------
 * Gestione "diretta" del tunnel WireGuard via `ip` + `wg`, SENZA passare per
 * wg-quick. Vantaggi:
 *   - nessuna dipendenza da resolvconf / systemd-resolved
 *   - nessun script esterno da generare/installare
 *   - nessun PostUp/PostDown con quoting fragile
 *   - DNS gestito direttamente in C++ con backup/ripristino di /etc/resolv.conf
 *
 * Stato:
 *   - lo "spec" del tunnel viene caricato in memoria (load_from_conf/from_params)
 *   - connect() applica lo spec all'interfaccia wg0
 *   - disconnect() butta giù tutto e ripristina /etc/resolv.conf
 */
class WireguardBackend {
public:
    explicit WireguardBackend(std::string iface = "wg0");
 
    // Verifica la presenza dei binari richiesti (wg, ip).
    bool tooling_available(std::string* missing = nullptr) const;
 
    // --- Configurazione ------------------------------------------------
    // Carica uno spec da un file .conf WireGuard standard (parser robusto:
    // gestisce spazi attorno all'=, righe vuote, commenti #/;).
    bool load_from_conf(const std::string& conf_path, std::string* err = nullptr);
 
    // Carica uno spec dai campi del form "Configurazione" dell'app.
    bool load_from_params(const WgConfigParams& p, std::string* err = nullptr);
 
    // True se uno spec è caricato.
    bool has_spec() const { return spec_.valid(); }
 
    // Endpoint del primo peer come da configurazione caricata (host:port),
    // utile per la UI quando `wg show` non è leggibile senza privilegi.
    std::string configured_endpoint() const {
        return spec_.peers.empty() ? std::string{} : spec_.peers[0].endpoint;
    }
 
    // --- Chiavi ---------------------------------------------------------
    std::optional<WgKeyPair> generate_keys() const;
 
    // --- Connect / Disconnect ------------------------------------------
    // Porta su il tunnel usando lo spec caricato.
    OpResult connect();
    // Butta giù il tunnel e ripristina /etc/resolv.conf.
    OpResult disconnect();
 
    // --- Stato ----------------------------------------------------------
    WgStatus status() const;
    std::optional<std::string> public_ip() const;
 
    // --- Kill-switch ---------------------------------------------------
    OpResult killswitch_enable();
    OpResult killswitch_disable();
    bool     killswitch_active() const;
 
    const std::string& interface_name() const { return iface_; }
 
private:
    std::string  iface_;
    WgTunnelSpec spec_;
 
    // Esegue argv catturando output. Se `privileged` antepone pkexec.
    OpResult run(const std::vector<std::string>& argv, bool privileged) const;
 
    // Come run(), ma scrive `stdin_data` sullo standard input del processo.
    OpResult run_with_stdin(const std::vector<std::string>& argv,
                            const std::string& stdin_data,
                            bool privileged) const;
 
    // Costruisce il testo "wg setconf"-compatibile dallo spec (solo PrivateKey
    // e Peer; niente Address/DNS che `wg` non capisce).
    std::string build_wg_setconf_text() const;
};
 
} // namespace BastionGuard