Plusieurs instances Wapt sur un même serveur

Cet article est une sorte de PoC démontrant la possibilité d’héberger plusieurs instance de Wapt sur un même serveur.
Nous ferons dans cet article une maquette avec deux instances mais il est possible de l’adapter pour augmenter le nombre d’instances.
Wapt est un logiciel de déploiement, de mise à jour et de suppression automatisé de paquetages pour Windows edité par TranquilIT.
Wapt existe en deux versions, enterprise et community. Dans cette article nous aborderons uniquement la version community.

Nous installerons deux instances de wapt nommées wapt-dev et wapt-prod.

Pour arriver à nos fins, nous utiliserons le container docker que j’ai mis à disposition sur le docker hub. Pour simplifier la compréhension de ce PoC, le serveur nginx sera installé directement sur l’hôte et non pas dans un container.

Prérequis :

Nous utiliserons un serveur installé en version minimale de Centos 7
Le serveur doit bien évidemment posséder suffisamment de ram, d’espace disque et de puissance cpu pour supporter l’exécution de deux containers.
Deux enregistrements dns font pointer wapt-dev.be-root.com et wapt-prod.be-root.com sur l’adresse IP de notre serveur.

Configuration initiale du système :

Tout d’abord, nous configurons le firewall :

systemctl enable firewalld --now
firewall-cmd --permanent --add-service http
firewall-cmd --permanent --add-service https

et nous désactivons SELinux :

sed -i 's/enforcing/disabled/g' /etc/selinux/config /etc/selinux/config && setenforce 0

Initialisation des containers

Nous allons maintenant installer Docker et Docker-compose :

yum install -y yum-utils wget
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
yum install -y docker-ce docker-ce-cli containerd.io
systemctl start docker && systemctl enable docker
wget https://github.com/docker/compose/releases/download/1.25.5/docker-compose-Linux-x86_64 -O /usr/local/bin/docker-compose && chmod +x  /usr/local/bin/docker-compose && rehash

Nous allons créer l’environnement nécessaire lancer les containers ainsi que monter les volumes :

mkdir -p /opt/wapt/compose
mkdir -p /opt/wapt/wapt-prod/nginx /opt/wapt/wapt-prod/html /opt/wapt/wapt-prod/ssl
mkdir -p /opt/wapt/wapt-dev/nginx /opt/wapt/wapt-dev/html /opt/wapt/wapt-dev/ssl

Éditons (et créons) le fichier /opt/wapt/compose/docker-compose.yml :

version: '3'
services:
  wapt-dev:
    image: clamy54/wapt-ce:latest
    hostname: wapt-dev.be-root.com
    container_name: wapt-dev
    privileged: true
    ports:
      - "10080:8080"
    volumes:
      - /sys/fs/cgroup:/sys/fs/cgroup:ro
      - /opt/wapt/wapt-dev/nginx:/etc/nginx
      - /opt/wapt/wapt-dev/html:/var/www/html
      - /opt/wapt/wapt-dev/ssl:/opt/wapt/waptserver/ssl
    environment:
      - DISABLE_NGINX=1
      - WAPT_ADMIN_PASSWORD=passdev

  wapt-prod:
    image: clamy54/wapt-ce:latest
    hostname: wapt-prod.be-root.com
    container_name: wapt-prod
    privileged: true
    ports:
      - "11080:8080"
    volumes:
      - /sys/fs/cgroup:/sys/fs/cgroup:ro
      - /opt/wapt/wapt-prod/nginx:/etc/nginx
      - /opt/wapt/wapt-prod/ssl:/opt/wapt/waptserver/ssl
      - /opt/wapt/wapt-prod/html:/var/www/html
    environment:
      - DISABLE_NGINX=1
      - WAPT_ADMIN_PASSWORD=passprod

