apt-get install mumble-server
dpkg-reconfigure mumble-server

Options choisies :

• oui la priorité du processus pour une meilleur latence ;
• un mot de passe pour SuperUser.

Mettre le mot de passe dans le password-store à Superuser.

Le fichier de configuration est /etc/mumble.ini.

Modification du fichier /etc/mumble.ini :

welcometext="<br/>Bienvenue sur le serveur Mumble du Chapril – https://www.chapril.org/.<br/>                                                                                                                                                                      
users=200                                                                                                                                                                                                                                                          
registerName=Chapril

Sur maine et coon :

• créer le fichier /etc/firehol/services/mumble.conf :

#FHVER: 1:213
# La premiere ligne ci dessus est nécessaire !!
server_mumble_ports="tcp/64738 udp/64738"
client_mumble_ports="default"

• dans /etc/firehol/firehol.conf :

  ["mumble"]='("64738" "tcp udp" "192.168.1.64" "2a01:4f8:10b:c41::64" "2a01:4f8:10b:c42::64")'

Redémarrer Firehol sur maine et coon :

systemctl restart firehol.service 

Sur la vm allo :

• créer le fichier /etc/firehol/services/mumble.conf :

#FHVER: 1:213
# La premiere ligne ci dessus est nécessaire !!
server_mumble_ports="tcp/64738 udp/64738"
client_mumble_ports="default"

• dans le fichier /etc/firehol/firehol-ext2me.conf, ajouter :

    server mumble accept

• dans le fichier /etc/firehol/firehol.conf, compléter avec :

[…]
# Trafic interne au cluster                                                                                                                                                                                                                                           
# The purpose of this interface is to control the traffic                                                                                                                                                                                                             
# on the ens3 interface with IP 192.168.1.30 (net: "192.168.1.0/24 ").                                                                                                                                                                                                
# on cible les interfaces ens3+ens8 pour mutualiser les regles ipv4 et ipv6                                                                                                                                                                                           
interface "ens3 ens8" internal_trafic src4 "192.168.1.0/24 " dst4 192.168.1.64 src6 "2a01:4f8:10b:c41::/64 2a01:4f8:10b:c42::/64" dst6 "2a01:4f8:10b:c41::64 2a01:4f8:10b:c42::64"
[…]
# Trafic externe au cluster                                                                                                                                                                                                                                           
# The purpose of this interface is to control the traffic                                                                                                                                                                                                             
# from/to unknown networks behind the default gateway 192.168.1.5 .                                                                                                                                                                                                   
# on cible les interfaces ens3+ens8 pour mutualiser les regles ipv4 et ipv6                                                                                                                                                                                           
interface "ens3 ens8" external_trafic src4 not "${UNROUTABLE_IPV4} 192.168.1.0/24 " dst4 192.168.1.64 src6 not "${UNROUTABLE_IPV6} 2a01:4f8:10b:c41::/64 2a01:4f8:10b:c42::/64" dst6 "2a01:4f8:10b:c41::64 2a01:4f8:10b:c42::64"
[…]

Redémarrer Firehol :

systemctl restart firehol.service 

À cette étape, le serveur Mumble est joignable à condition d'accepter le certificat.

Informations de connexion :

• adresse : mumble.chapril.org
• port : 64738 (celui par défaut)
• nom d'utilisateur : monpseudo
• nom : Chapril

Marche à suivre :

• se connecter en tant que Superuser ;
• bouton droit sur la racine puis modifier ;
• onglet CLA ;
• sélectionner @all non italique ;
• cocher la colonne Autoriser pour la ligne Créer des temporaires ;
• cliquer sur OK.

Par défaut, il est possible d'utiliser un certificat auto-signé. Mais alors une boite de dialogue technique apparaît et demande une confirmation. Cela représente une barrière aux utilisateurs. Donc l'utilisation d'un certificat validé par une autorité reconnue est la bienvenue.

apt install dehydrated dnsutils ntp

Temporairement, le temps de tester la configuration on va utiliser le serveur ACME de staging.

echo 'CA="https://acme-staging-v02.api.letsencrypt.org/directory"' > /etc/dehydrated/conf.d/staging.sh

On configure dehydrated pour faire de la validation DNS-01 dans le fichier /etc/dehydrated/conf.d/auth-dns.sh :

/etc/dehydrated/conf.d/auth-dns.sh

CHALLENGETYPE="dns-01"
HOOK=/etc/dehydrated/hook-custom-chapril.sh

On va maintenant créer le script hook /etc/dehydrated/hook-custom-chapril.sh. C'est lui qui est chargé de pousser des changements dans la zone DNS dynamique _acme-challenge.chapril.org à l'aide de la commande nsupdate. Attention les paramètres passés à la commande nsupdate sont ici spécifiques à chapril.

Et la valeur de la variable KEY est ici évidemment fausse. La bonne valeur à utiliser se trouve sur le serveur DNS chapril dans le fichier /etc/bind/rndc-acme.key.

/etc/dehydrated/hook-custom-chapril.sh

#!/usr/bin/env bash
 
set -e
set -u
set -o pipefail
 
