Relution Shield (Add-on)

Relution Shield permet un accès sécurisé à l’intranet interne de l’organisation depuis l’internet et combine le réseau privé virtuel (VPN), l’infrastructure à clé publique (PKI) et l’UEM - MDM. Pour plus d’informations : Relution Shield →.

Conditions préalables

Serveur Relution

Le serveur d’application Relution existant sur lequel Relution Shield est configuré et les profils VPN des appareils sont gérés.

Serveur Relution (version 5.26+)
Une organisation cible sur le serveur avec une licence Relution Shield

Serveur Relution Shield

Un serveur séparé sur lequel Relution Shield est installé en tant que composant VPN.

Ubuntu 22.04+ (vérifier la version : lsb_release -a)
Les ports UDP 500 et 4500 doivent être libres et accessibles depuis Internet (configurés à l’étape 5 de la configuration du pare-feu, vérifier le statut : sudo ufw status verbose)
Trafic sortant vers toutes les cibles qui doivent être protégées par Relution Shield.
Le serveur Relution Shield DOIT être disponible sur Internet.
Recommandé : entrée DNS publique

Préparer Relution

Créer un nouveau rôle d’autorisation avec l’autorisation Relution Shield Access Check.
Créer un nouvel utilisateur sans mot de passe dans l’organisation cible
Attribuer le rôle à l’utilisateur
Créer une clé d’accès API pour l’utilisateur

Relution Shield Server

Paramètres requis

Relution Host: Nom d’hôte du serveur Relution, par exemple yourserver.relution.io
Clé API de Relution: Voir l’étape précédente (création d’un utilisateur)
VPN CIDR: La plage d’adresses IP privées à partir de laquelle Relution Shield attribue une adresse IP interne aux appareils connectés, par exemple 10.1.0.0/16. Cette plage ne doit pas chevaucher le réseau existant.
Interface réseau: Nom de l’interface réseau à utiliser pour Relution Shield, par exemple eth0.
Relution Shield Host: Nom de l’hôte de Relution Shield, par exemple vpn.yourserver.relution.io
Serveurs DNS: Les adresses IP des serveurs DNS internes du réseau, par exemple 10.1.0.1,10.1.0.2. Celles-ci sont communiquées aux appareils connectés afin que les noms d’hôtes internes (p. ex. ressources intranet) puissent être résolus. Si aucun serveur DNS interne n’est disponible, des serveurs DNS publics (p. ex. 8.8.8.8) peuvent être utilisés — les noms d’hôtes internes ne seront alors pas résolvables.

Installation

L’installation de Relution Shield est exigeante et demande de l’attention et du temps. Porter également une attention particulière aux variables qui doivent être définies. Vérifier les commandes et les configurations avant de les enregistrer.

Exécuter sudo apt update && upgrade
Installer Docker, y compris docker compose : https://docs.docker.com/engine/install/ubuntu/ (Ne pas installer via snap)
Créer un répertoire d’installation et un répertoire de conformité
```
mkdir -p /opt/relution-shield/compliance
```

Créer le fichier d’environnement /opt/relution-shield/.env – remplacer <%Relution Host%> par le nom d’hôte réel, p. ex. RELUTION_HOSTNAME=mdm.mondomaine.fr

touch /opt/relution-shield/.env
vi /opt/relution-shield/.env

RELUTION_HOSTNAME=<%Hôte de Relution%>
REST_API_ACCESS_TOKEN=<jeton d'accès généré ci-dessus>

Configurer le pare-feu Ubuntu ufw

Changer la politique de transfert par défaut dans /etc/default/ufw en DEFAULT_FORWARD_POLICY="ACCEPT".
```
vi /etc/default/ufw
```
Autoriser SSH et les ports UDP requis
```
ufw allow ssh
ufw allow 500,4500/udp
```

Ajuster /etc/ufw/before.rules. Ajouter les lignes suivantes au début du fichier, avant les lignes contenant *filter (s’assurer de remplacer <%VPN CIDR%> et <%Network interface%> - chaque valeur 3 fois) :

vi /etc/ufw/before.rules

# Relution Règles supplémentaires du bouclier de relution
*nat
-A POSTROUTING -s <%VPN CIDR%> -o <%Network interface%> -m policy --pol ipsec --dir out -j ACCEPT
-A POSTROUTING -s <%VPN CIDR%> -o <%Network interface%> -j MASQUERADE
COMMIT

*mangle
-A FORWARD --match policy --pol ipsec --dir in -s <%VPN CIDR%> -o <%Network interface%> -p tcp -m tcp --tcp-flags SYN,RST SYN -m tcpmss --mss 1361:1536 -j TCPMSS --set-mss 1360
COMMIT