Attention, nous sommes en présence d’un fichier au formal Yaml. L’indentation est donc fondamentale.
La variable d’environnement DISABLE_NGINX=1 permet de désactiver nginx dans le container car nous utiliserons un service nginx commun en frontal directement sur l’hôte.
Cette variable permet également de faire écouter le daemon waptserver sur tous les ports et non pas seulement sur le localhost.
La variable d’environnement WAPT_ADMIN_PASSWORD permet de fixer le mot de passe admin de l’instance wapt. Le port 8080 du container wapt-prod sera mappé sur le port 11080 de l’hôte
et le port 8080 du container wapt-dev sera mappé sur le port 10080 de l’hôte.

Nous pouvons ainsi démarrer les containers :

cd /opt/wapt/compose
docker-compose up -d

Installation du frontal nginx

Pour des raisons de cohérence et de droits d’accès aux fichiers, nous allons faire en sorte que l’utilisateur nginx ait les mêmes uid/gid que l’utilisateur nginx à l’intérieur des containers (qui est forcé lors de l’initialisation de ces derniers).

groupadd -g 8080 nginx && useradd -d /var/lib/nginx -g nginx -G nginx -u 8080 -s /sbin/nologin -m nginx && passwd -l nginx

Nous allons maintenant installer nginx :

yum install -y epel-release
yum install -y nginx

Grace aux volumes montés sur l’hôte, nous pouvons ainsi configurer facilement nginx.
Nous allons d’abord copier le fichier nginx.conf depuis l’un des container :

cp /opt/wapt/wapt-prod/nginx/nginx.conf /etc/nginx/

Nous allons ensuite créer un fichier /etc/nginx/conf.d/wapt-prod.conf inspiré du fichier /opt/wapt/wapt-prod/nginx/conf.d/wapt.conf et en y adaptant certains paramètres.

server {
    listen                      80;
    listen                      443 ssl;
    server_name                 wapt-prod.be-root.com;

    ssl_certificate             "/opt/wapt/wapt-prod/ssl/cert.pem";
    ssl_certificate_key         "/opt/wapt/wapt-prod/ssl/key.pem";
    ssl_protocols               TLSv1.2;
    ssl_dhparam                 /opt/wapt/wapt-prod/ssl/dhparam.pem;
    ssl_prefer_server_ciphers   on;
    ssl_ciphers                 'EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH';
    ssl_stapling                on;
    ssl_stapling_verify         on;
    ssl_session_cache           none;
    ssl_session_tickets         off;


    #ssl_client_certificate "/opt/wapt/conf/ca-wapt-prod.be-root.com.crt";
    #ssl_crl "None";
    #ssl_verify_client optional;


    gzip_min_length     1000;
    gzip_buffers        4 8k;
    gzip_http_version   1.0;
    gzip_disable        "msie6";
    gzip_types          text/plain text/css application/json;
    gzip_vary           on;

    index index.html;


    location / {
        add_header Cache-Control "store, no-cache, must-revalidate, post-check=0, pre-check=0";
        add_header Pragma "no-cache";
        proxy_set_header X-Real-IP  $remote_addr;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        # be sure these headers are not forwarded
        proxy_set_header X-Ssl-Client-Dn  "";
        proxy_set_header X-Ssl-Authenticated  "";

        client_max_body_size 4096m;
        client_body_timeout 1800;

        location /static {
            alias "/opt/wapt/wapt-prod/html/static";
        }


        location /ssl {
            alias "/opt/wapt/wapt-prod/html/ssl";
        }


        location ~ ^/(wapt/waptsetup-tis.exe|wapt/waptagent.exe|wapt/waptdeploy.exe|sync.json)$ {
            root "/opt/wapt/wapt-prod/html";
        }

        location ~ ^/(wapt/.*|wapt-host/.*|waptwua/.*|wapt-diff-repos/.*)$ {

            root "/opt/wapt/wapt-prod/html";
        }

        location / {
            proxy_set_header X-Real-IP  $remote_addr;
            proxy_set_header Host $host;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;

            client_max_body_size 4096m;
            client_body_timeout 1800;


            location /add_host_kerberos {
                return 403;
            }


            location /wapt-host/Packages {
                    return 403;
            }

            location / {

                add_header X-Forwarded-List $http_x_forwarded_for;
                add_header X-Remote-IP $remote_addr;
                proxy_pass http://127.0.0.1:11080;
            }

            location /socket.io {
                proxy_http_version 1.1;
                proxy_buffering off;
                proxy_set_header Upgrade $http_upgrade;
                proxy_set_header Connection "Upgrade";
                proxy_pass http://127.0.0.1:11080/socket.io;
            }
        }
    }
}