DNSSERVER="dns.cluster.chapril.org"
KEY="hmac-sha512:rndc-acme cmF0YXBvaWwgdWd1c3NlCg=="
NSUPDATE="nsupdate"
TTL=300
 
case "$1" in
    "deploy_challenge")
        printf "key %s\nserver %s\nupdate add _acme-challenge.%s. %d in TXT \"%s\"\nsend\n" "${KEY}" "${DNSSERVER}" "${2}" "${TTL}" "${4}" | $NSUPDATE
        ;;
    "clean_challenge")
        printf "key %s\nserver %s\nupdate delete _acme-challenge.%s. %d in TXT \"%s\"\nsend\n" "${KEY}" "${DNSSERVER}" "${2}" "${TTL}" "${4}" | $NSUPDATE
        ;;
 
    "deploy_cert")
        # Reloading mumble is not possible, so we restart it :(
        /bin/systemctl restart mumble-server
        ;;
 
    "unchanged_cert")
        # do nothing for now
        ;;
 
    "startup_hook")
        # do nothing for now
        ;;
 
    "exit_hook")
        # do nothing for now
        ;;
 
esac
 
exit 0

Il faut rendre ce script exécutable :

chmod +x /etc/dehydrated/hook-custom-chapril.sh

On indique le ou les domaines qu’on souhaite dans /etc/dehydrated/domains.txt :

chapril.org *.chapril.org

La première fois :

dehydrated --register --accept-terms

Puis on génère ou régénère les certificats :

dehydrated -c

Si tout s’est bien passé, alors pour peut générer un vrai certificat cette fois. Il faut donc supprimer le fichier /etc/dehydrated/conf.d/staging.sh, forcer la création d’un nouveau compte ACME et forcer le renouvellement du certificat pour écraser le certificat de test qu’on vient de créer.

rm /etc/dehydrated/conf.d/staging.sh
dehydrated --register --accept-terms
dehydrated -c --force

Il faut maintenant automatiser le renouvellement des certificats avec une tâche cron. On créé le fichier /etc/cron.weekly/acme-renew suivant :

/etc/cron.weekly/acme-renew

#! /bin/bash
/usr/bin/dehydrated -c

Puis on le rend exécutable :

chmod +x /etc/cron.weekly/acme-renew

Créer le dossier des logs Nginx :

mkdir /var/log/nginx/mumble.chapril.org/

Actions :

• créer le fichier de configuration web /etc/nginx/sites-available/mumble.chapril.org :
  • s'appuyer sur un fichier déjà existant, par exemple drop.chapril.org ;
  • remplacer drop par mumble ;
  • neutraliser la partie SSL ;
  • neutraliser la partie redirection SSL ;
• créer un lien vers ce fichier dans /etc/nginx/sites-enable/ ;
• ajouter mumble.chapril.org dans /etc/dehydrated/domains.txt ;
• lancer dehydrated -c pour générer les certifcats ;
• réactiver la redirection SSL et la partie SSL dans le fichier web.

Par défaut, aucun salon n'est présent.

Pour créer des salons :

• se connecter avec :
  • adresse : mumble.chapril.org
  • port : 64738 (celui par défaut)
  • nom d'utilisateur : Superuser
  • nom : Chapril-SU
• dans l’arborescence des salons :
  • cliquer bouton droit sur « root »
  • cliquer sur « Ajouter… »
  • remplir le formulaire
  • …

Mumble-web peut être installé en mode standalone ou proxied. Pour le Chapril, le mode proxied a été retenu car il permet :

• une gestion du certificat web sur notre vm bastion ;
• la génération de log HTTP pour suivre la fréquentation du service.

Voici le chemin romancé des requêtes :

• côté utilisateur :
  • Mumble-web consiste en des fichiers statiques : HTML, Javascript et images,
  • une fois ces fichiers chargés dans le navigateur depuis https://mumble.chapril.org/, le code Javascript ouvre un flux Webrtc,
  • le fichier config.local.js de Mumble-web contient une adresse spéciale pour le flux web :
    • config.defaults.address = 'mumble.chapril.org/ws';
  • donc le navigateur de l'utilisateur ouvre deux flux : un flux web statique et un flux Webrtc,

• Nginx sur la vm bastion :
  • tout le trafic web du SI Chapril passe par un bastion web,
  • les deux flux arrivent sur le même Nginx,
  • c'est à ce niveau là qu'est géré le certificat web,
  • ensuite tout est envoyé au Nginx de la vm allo sans chiffrement,

• Nginx sur la vm allo :
  • les deux flux arrivent sur le même Nginx,
  • si le chemin de requête est / alors :
    • on sert les pages web demandées,
  • si le chemin demandé est /ws alors :
    • on redirige vers le port 64737 du processus websockify

