Blog

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
<html>
<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Documentation : Proxy Sécurisé C++ sur Virt-Manager</title>
    <style>
        :root {
            --primary-color: #2c3e50;
            --accent-color: #3498db;
            --bg-color: #f4f6f7;
            --code-bg: #282c34;
            --text-color: #333;
            --border-color: #ddd;
        }
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            line-height: 1.6;
            color: var(--text-color);
            background-color: var(--bg-color);
            margin: 0;
            padding: 20px;
        }
        .container {
            max-width: 1000px;
            margin: 0 auto;
            background: white;
            padding: 40px;
            border-radius: 8px;
            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
        }
        h1, h2, h3 {
            color: var(--primary-color);
            border-bottom: 2px solid var(--accent-color);
            padding-bottom: 10px;
            margin-top: 30px;
        }
        h1 { text-align: center; font-size: 2.5em; margin-bottom: 40px; }
        h2 { font-size: 1.8em; margin-top: 40px; }
        h3 { font-size: 1.4em; margin-top: 25px; }
        
        .alert {
            background-color: #fff3cd;
            border-left: 5px solid #ffc107;
            padding: 15px;
            margin: 20px 0;
            border-radius: 4px;
        }
        .alert-danger {
            background-color: #f8d7da;
            border-left: 5px solid #dc3545;
        }
        .alert-success {
            background-color: #d4edda;
            border-left: 5px solid #28a745;
        }

        pre {
            background-color: var(--code-bg);
            color: #abb2bf;
            padding: 15px;
            border-radius: 5px;
            overflow-x: auto;
            font-family: 'Consolas', 'Monaco', monospace;
            font-size: 0.95em;
            border: 1px solid #444;
        }
        code {
            font-family: 'Consolas', 'Monaco', monospace;
            background-color: #eee;
            padding: 2px 5px;
            border-radius: 3px;
            color: #c7254e;
        }
        pre code {
            background-color: transparent;
            color: inherit;
            padding: 0;
        }
        table {
            width: 100%;
            border-collapse: collapse;
            margin: 20px 0;
        }
        th, td {
            border: 1px solid var(--border-color);
            padding: 12px;
            text-align: left;
        }
        th {
            background-color: var(--primary-color);
            color: white;
        }
        tr:nth-child(even) { background-color: #f9f9f9; }
        
        .step-box {
            background: #f8f9fa;
            border: 1px solid #e9ecef;
            padding: 20px;
            margin-bottom: 20px;
            border-radius: 5px;
        }
        .copy-btn {
            background-color: var(--accent-color);
            color: white;
            border: none;
            padding: 5px 10px;
            cursor: pointer;
            border-radius: 3px;
            font-size: 0.8em;
            float: right;
        }
        .copy-btn:hover { background-color: #2980b9; }
        
        .diagram {
            font-family: monospace;
            white-space: pre;
            background: #f0f0f0;
            padding: 20px;
            border: 1px dashed #ccc;
            overflow-x: auto;
            text-align: center;
            font-size: 0.85em;
        }
    </style>
</head>
<body>

<div class="container">
    <h1>Architecture Proxy Sécurisé C++ sur Virt-Manager</h1>
    <p><strong>Objectif :</strong> Créer une infrastructure virtualisée où des VMs Yunohost sont isolées dans un réseau privé, protégées par une VM Gateway (Debian) exécutant un Reverse Proxy personnalisé en C++.</p>
    <p><strong>Contexte :</strong> Freebox Pop (IP Fixe V4 Full Stack), PC Hôte Linux avec virt-manager.</p>

    <!-- SECTION 1: ARCHITECTURE -->
    <h2>1. Architecture Réseau</h2>
    <div class="alert alert-success">
        <strong>Topologie Clé :</strong> La VM Yunohost est <em>invisible</em> depuis Internet. Seul le Proxy sur la Gateway est exposé.
    </div>

    <div class="diagram">
+-----------------------+       INTERNET (IP Fixe)       +---------------------------+
|   UTILISATEUR         |                                |   FREEBOX POP             |
|   (Navigateur)        |                                |   (IP Publique Fixe)      |
+----------+------------+                                +-------------+-------------+
           |                                                       |
           | 1. Requêtes HTTP/HTTPS (Port 80/443)                  |
           |                                                       |
           v                                                       v
+--------------------------------------------------------------------------------------------+
|                                  SERVEUR PHYSIQUE (Hôte KVM)                               |
|  (PC avec virt-manager)                                                                      |
|                                                                                              |
|  +----------------------+          +----------------------+          +------------------+   |
|  |                      |          |   RÉSEAU VIRTUEL     |          |  VM YUNOHOST     |   |
|  |  VM GATEWAY (Debian) | <------> |   (reseau-yunohost)  | <------> |  (Service A)     |   |
|  |                      |          |   (192.168.100.0/24) |          |                  |   |
|  |  +--------------+    |          |   (Bridge virtuel)   |          |  IP: 192.168.100.10|   |
|  |  | eth0 (WAN)   |----+----------+----------------------+----------+--> eth0 (LAN)    |   |
|  |  | 192.168.1.50 |    |          |                    |          |                  |   |
|  |  +--------------+    |          |                    |          |                  |   |
|  |                      |          |                    |          |                  |   |
|  |  +--------------+    |          |                    |          |                  |   |
|  |  | eth1 (LAN)   |----+----------+--------------------+----------+--> eth0 (LAN)    |   |
|  |  | 192.168.100.1|    |          |                    |          |                  |   |
|  |  +--------------+    |          |                    |          |                  |   |
|  |                      |          |                    |          |                  |   |
|  |  [Services]:         |          |                    |          |  [Services]:     |   |
|  |  - Reverse Proxy C++ |          |                    |          |  - Web/Mail      |   |
|  |  - Pare-feu (NAT)    |          |                    |          |  - Apps          |   |
|  |  - Interface Web     |          |                    |          |                  |   |
|  +----------------------+          +----------------------+          +------------------+   |
+--------------------------------------------------------------------------------------------+
    </div>

    <h3>Configuration des Adresses IP</h3>
    <table>
        <thead>
            <tr>
                <th>Composant</th>
                <th>Interface</th>
                <th>Réseau</th>
                <th>Adresse IP</th>
                <th>Rôle</th>
            </tr>
        </thead>
        <tbody>
            <tr>
                <td>Freebox</td>
                <td>LAN</td>
                <td>192.168.1.0/24</td>
                <td>192.168.1.254</td>
                <td>Passerelle Physique</td>
            </tr>
            <tr>
                <td>VM Gateway</td>
                <td>eth0 (WAN)</td>
                <td>192.168.1.0/24</td>
                <td><strong>192.168.1.50</strong> (Statique)</td>
                <td><strong>Cible de la DMZ</strong></td>
            </tr>
            <tr>
                <td>VM Gateway</td>
                <td>eth1 (LAN)</td>
                <td>192.168.100.0/24</td>
                <td>192.168.100.1</td>
                <td>Gateway Interne</td>
            </tr>
            <tr>
                <td>VM Yunohost</td>
                <td>eth0</td>
                <td>192.168.100.0/24</td>
                <td>192.168.100.10</td>
                <td>Service Caché</td>
            </tr>
        </tbody>
    </table>

    <div class="alert alert-danger">
        <strong>Attention :</strong> La Freebox doit avoir l'IP <code>192.168.1.50</code> configurée en <strong>DMZ</strong>.
    </div>

    <!-- SECTION 2: CONFIGURATION VIRT-MANAGER -->
    <h2>2. Configuration Virt-Manager</h2>
    
    <div class="step-box">
        <h3>Étape A : Créer le réseau interne</h3>
        <p>Dans l'interface virt-manager :</p>
        <ol>
            <li>Ouvrez "Détails de l'hôte" > onglet "Réseaux virtuels".</li>
            <li>Cliquez sur <strong>+</strong> pour ajouter un réseau.</li>
            <li>Nom : <code>reseau-yunohost</code>.</li>
            <li>IPv4 : <code>192.168.100.0/24</code>.</li>
            <li>Mode : <strong>NAT</strong> (par défaut).</li>
            <li>Activer le DHCP : Oui (plage <code>192.168.100.10</code> à <code>192.168.100.254</code>).</li>
        </ol>
    </div>

    <div class="step-box">
        <h3>Étape B : Configurer la VM Gateway (Debian)</h3>
        <p>Éditez les détails de la VM Debian :</p>
        <ul>
            <li><strong>Interface 1 (WAN)</strong> :
                <ul>
                    <li>Source : <strong>Bridge</strong> vers l'interface physique de votre PC (ex: <code>eth0</code> ou <code>enp3s0</code>).</li>
                    <li>Modèle : <code>virtio</code>.</li>
                </ul>
            </li>
            <li><strong>Interface 2 (LAN)</strong> :
                <ul>
                    <li>Source : <strong>réseau virtuel</strong> nommé <code>reseau-yunohost</code>.</li>
                    <li>Modèle : <code>virtio</code>.</li>
                </ul>
            </li>
        </ul>
    </div>

    <div class="step-box">
        <h3>Étape C : Configurer la VM Yunohost</h3>
        <ul>
            <li>Éditez les détails de la VM Yunohost.</li>
            <li><strong>Interface</strong> :
                <ul>
                    <li>Source : <strong>réseau virtuel</strong> <code>reseau-yunohost</code>.</li>
                    <li><strong>Ne pas ajouter d'interface WAN</strong>.</li>
                </ul>
            </li>
        </ul>
    </div>

    <!-- SECTION 3: SCRIPT BASH -->
    <h2>3. Script de Configuration Gateway (Bash)</h2>
    <p>À exécuter sur la VM Debian (Gateway) après installation. Ce script active le routage, le NAT et le pare-feu.</p>
    
    <button class="copy-btn" onclick="copyCode('bash-code')">Copier</button>
    <pre id="bash-code"><code>#!/bin/bash

# ==========================================
# CONFIGURATION DE LA GATEWAY DEBIAN
# ==========================================

# --- 1. Configuration des Interfaces (À adapter) ---
WAN_IF="eth0"   # Interface vers la Box/Internet (Bridge physique)
LAN_IF="eth1"   # Interface vers le réseau 'reseau-yunhost' (192.168.100.x)

# Vérification simple
if ! ip link show $WAN_IF &>/dev/null; then
    echo "ERREUR: Interface WAN ($WAN_IF) introuvable."
    exit 1
fi
if ! ip link show $LAN_IF &>/dev/null; then
    echo "ERREUR: Interface LAN ($LAN_IF) introuvable."
    exit 1
fi

echo "[+] Interfaces détectées : WAN=$WAN_IF, LAN=$LAN_IF"

# --- 2. Activation du Forwarding IP (Routeur) ---
echo "[+] Activation du forwarding IP..."
echo "net.ipv4.ip_forward=1" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

# --- 3. Configuration du Pare-feu (iptables) ---
echo "[+] Configuration des règles iptables..."

# Effacer les règles existantes
sudo iptables -F
sudo iptables -t nat -F
sudo iptables -X
sudo iptables -t nat -X

# Politiques par défaut
sudo iptables -P INPUT DROP
sudo iptables -P FORWARD DROP
sudo iptables -P OUTPUT ACCEPT

# --- Règles INPUT (Trafic vers la Gateway) ---
sudo iptables -A INPUT -i lo -j ACCEPT
sudo iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT # SSH
sudo iptables -A INPUT -i $WAN_IF -p tcp --dport 80 -j ACCEPT # HTTP
sudo iptables -A INPUT -i $WAN_IF -p tcp --dport 443 -j ACCEPT # HTTPS

# --- Règles FORWARD (Trafic transitant) ---
sudo iptables -A FORWARD -i $LAN_IF -o $WAN_IF -j ACCEPT # Sortie VMs
sudo iptables -A FORWARD -i $WAN_IF -o $LAN_IF -m state --state ESTABLISHED,RELATED -j ACCEPT
sudo iptables -A FORWARD -i $WAN_IF -o $LAN_IF -p tcp --dport 80 -j ACCEPT # Proxy In
sudo iptables -A FORWARD -i $WAN_IF -o $LAN_IF -p tcp --dport 443 -j ACCEPT # Proxy In

# --- Règles NAT (Masquerade) ---
sudo iptables -t nat -A POSTROUTING -o $WAN_IF -j MASQUERADE

# --- 4. Persistance ---
echo "[+] Sauvegarde des règles..."
sudo apt install -y iptables-persistent
sudo netfilter-persistent save

echo "=========================================="
echo "CONFIGURATION TERMINÉE !"
echo "=========================================="</code></pre>

    <!-- SECTION 4: CODE C++ -->
    <h2>4. Source C++ (Proxy Manager)</h2>
    <p>Code complet incluant le serveur HTTP (interface web), le moteur de proxy et la gestion de config.</p>
    
    <button class="copy-btn" onclick="copyCode('cpp-code')">Copier</button>
    <pre id="cpp-code"><code>#include &lt;iostream&gt;
#include &lt;fstream&gt;
#include &lt;sstream&gt;
#include &lt;string&gt;
#include &lt;vector&gt;
#include &lt;thread&gt;
#include &lt;mutex&gt;
#include &lt;cstring&gt;
#include &lt;sys/socket.h&gt;
#include &lt;netinet/in.h&gt;
#include &lt;unistd.h&gt;
#include &lt;arpa/inet.h&gt;
#include &lt;regex&gt;
#include &lt;ctime&gt;

struct VMConfig {
    std::string id;
    std::string name;
    std::string domain;
    std::string ip;
    int port;
    bool enabled;
};

class ConfigManager {
private:
    std::string config_path;
    std::vector&lt;VMConfig&gt; vms;
    std::string admin_password;
    std::mutex mtx;

public:
    ConfigManager(std::string path = "config.json") : config_path(path) { load_config(); }

    void load_config() {
        std::lock_guard&lt;std::mutex&gt; lock(mtx);
        std::ifstream file(config_path);
        if (!file.is_open()) return;
        std::stringstream buffer; buffer &lt;&lt; file.rdbuf();
        parse_json(buffer.str());
    }

    void save_config() {
        std::lock_guard&lt;std::mutex&gt; lock(mtx);
        std::ofstream file(config_path);
        file &lt;&lt; "{\n  \"vm_list\": [\n";
        for (size_t i = 0; i &lt; vms.size(); i++) {
            file &lt;&lt; "    {\"id\": \"" &lt;&lt; vms[i].id &lt;&lt; "\", \"name\": \"" &lt;&lt; vms[i].name &lt;&lt; "\", ";
            file &lt;&lt; "\"domain\": \"" &lt;&lt; vms[i].domain &lt;&lt; "\", \"ip\": \"" &lt;&lt; vms[i].ip &lt;&lt; "\", ";
            file &lt;&lt; "\"port\": " &lt;&lt; vms[i].port &lt;&lt; ", \"enabled\": " &lt;&lt; (vms[i].enabled ? "true" : "false") &lt;&lt; "}";
            if (i &lt; vms.size() - 1) file &lt;&lt; ",";
            file &lt;&lt; "\n";
        }
        file &lt;&lt; "  ]\n}";
    }

    void parse_json(const std::string& content) {
        vms.clear();
        std::regex vm_block(R"(\{\s*"id"\s*:\s*"([^"]+)".*?"name"\s*:\s*"([^"]+)".*?"domain"\s*:\s*"([^"]+)".*?"ip"\s*:\s*"([^"]+)".*?"port"\s*:\s*(\d+).*?"enabled"\s*:\s*(true|false)\s*\})", std::regex::dotall);
        auto begin = std::sregex_iterator(content.begin(), content.end(), vm_block);
        auto end = std::sregex_iterator();
        for (auto i = begin; i != end; ++i) {
            vms.push_back({(*i)[1], (*i)[2], (*i)[3], (*i)[4], std::stoi((*i)[5]), (*i)[6]=="true"});
        }
    }

    void add_vm(const std::string& id, const std::string& name, const std::string& domain, const std::string& ip, int port) {
        std::lock_guard&lt;std::mutex&gt; lock(mtx);
        vms.push_back({id, name, domain, ip, port, true});
        save_config();
    }

    void remove_vm(const std::string& id) {
        std::lock_guard&lt;std::mutex&gt; lock(mtx);
        vms.erase(std::remove_if(vms.begin(), vms.end(), [&id](const VMConfig& vm) { return vm.id == id; }), vms.end());
        save_config();
    }

    VMConfig* find_by_domain(const std::string& domain) {
        std::lock_guard&lt;std::mutex&gt; lock(mtx);
        for (auto& vm : vms) if (vm.domain == domain &amp;&amp; vm.enabled) return &amp;vm;
        return nullptr;
    }

    std::vector&lt;VMConfig&gt; get_all_vms() { std::lock_guard&lt;std::mutex&gt; lock(mtx); return vms; }
};

class HTTPServer {
private:
    int server_fd;
    ConfigManager&amp; config;
    std::string generate_html() {
        std::stringstream html;
        html &lt;&lt; "&lt;!DOCTYPE html&gt;&lt;html&gt;&lt;head&gt;&lt;title&gt;Proxy Manager&lt;/title&gt;&lt;style&gt;body{font-family:Arial;} table{border-collapse:collapse;width:100%;} th,td{border:1px solid #ddd;padding:8px;} th{background:#4CAF50;color:white;}&lt;/style&gt;&lt;/head&gt;&lt;body&gt;&lt;h1&gt;Proxy Manager&lt;/h1&gt;&lt;form method='POST' action='/add'&gt;ID: &lt;input name='id'&gt; Nom: &lt;input name='name'&gt; Domaine: &lt;input name='domain'&gt; IP: &lt;input name='ip'&gt; Port: &lt;input name='port' value='80'&gt; &lt;button type='submit'&gt;Ajouter&lt;/button&gt;&lt;/form&gt;&lt;h3&gt;Liste&lt;/h3&gt;&lt;table&gt;&lt;tr&gt;&lt;th&gt;ID&lt;/th&gt;&lt;th&gt;Nom&lt;/th&gt;&lt;th&gt;Domaine&lt;/th&gt;&lt;th&gt;IP&lt;/th&gt;&lt;th&gt;Action&lt;/th&gt;&lt;/tr&gt;";
        for (const auto&amp; vm : config.get_all_vms()) {
            html &lt;&lt; "&lt;tr&gt;&lt;td&gt;" &lt;&lt; vm.id &lt;&lt; "&lt;/td&gt;&lt;td&gt;" &lt;&lt; vm.name &lt;&lt; "&lt;/td&gt;&lt;td&gt;" &lt;&lt; vm.domain &lt;&lt; "&lt;/td&gt;&lt;td&gt;" &lt;&lt; vm.ip &lt;&lt; "&lt;/td&gt;&lt;td&gt;&lt;form method='POST' action='/remove' style='display:inline;'&gt;&lt;input type='hidden' name='id' value='" &lt;&lt; vm.id &lt;&lt; "'&gt;&lt;button type='submit'&gt;Supprimer&lt;/button&gt;&lt;/form&gt;&lt;/td&gt;&lt;/tr&gt;";
        }
        html &lt;&lt; "&lt;/table&gt;&lt;/body&gt;&lt;/html&gt;";
        return html.str();
    }
    std::string get_param(const std::string&amp; data, const std::string&amp; param) {
        std::string search = param + "="; size_t pos = data.find(search);
        if (pos == std::string::npos) return "";
        pos += search.length(); size_t end = data.find('&', pos);
        return data.substr(pos, end == std::string::npos ? data.length() - pos : end - pos);
    }
public:
    HTTPServer(ConfigManager&amp; cfg, int port = 8080) : config(cfg) {
        server_fd = socket(AF_INET, SOCK_STREAM, 0);
        int opt = 1; setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &amp;opt, sizeof(opt));
        sockaddr_in addr{}; addr.sin_family = AF_INET; addr.sin_addr.s_addr = INADDR_ANY; addr.sin_port = htons(port);
        bind(server_fd, (sockaddr*)&amp;addr, sizeof(addr)); listen(server_fd, 10);
        std::cout &lt;&lt; "[+] Interface Web sur port " &lt;&lt; port &lt;&lt; std::endl;
    }
    void handle_request(int client_fd) {
        char buffer[8192] = {0}; read(client_fd, buffer, sizeof(buffer));
        std::string request(buffer), response;
        if (request.find("POST /add") != std::string::npos) {
            std::string data = request.substr(request.find("\r\n\r\n") + 4);
            config.add_vm(get_param(data, "id"), get_param(data, "name"), get_param(data, "domain"), get_param(data, "ip"), std::stoi(get_param(data, "port")));
            response = "HTTP/1.1 302 Found\r\nLocation: /\r\n\r\n";
        } else if (request.find("POST /remove") != std::string::npos) {
            std::string data = request.substr(request.find("\r\n\r\n") + 4);
            config.remove_vm(get_param(data, "id"));
            response = "HTTP/1.1 302 Found\r\nLocation: /\r\n\r\n";
        } else {
            response = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n" + generate_html();
        }
        write(client_fd, response.c_str(), response.length()); close(client_fd);
    }
    void run() { while(true) { sockaddr_in client_addr{}; socklen_t len = sizeof(client_addr); int cfd = accept(server_fd, (sockaddr*)&amp;client_addr, &amp;len); if(cfd>=0) std::thread(&amp;HTTPServer::handle_request, this, cfd).detach(); } }
};

class ReverseProxy {
private:
    ConfigManager&amp; config;
    int create_backend(const std::string&amp; ip, int port) {
        int sock = socket(AF_INET, SOCK_STREAM, 0);
        sockaddr_in srv{}; srv.sin_family = AF_INET; srv.sin_port = htons(port); inet_pton(AF_INET, ip.c_str(), &amp;srv.sin_addr);
        if (connect(sock, (sockaddr*)&amp;srv, sizeof(srv)) &lt; 0) { close(sock); return -1; }
        return sock;
    }
public:
    ReverseProxy(ConfigManager&amp; cfg, int port = 80) : config(cfg) {
        int lfd = socket(AF_INET, SOCK_STREAM, 0);
        int opt = 1; setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &amp;opt, sizeof(opt));
        sockaddr_in addr{}; addr.sin_family = AF_INET; addr.sin_addr.s_addr = INADDR_ANY; addr.sin_port = htons(port);
        bind(lfd, (sockaddr*)&amp;addr, sizeof(addr)); listen(lfd, 100);
        std::cout &lt;&lt; "[+] Proxy sur port " &lt;&lt; port &lt;&lt; std::endl;
        while(true) {
            sockaddr_in caddr{}; socklen_t clen = sizeof(caddr); int cfd = accept(lfd, (sockaddr*)&amp;caddr, &amp;clen);
            if(cfd &lt; 0) continue;
            std::thread([this, cfd]() {
                char buf[8192] = {0}; int bytes = recv(cfd, buf, sizeof(buf)-1, 0);
                if(bytes &gt; 0) {
                    buf[bytes] = '\0'; std::string req(buf);
                    std::regex host_r(R"(Host:\s*([^\r\n]+))"); std::smatch m; std::string host = "localhost";
                    if(std::regex_search(req, m, host_r)) { host = m[1].str(); size_t p = host.find(':'); if(p!=std::string::npos) host = host.substr(0,p); }
                    VMConfig* vm = config.find_by_domain(host);
                    if(vm) {
                        int bfd = create_backend(vm-&gt;ip, vm-&gt;port);
                        if(bfd &gt;= 0) {
                            std::string mod_req = req; size_t eh = mod_req.find("\r\n\r\n");
                            if(eh != std::string::npos) mod_req.insert(eh, "X-Forwarded-For: client\r\nX-Real-IP: client\r\n");
                            send(bfd, mod_req.c_str(), mod_req.length(), 0);
                            char bbuf[4096];
                            while(true) {
                                fd_set fds; FD_ZERO(&amp;fds); FD_SET(cfd, &amp;fds); FD_SET(bfd, &amp;fds);
                                struct timeval tv{10,0}; int act = select(std::max(cfd,bfd)+1, &amp;fds, NULL, NULL, &amp;tv);
                                if(act&lt;0) break;
                                if(FD_ISSET(cfd, &amp;fds)) { int r = recv(cfd, bbuf, sizeof(bbuf), 0); if(r&lt;=0) break; send(bfd, bbuf, r, 0); }
                                if(FD_ISSET(bfd, &amp;fds)) { int r = recv(bfd, bbuf, sizeof(bbuf), 0); if(r&lt;=0) break; send(cfd, bbuf, r, 0); }
                            }
                            close(bfd);
                        } else { std::string err = "HTTP/1.1 502 Bad Gateway\r\n\r\n"; send(cfd, err.c_str(), err.length(), 0); }
                    } else { std::string err = "HTTP/1.1 404 Not Found\r\n\r\n"; send(cfd, err.c_str(), err.length(), 0); }
                }
                close(cfd);
            }).detach();
        }
    }
};