Les paramêtres à adapter par rapport au fichier initial présent dans le volume sont les chemins des aliases, le server_name correspondant au vhost, les ports référencés dans les paramètres proxy_pass et les chemins des certificats ssl.

De la même façon, nous pouvons créer un fichier /etc/nginx/conf.d/wapt-dev.conf inspiré du fichier /opt/wapt/wapt-dev/nginx/conf.d/wapt.conf :

server {
    listen                      80;
    listen                      443 ssl;
    server_name                 wapt-dev.be-root.com;

    ssl_certificate             "/opt/wapt/wapt-dev/ssl/cert.pem";
    ssl_certificate_key         "/opt/wapt/wapt-dev/ssl/key.pem";
    ssl_protocols               TLSv1.2;
    ssl_dhparam                 /opt/wapt/wapt-dev/ssl/dhparam.pem;
    ssl_prefer_server_ciphers   on;
    ssl_ciphers                 'EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH';
    ssl_stapling                on;
    ssl_stapling_verify         on;
    ssl_session_cache           none;
    ssl_session_tickets         off;


    #ssl_client_certificate "/opt/wapt/conf/ca-wapt-dev.be-root.com.crt";
    #ssl_crl "None";
    #ssl_verify_client optional;


    gzip_min_length     1000;
    gzip_buffers        4 8k;
    gzip_http_version   1.0;
    gzip_disable        "msie6";
    gzip_types          text/plain text/css application/json;
    gzip_vary           on;

    index index.html;


    location / {
        add_header Cache-Control "store, no-cache, must-revalidate, post-check=0, pre-check=0";
        add_header Pragma "no-cache";
        proxy_set_header X-Real-IP  $remote_addr;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        # be sure these headers are not forwarded
        proxy_set_header X-Ssl-Client-Dn  "";
        proxy_set_header X-Ssl-Authenticated  "";

        client_max_body_size 4096m;
        client_body_timeout 1800;

        location /static {
            alias "/opt/wapt/wapt-dev/html/static";
        }


        location /ssl {
            alias "/opt/wapt/wapt-dev/html/ssl";
        }


        location ~ ^/(wapt/waptsetup-tis.exe|wapt/waptagent.exe|wapt/waptdeploy.exe|sync.json)$ {
            root "/opt/wapt/wapt-dev/html";
        }

        location ~ ^/(wapt/.*|wapt-host/.*|waptwua/.*|wapt-diff-repos/.*)$ {

            root "/opt/wapt/wapt-dev/html";
        }

        location / {
            proxy_set_header X-Real-IP  $remote_addr;
            proxy_set_header Host $host;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;

            client_max_body_size 4096m;
            client_body_timeout 1800;


            location /add_host_kerberos {
                return 403;
            }


            location /wapt-host/Packages {
                    return 403;
            }

            location / {

                add_header X-Forwarded-List $http_x_forwarded_for;
                add_header X-Remote-IP $remote_addr;
                proxy_pass http://127.0.0.1:10080;
            }

            location /socket.io {
                proxy_http_version 1.1;
                proxy_buffering off;
                proxy_set_header Upgrade $http_upgrade;
                proxy_set_header Connection "Upgrade";
                proxy_pass http://127.0.0.1:10080/socket.io;
            }
        }
    }
}

Nous pouvons ensuite lancer nginx :

systemctl enable nginx --now

En conclusion

Nos deux containers tournent et exposent le service waptserver sur les ports 10080 et 11080 de l’hôte.
Le serveur nginx installé sur l’hôte sera reverse proxy pour ces deux services grâce à des vhosts basés sur le nom.
Grace aux volumes docker montés sur l’hôte, le serveur nginx sera également capable de servir l’ensemble des pages et binaires.
Bien évidemment d’autres possibilités ou implémentations sont possibles (par exemple restreindre l’accès à un vhost, nginx en container, automatiser la génération de la configuration nginx, etc …). Déployer un container supplémentaire est facile et rapide : il suffit de créer l’arborescence pour les volumes, d’ajouter une instance au fichier docker-compose et une fois le container lancé, de générer un nouveau vhost nginx en fonction des fichiers de configurations présent dans les volumes montés de l’instance.