# Ne supprimez pas ces lignes obligatoires, sinon il y aura des erreurs
*filtre
...

Ajuster /etc/ufw/before.rules. Ajouter les lignes suivantes au début du fichier, après les lignes contenant *filter (s’assurer de remplacer <%VPN CIDR%>) :

...
# Fin des lignes obligatoires

# Relution Règles supplémentaires du bouclier
-A ufw-before-forward --match policy --pol ipsec --dir in --proto esp -s <%VPN CIDR%> -j ACCEPT
-A ufw-before-forward --match policy --pol ipsec --dir out --proto esp -d <%VPN CIDR%> -j ACCEPT

Ajuster /etc/ufw/sysctl.conf, ajouter les lignes suivantes à la fin :

vi /etc/ufw/sysctl.conf

# Configuration du noyau de la redirection IPv4 du bouclier de relution
net/ipv4/ip_forward=1
net/ipv4/conf/all/accept_redirects=0
net/ipv4/conf/all/send_redirects=0
net/ipv4/ip_no_pmtu_disc=1

Redémarrer le pare-feu Ubuntu
```
ufw disable && ufw enable
```

Préparer la configuration du Relution Shield

Créer les répertoires des fichiers de configuration

mkdir -v -p /opt/relution-shield/etc/ipsec.d/{aacerts,acerts,cacerts,certs,crls,ocspcerts,private}

Créer les certificats et les clés nécessaires (s’assurer de remplacer <%Relution Shield Host%>)

cd /opt/relution-shield
# Créer les répertoires montés
mkdir -v -p pki/{cacerts,certs,private}
docker run -ti --volume "$(pwd)/pki:/opt/pki" relution/relution-shield:latest bash

# Maintenant dans le conteneur docker
cd /opt

# Créer la clé privée de l'AC
pki --gen --type rsa --size 4096 --outform pem > pki/private/ca-key.pem

Une ligne s’affiche dans le terminal (plugin ’tpm’ : failed to load…), ce qui indique que le plugin TPM est manquant. Ce message peut être ignoré. Ce n’est pas une erreur.

# Créer un certificat
pki --self --ca --lifetime 3650 --in pki/private/ca-key.pem \N-types rsa --dn "pki/private/ca-key.pem".
    --type rsa --dn "CN=ca.<%Relution Shield Host%>" --outform pem > pki/cacerts/ca-cert.pem

# Générer la clé du serveur, signée par l'autorité de certification
pki --gen --type rsa --size 4096 --outform pem > pki/private/server-key.pem

# Générer un certificat, signé par l'autorité de certification
pki --pub --in pki/private/server-key.pem --type rsa \N--pub --in pki/private/server-key.pem --type rsa \N--pub
    | pki --issue --lifetime 1825 \N- --cacert pki/cacer.com
        --cacert pki/cacerts/ca-cert.pem \N- --cakey pki/private/server-key.pem -type rsa
        --cakey pki/private/ca-key.pem \N--cacert pki/cacerts/ca-cert.pem
        --dn "CN=<%Relution Shield Host%>" --san "<%Relution Shield Host%>" \
        --flag serverAuth --flag ikeIntermediate --outform pem \N- --flag serverAuth --flag ikeIntermediate
    > pki/certs/server-cert.pem

# Préparer l'archive de la paire de clés, qui sera nécessaire pour Relution plus tard
openssl pkcs12 -export -out "pki/ca.<%Relution Shield Host%>.p12" -inkey pki/private/ca-key.pem -in pki/cacerts/ca-cert.pem

# Quitter le conteneur docker
exit

Déplacer les fichiers de certificats aux endroits appropriés

mv pki/private/ca-key.pem /opt/relution-shield/etc/ipsec.d/private/ca-key.pem
mv pki/cacerts/ca-cert.pem /opt/relution-shield/etc/ipsec.d/cacerts/ca-cert.pem
mv pki/private/server-key.pem /opt/relution-shield/etc/ipsec.d/private/server-key.pem
mv pki/certs/server-cert.pem /opt/relution-shield/etc/ipsec.d/certs/server-cert.pem

Créer le fichier d’authentification du serveur /opt/relution-shield/etc/ipsec.secrets
```
RSA "server-key.pem"
```
Créer le fichier de configuration /opt/relution-shield/etc/strongswan.conf

Show full configuration example

# strongswan.conf - fichier de configuration de strongSwan
#
# Se référer à la page de manuel strongswan.conf(5) pour plus de détails
#
# Les changements de configuration doivent être effectués dans les fichiers inclus