int main() {
    ConfigManager cfg("config.json");
    std::thread t1([&cfg](){ ReverseProxy p(cfg, 80); p.run(); });
    std::thread t2([&cfg](){ HTTPServer w(cfg, 8080); w.run(); });
    t1.join(); t2.join();
    return 0;
}</code></pre>

    <!-- SECTION 5: MAKEFILE -->
    <h2>5. Makefile</h2>
    
    <button class="copy-btn" onclick="copyCode('make-code')">Copier</button>
    <pre id="make-code"><code>CXX = g++
CXXFLAGS = -std=c++17 -Wall -pthread -O2
TARGET = proxy_manager

all: $(TARGET)

$(TARGET): main.cpp
	$(CXX) $(CXXFLAGS) -o $@ $<

clean:
	rm -f $(TARGET)

run: $(TARGET)
	sudo ./$(TARGET)</code></pre>

    <!-- SECTION 6: CONFIG.JSON -->
    <h2>6. Fichier de Configuration (config.json)</h2>
    <p>Créez ce fichier manuellement ou laissez le programme le créer au premier lancement.</p>
    
    <button class="copy-btn" onclick="copyCode('json-code')">Copier</button>
    <pre id="json-code"><code>{
  "vm_list": []
}</code></pre>

    <!-- SECTION 7: INSTRUCTIONS -->
    <h2>7. Instructions de Déploiement</h2>
    <ol>
        <li><strong>Préparer la VM Gateway (Debian) :</strong>
            <ul>
                <li>Installer les dépendances : <code>sudo apt update && sudo apt install -y build-essential net-tools iptables-persistent</code>.</li>
                <li>Créer les fichiers <code>main.cpp</code>, <code>Makefile</code>, <code>config.json</code>.</li>
                <li>Lancer le script Bash <code>setup_gateway.sh</code> (copié ci-dessus) pour configurer le réseau.</li>
            </ul>
        </li>
        <li><strong>Compiler le Proxy :</strong>
            <ul>
                <li><code>make</code></li>
            </ul>
        </li>
        <li><strong>Lancer le Proxy :</strong>
            <ul>
                <li><code>sudo ./proxy_manager</code></li>
            </ul>
        </li>
        <li><strong>Configurer les VMs Yunohost :</strong>
            <ul>
                <li>Assurez-vous qu'elles sont sur le réseau <code>reseau-yunohost</code>.</li>
                <li>Accédez à l'interface web du proxy : <code>http://192.168.1.50:8080</code>.</li>
                <li>Ajoutez vos VMs via l'interface (ex: Domaine: <code>monsite.com</code>, IP: <code>192.168.100.10</code>).</li>
            </ul>
        </li>
        <li><strong>Test Final :</strong>
            <ul>
                <li>Depuis l'extérieur (4G), accédez à <code>http://<VOTRE_IP_FIXE></code>.</li>
                <li>Le trafic doit passer par la Gateway, puis être routé vers la VM Yunohost.</li>
            </ul
</html>