Pour accéder à nos instances wapt, il suffit maintenant de lancer depuis une machine Windows la console wapt. Dans « serveur » renseigner le nom de l’instance désirée (wapt-prod.be-root.com ou wapt-dev.be-root.com), de mettre admin en tant que nom d’utilisateur et de renseigner le mot de passe correpondant à l’instance (passprod ou passdev).

fenetre de connexion wapt

Autoconfig pour Thunderbird

Depuis la version 3.0 de Mozilla Thunderbird, à la création d’un compte de messagerie, ce dernier cherche par plusieurs moyen à configurer automatiquement les paramètres des serveurs de messagerie. Les paramètres peuvent ainsi être renseignés dans un fichier au format XML. La liste des paramètres pouvant être utilisée dans ce fichier XML se trouve à l’adresse https://wiki.mozilla.org/Thunderbird:Autoconfiguration:ConfigFileFormat

 

Supposons que l’on rentre l’adresse toto@mondomaine.com.
La recherche de la configuration se déroule suivant plusieurs étapes. En cas d’échec à une étape, on passer à la suivante. En cas de succès à une étape, les étapes suivantes ne seront pas effectuées :

  • Recherche sur le disque dur d’un fichier domaine.com.xml situé dans le répertoire isp présent dans le répertoire d’installation de thunderbird
  • Téléchargement du fichier http://autoconfig.domaine.com/mail/config-v1.1.xml?emailaddress=toto@domaine.com
  • Téléchargement du fichier http://domaine.com/.well-known/autoconfig/mail/config-v1.1.xml
  • Recherche DNS d’un enregistrement TXT contenant une URL indiquant à quelle adresse télécharger le fichier XML
  • Téléchargement sur la base mozilla : https://autoconfig-live.mozillamessaging.com/autoconfig/domaine.com
  • Recherche heuristique ( imap.domaine.com, pop.domaine.com, …)
  • Saisie manuelle

Nous allons donc implémenter la solution utilisant le téléchargement du fichier http://autoconfig.domaine.com/mail/config-v1.1.xml?emailaddress=toto@domaine.com.

Cette solution présente l’avantage de pouvoir récupérer côté serveur l’adresse email de la personne cherchant à configurer son compte. Ainsi il sera possible de générer un fichier xml personnalisé qui contiendra son login de messagerie. En effet, il est possible que, pour l’adresse toto@domaine.com, le login à utiliser ne soit pas toto mais un login tout autre.
La solution que nous allons implémenter permet de rechercher le login associé à l’adresse toto@domaine.com soit dans un annuaire ldap soit dans une base mysql (ou d’utiliser toto tout simplement).

Les autres solutions ne fournissent qu’une configuration « générale » dans lequel l’identifiant de messagerie ne peut être que soit l’adresse mail complète, soit la partie située avant l’arobase dans l’adresse.

Tout d’abord il faut créer un enregistrement DNS autoconfig.domaine.com. pointant vers un serveur hébergeant une solution apache+php.

Considérons que le serveur apache+php soit installé sous Centos 5. Il nous faut créer un vhost autoconfig.domaine.com. Par exemple :

<VirtualHost *:80>
        ServerName      autoconfig.domaine.com
        ServerAdmin     root@domaine.com
        DocumentRoot    /var/www/html/autoconfig/
</VirtualHost>

Dans le fichier  /etc/httpd/conf.d/php.conf modifions la ligne :

AddHandler php5-script .php .xml

Sous /var/www/html/autoconfig, mettons en place un répertoire nommé mail et téléchargeons à l’intérieur de ce répertoire le script de configuration :

mkdir -p /var/www/html/autoconfig/mail/
cd /var/www/html/autoconfig/mail/
wget http://be-root.com/downloads/autoconfig/config-v1.1.xml