charon {
    load_modular = yes

    threads = 64

    processeur {
        priorité_threads {
          élevée = 2
          moyenne = 8
        }
    }

    filelog {
        stdout {
            default = 0
            enc = 0
        }
    }

    plugins {
        include strongswan.d/charon/*.conf

        bypass-lan {
            interfaces_use = lo
        }

    }
}

Créer le fichier de configuration /opt/relution-shield/etc/ipsec.conf (s’assurer de remplacer <%Relution Shield Host%>, <%VPN CIDR%>, <%Relution Host%> et<%DNS Servers%>`).

Show full configuration example

# see <https://wiki.strongswan.org/projects/strongswan/wiki/Ipsecconf>
config setup
    uniqueids=no

# voir <https://wiki.strongswan.org/projects/strongswan/wiki/ConnSection>
conn %default
    dpdaction=clear
    # DPD désactivé depuis IKEv2
    dpddelay=0s
    fragmentation=yes
    mobike=oui
    compress=oui

conn <%Relution Shield Host%>-base
    keyexchange=ikev2
    left=%any
    leftauth=pubkey
    lefttid=<%Relution Shield Host%>
    leftca=ca-cert.pem
    leftcert=server-cert.pem
    leftsendcert=toujours
    leftsubnet=0.0.0.0/0
    leftfirewall=yes
    right=%any
    rightsourceip=<%VPN CIDR%>
    rightdns=<%DNS Servers%>
    type=tunnel
    auto=add
    forceencaps=yes
    reauth=oui
    rekey=oui
    eap_identity=%identity
    ike=chacha20poly1305-sha512-curve25519-prfsha512,aes256gcm16-sha384-prfsha384-ecp384,aes256-sha384-modp4096,aes256-sha256-modp4096,aes256-sha384-ecp384!
    esp=chacha20poly1305-sha512,aes256gcm16-ecp384,aes256-sha256,aes256-sha384-modp4096,aes256-sha256-modp4096,aes256-sha384-ecp384!

conn <%Relution Shield Host%>-eaptls
    also=<%Relution Shield Host%>-base
    rightauth=eap-tls
    rightid="%*@<%Relution Host%>"
    rightca=ca-cert.pem
    rightsendcert=toujours

conn <%Relution Shield Host%>-eaptls-windows
    also=<%Relution Shield Host%>-base
    rightauth=eap-tls
    rightid=%any
    rightca=ca-cert.pem
    rightsendcert=toujours

Installer Relution Shield via docker

Créer /opt/relution-shield/compose.yml

services:
  relution-shield:
    image: relution/relution-shield:latest
    restart: unless-stopped
    cap_add:
      - NET_ADMIN
      - NET_RAW
      - SYS_MODULE
    network_mode: host
    ports:
      - 500:500/udp
      - 4500:4500/udp"
    environnement:
      RELUTION_HOSTNAME: ${RELUTION_HOSTNAME}
      REST_API_ACCESS_TOKEN: ${REST_API_ACCESS_TOKEN}
    volumes:
      - "/dev/net/tun:/dev/net/tun"
      - "./etc/ipsec.conf:/etc/ipsec.conf:ro"
      - "./etc/ipsec.d:/etc/ipsec.d:ro"
      - "./etc/ipsec.secrets:/etc/ipsec.secrets:ro"
      - "./etc/strongswan.conf:/etc/strongswan.conf:ro"
      - "/lib/modules:/lib/modules:ro"
      - "./compliance:/opt/strongswan/compliance"

Démarrer Relution Shield dans /opt/relution-shield via docker compose up -d
Redémarrer automatiquement Relution Shield après le redémarrage du daemon réseau (par exemple après des mises à jour automatiques), créer /etc/systemd/system/relution-shield-networkd-post-restarter.service
``ini [Unit] Requires=systemd-networkd.service After=systemd-networkd.service network-online.target
[Service] Type=oneshot ExecStart=docker compose -f /opt/relution-shield/compose.yml restart RemainAfterExit=yes
[Installation] WantedBy=multi-user.target
Démarrer le service via systemctl enable relution-shield-networkd-post-restarter --now

Configurer Relution

Configuration du certificat

Importer les certificats dans l’organisation cible
1. Naviguer vers Paramètres → Certificats
2. Télécharger le certificat dans /opt/relution-shield/etc/ipsec.d/cacerts/ca-cert.pem et lui donner un nom comme <%Relution Shield Host%> CA Certificate.
3. Télécharger le certificat dans /opt/relution-shield/etc/ipsec.d/certs/server-cert.pem et lui donner un nom comme <%Relution Shield Host%> Server Certificate
4. Télécharger l’archive PKCS12 dans /opt/relution-shield/pki/ca.<%Relution Shield Host%>.p12 et lui donner un nom comme <%Relution Shield Host%> CA Key Pair
Créer une autorité de certification et un modèle de certificat
1. Naviguer vers Paramètres → Autorités de certification
2. Ajouter une nouvelle autorité de certification de type Built-in et sélectionner le certificat <%Relution Shield Host%> CA Key Pair téléchargé précédemment.
3. Accéder à Settings → Certificate Templates (Paramètres → Modèles de certificats)
4. Ajouter un nouveau modèle de certificat
  1. Sélectionner l’autorité de certification créée précédemment
  2. Régler le Subject Name sur CN=${device.uuid}@<%Relution Host%> (noter le CN= au début).
  3. Dans le champ Utilisation de la clé de certificat, activer Signature et Cryptage de la clé
  4. Ajouter un Subject Alternative Name de type Email avec ${device.uuid}@<%Relution Host%> (Pas de CN= au début)
    Confirmer la valeur saisie en appuyant sur Entrée
  5. Activer le renouvellement automatique et définir les valeurs appropriées, par exemple 60 jours et 180 jours.

Exemple de configuration iOS

Créer une nouvelle politique iOS ou étendre une politique existante
Ajouter une configuration VPN
1. Sélectionner le type IKEv2
2. Activer Per App and Account VPN ( voir aussi Relution Hub Docs → )
3. Définir Server et Remote identifier à la valeur de <%Relution Shield Host%>
4. Définir Local identifier à ${device.uuid}@<%Relution Host%>
5. Définir Machine authentication sur Certificate et sélectionner le modèle de certificat créé précédemment.
6. Activer Enable extended authentication (EAP) (Activer l’authentification étendue (EAP))
7. Définir les paramètres IKE SA et Child SA à AES-256, SHA-256, DH group 16 : 4096-bit group, 1440 minutes.
8. Facultatif : Ajouter un domaine de test à Safari Domains ci-dessous pour activer automatiquement le VPN lorsque le domaine est accessible via Safari.
Ajouter une configuration Certificat à la politique et sélectionner le <%Relution Shield Host%> CA Certificate téléchargé auparavant.
Ajouter optionnellement une configuration App to VPN Mapping et sélectionner la configuration VPN créée précédemment et une autre application de navigateur comme Firefox ou Chrome pour tester l’accès VPN. Il est recommandé d’ajouter également une conformité d’application avec cette application pour s’assurer qu’elle est installée.
Publier la politique et l’assigner à un appareil. Le VPN peut maintenant être connecté manuellement via Paramètres → Général → VPN et gestion des appareils → VPN. Relution Shield sera également automatiquement connecté lors de l’accès aux domaines Safari configurés ci-dessus dans Safari ou lors de l’ouverture de l’application du navigateur.
Ajuster la configuration pour inclure les comptes, les applications et les domaines qui ne doivent être accessibles que via Relution Shield.

Exemple de configuration Android Enterprise

Créer une nouvelle politique Android Enterprise ou étendre une politique existante
Ajouter une configuration Profil VPN StrongSwan.
1. Sélectionner IKEv2 EAP-TLS comme Type de VPN.
2. Définir Server et Server identity à la valeur de <%Relution Shield Host%>
3. Définir User Certificate sur le modèle de certificat généré précédemment.
4. Définir le CA certificate sur le <%Relution Shield Host%> CA Certificate téléchargé précédemment.
5. Définir Client identity sur ${device.uuid}@<%Relution Host%>
6. Définir Only these Apps will use the VPN (Seules ces applications utiliseront le VPN) à un navigateur comme Firefox
Ajouter une configuration StrongSwan VPN Restrictions et sélectionner le profil VPN créé précédemment comme profil par défaut.
Publier la politique et l’assigner à un appareil. Le VPN peut maintenant être connecté manuellement via l’application StrongSwan. Relution Shield sera également automatiquement connecté lors de l’ouverture de l’application de navigation configurée précédemment.
Ajuster la configuration pour inclure les applications qui ne doivent être accessibles que via Relution Shield.

Customer Hub

Relution Shield (Add-on)

Conditions préalables #

Serveur Relution #

Serveur Relution Shield #

Préparer Relution #

Relution Shield Server #

Paramètres requis #

Installation #

Configurer Relution #

Configuration du certificat #

Exemple de configuration iOS #

Exemple de configuration Android Enterprise #