• Websockify sur la vm allo :
  • lancé en tâche de fond via Systemd,
  • lit tout ce qui arrive sur le port 64737,
  • redirige tout vers le port 64738 (c'est celui de notre serveur Mumble),
  • s'occupe de rediriger correctement les réponses,

• serveur Mumble :
  • traite toutes les connexions sur le port 64738.

Gère le certificat SSL. Redirige en proxy vers la vm allo.

server {
    listen 80;
    listen [::]:80;
 
    server_name mumble.chapril.org; 
 
    access_log /var/log/nginx/mumble.chapril.org/mumble.chapril.org.access_log;
    error_log /var/log/nginx/mumble.chapril.org/mumble.chapril.org.error_log;
 
    include /etc/nginx/acme-challenge;
    include /etc/nginx/sexy-chapril;
    include /etc/nginx/force-ssl.conf;
}

server {
    listen 443 ssl;
    listen [::]:443 ssl;
 
    server_name mumble.chapril.org;
 
    access_log /var/log/nginx/mumble.chapril.org/mumble.chapril.org.access_log;
    error_log /var/log/nginx/mumble.chapril.org/mumble.chapril.org.error_log;
 
    ssl_certificate     /var/lib/dehydrated/certs/mumble.chapril.org/fullchain.pem;
    ssl_certificate_key /var/lib/dehydrated/certs/mumble.chapril.org/privkey.pem;
 
    include /etc/nginx/acme-challenge;
    include /etc/nginx/sexy-chapril;
    #include /etc/nginx/chapril-banner-location;

    location / {
        proxy_http_version      1.1;
        proxy_set_header        Upgrade $http_upgrade;
        include proxy_params;
        proxy_pass http://allo.cluster.chapril.org;
    }
}

Installation de npm :

apt-get install npm

Oui, ça installe 251 paquets node-*…

Clonage :

cd /srv/mumble.chapril.org
git clone https://github.com/johni0702/mumble-web
cd mumble-web
npm install
npm run build

Note : pour le premier déploiement, on a utilisé le commit 9945bc5f767eafb0fb82040c4ab38ecf24d99cbc.

Créer la branche officielle :

mkdir /var/www/mumble.chapril.org/
cd /var/www/mumble.chapril.org/
git init .
cp -a /srv/mumble.chapril.org/mumble-web/dist/* .
chown -R www-data /var/www/mumble.chapril.org/
git add .
git commit -m "Build 9945bc5f7"

Créer la branche Chapril :

cd /var/www/mumble.chapril.org/
git branch chapril-9945bc5f7
git checkout chapril-9945bc5f7

Paramétrer le fichier /var/www/mumble.chapril.org/config.local.js :

echo "config.settings.address     = 'mumble.chapril.org/ws';" >> config.local.js
git add -p
git commit -m "First settings."

Installation de websockify :

apt install websockify

Configuration systemd :

[Unit]
Description=Mumble web interface
Documentation=https://github.com/johni0702/mumble-web
Requires=network.target mumble-server.service
After=network.target mumble-server.service

[Service]
Type=simple
User=www-data
ExecStart=/usr/bin/websockify --ssl-target localhost:64737 localhost:64738

[Install]
WantedBy=multi-user.target

Activation :

systemctl daemon-reload
systemctl start mumble-web
systemctl enable mumble-web

Créer les fichiers Nginx :

touch /etc/nginx/sites-available/mumble.chapril.org
ln -s /etc/nginx/sites-available/mumble.chapril.org etc/nginx/sites-enabled/

Remplir le fichier :

server {
        listen 80;
        server_name mumble.chapril.org;

        access_log /var/log/nginx/mumble.chapril.org/mumble.chapril.org-access.log;
        error_log /var/log/nginx/mumble.chapril.org/mumble.chapril.org-error.log;

        location / {
                root /var/www/mumble.chapril.org/;
        }

        location /ws {
                proxy_pass http://localhost:64737;
                proxy_http_version 1.1;
                proxy_set_header Upgrade $http_upgrade;
                proxy_set_header Connection $connection_upgrade;
        }
}

map $http_upgrade $connection_upgrade {
        default upgrade;
        '' close;
}

Éditer le fichier /var/www/mumble.chapril.org/config.local.js :

config.connectDialog.address  = false;
config.connectDialog.port     = false;
config.connectDialog.token    = false;
config.connectDialog.password = false;
config.connectDialog.channel  = false;

config.settings.voiceMode     = 'ptt';
config.settings.joinDialog    = true;

TODO

TODO

TODO

Éditer le fichier /var/www/mumble.chapril.org/index.html :

TODO

Les fichiers de Mumble-web sont statiques.

Builder les fichiers :

cd /srv/mumble.chapril.org/mumble-web
git fetch --all 
npm install
npm run build

Désactiver mumble-web :

rm /etc/nginx/sites-enabled/mumble.chapril.org
systemctrl restart nginx

Intégrer la nouvelle version :

cd /var/www/mumble.chapril.org/
git checkout master
git branch master-hashducommit
rm -f *
cp -a /srv/mumble-chapril.org/dist/* .
chown -R www-data .
git add .
git commit -m "Build hashducommit"
git checkout chapril-derniereversion
git merge master-hashducommit

Ré-activer mumble-web :

ln -s /etc/nginx/sites-available/mumble.chapril.org /etc/nginx/sites-enabled/
systemctrl restart nginx