Modifiez les variables présentes au début de ce script en fonction de votre configuration et redémarrez votre serveur apache.

En allant à l’url  http://autoconfig.domaine.com/mail/config-v1.1.xml avec un navigateur, vous devriez voir apparaître le code xml contenant les balises <username>%EMAILLOCALPART%</username>.

Si vous avez défini un driver (ldap ou mysql) pour faire une correspondance entre l’adresse email d’un utilisateur et son login, alors, en allant à l’url http://autoconfig.domaine.com/mail/config-v1.1.xml?emailaddress=utilisateur.existant@domaine.com
vous devriez voir une balise <username>login_utilisateur</username>.

Si cette étape fonctionne correctement, alors, lorsque vous configurerez votre compte sous Thunderbird, la configuration des serveurs pop/imap/smtp se fera alors correctement.

 

Création d’un VPN avec OpenVPN sous Centos 5

Dans cet article, nous allons créer un point d’accès vpn chargé de router l’ensemble du trafic des clients vpn.
Le système retenu pour créer ce point d’accés est une machine sous Centos 5 sur laquelle nous allons installer le logiciel OpenVPN.

Installation du serveur vpn :

Nous considérons que la machine est déjà installée sous Centos 5 et que les outils de développement y sont également installés (autoconf, automake, gcc, …). SELinux ainsi que IPtables sont désactivés.

Tous d’abord, nous allons installer la librairie lzo (téléchargeable en version 2.04 depuis ici, permettant de compresser en temps réel les flux qui transiteront par le tunnel :

[root@vador sources]# tar zxf lzo-2.04.tar.gz
[root@vador sources]# cd lzo-2.04
[root@vador lzo-2.04]# ./configure --prefix=/usr && make && make install

Nous pouvons ensuite installer openvpn depuis les sources, téléchargeables depuis le site officiel :

[root@vador sources]# tar zxf openvpn-2.1.4.tar.gz
[root@vador sources]# cd openvpn-2.1.4
[root@vador openvpn-2.1.4]# ./configure --prefix=/usr --sysconfdir=/etc/openvpn
[root@vador openvpn-2.1.4]# make && make install
[root@vador openvpn-2.1.4]# cp sample-scripts/openvpn.init /etc/init.d/
[root@vador openvpn-2.1.4]# chmod +x /etc/init.d/openvpn.init
[root@vador openvpn-2.1.4]# cd plugin/auth-pam/
[root@vador openvpn-2.1.4]# make
[root@vador auth-pam]# mkdir /usr/lib/openvpn
[root@vador auth-pam]# cp openvpn-auth-pam.so /usr/lib/openvpn/

Nous allons ensuite générer les certificats :

[root@vador auth-pam]# cd ../..
[root@vador openvpn-2.1.4]# cd easy-rsa/2.0/
[root@vador 2.0]# vi vars
[root@vador 2.0]# . ./vars
[root@vador 2.0]# ./clean-all
[root@vador 2.0]# ./build-ca
[root@vador 2.0]# ./build-key-server server
[root@vador 2.0]# ./build-dh
[root@vador 2.0]# mkdir -p /etc/openvpn/keys
[root@vador 2.0]# cp keys/ca.crt /etc/openvpn/keys/
[root@vador 2.0]# cp keys/ca.key /etc/openvpn/keys/
[root@vador 2.0]# cp keys/server.crt /etc/openvpn/keys/
[root@vador 2.0]# cp keys/server.key /etc/openvpn/keys/
[root@vador 2.0]# cp keys/dh1024.pem /etc/openvpn/keys/

Le fichier ca.crt sera a distribuer sur les clients.
Créons le fichier de configuration d’OpenVPN /etc/openvpn/openvpn.conf :

port 1194
proto udp
dev tun0

ca /etc/openvpn/keys/ca.crt
cert /etc/openvpn/keys/server.crt
key /etc/openvpn/keys/server.key
dh /etc/openvpn/keys/dh1024.pem


server 10.8.0.0 255.255.255.0
ifconfig-pool-persist ipp.txt

client-to-client

keepalive 10 120

comp-lzo
max-clients 100

user nobody
group nobody

# of the privilege downgrade.
persist-key
persist-tun

status /var/log/openvpn-status.log
log-append  /var/log/openvpn.log

verb  4

client-cert-not-required
plugin /usr/lib/openvpn/openvpn-auth-pam.so login

push "redirect-gateway def1"
push "dhcp-option DNS xxx.xxx.xxx.xxx"  #Optionnel : Adresse IP du serveur dns 

Ainsi configuré, OpenVPN écoutera sur le port 1194/udp et l’authentification se fera via login/mot de passe grace aux PAM. Ainsi, chaque utilisateur ayant un compte sur la machine pourra se connecter au VPN.
Il est possible d’aller plus loin en configurant les pam pour aller chercher les informations dans un annuaire LDAP par exemple.
La directive push « redirect-gateway def1 » permet de rediriger l’ensemble du trafic des clients via le VPN.
verb 4 pourra être diminué par la suite afin de rendre les logs moins volumineux.

[root@vador openvpn]# touch /var/log/openvpn.log
[root@vador openvpn]# touch /var/log/openvpn-status.log
[root@vador openvpn]# chown nobody:nobody /var/log/openvpn*.log

Nous pouvons ensuite demarrer openvpn grace à la commande :

/etc/init.d/openvpn.init start

Créons ensuite le script /etc/rc.d/rc.firewall qui permettra de masquerader le traffic provenant de l’interface virtuelle tun0.

#!/bin/sh
/sbin/modprobe iptable_nat
/sbin/modprobe ip_nat_ftp
echo 1 > /proc/sys/net/ipv4/ip_forward
/sbin/iptables -F FORWARD
/sbin/iptables -F INPUT
/sbin/iptables -A FORWARD -s 10.8.0.0/24 -j ACCEPT
/sbin/iptables -A FORWARD -i tun0 -o eth0 -j ACCEPT
/sbin/iptables -A INPUT -s 10.8.0.0/24 -j ACCEPT
/sbin/iptables -t nat -A POSTROUTING -s 10.8.0.0/24 -j MASQUERADE

Rendons le exécutable avec la commande :

chmod +x /etc/rc.d/rc.firewall

et nous pouvons modifier le fichier /etc/rc.local afin que rc.firewall soit lancé au démarrage de la machine.
La configuration du point d’accés et désormais terminée. Il faut juste s’assurer que le port 1194/udp est ouvert pour les clients.

Configuration d’un client vpn sous linux :

Pour cet exemple, nous allons configurer un client fonctionnant sous Ubuntu. Installons le plugin openvpn pour le networkmanager :

sudo apt-get install network-manager-openvpn-gnome

Il faut ensuite redemarrer le network-manager (ou la machine pour les plus fénéants 🙂 ).

Sur l’applet de configuration de réseau, nous choisissons « Configurer le VPN » :

La passerelle est l’adresse IP de notre serveur OpenVPN.
Le certificat du ca est le fichier ca.crt récupéré du répertoire /etc/openvpn/keys sur le serveur.

Cliquer sur « Avancé » et activer la compression lzo :

Après activation du vpn, à l’aide de la commande traceroute, nous voyons bien que le traffic passe par le vpn (10.8.0.1) :

Configuration d’un client vpn sous windows :

Il faut installer le logiciel Openvpn-GUI disponible ici. Installer le pilote
TAP-Win32 (soit depuis l’installation, soit depuis le menu demarrer->openvpn).

Dans le répertoire c:\program files\openvpn\config, placer le fichier ca.crt récupéré sur le serveur.

Éditer un fichier c:\program files\openvpn\config\client.ovpn :

### Client configuration file for OpenVPN
client
dev tun
remote 192.168.0.10 1194   # Adresse & port du serveur openvpn
proto udp
nobind
resolv-retry infinite
persist-key
persist-tun
ca ca.crt
cipher BF-CBC
comp-lzo
verb 3
auth-user-pass
route-method exe
route-delay 2

La connexion au vpn se fait par un clic droit sur l’icone openvpn dans la zone de notification et en cliquant sur connect.