Bouclier de Relution (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é privée (PKI) et l’UEM - MDM. Pour plus d’informations : Relution Shield.

Conditions préalables

Serveur Relution

Serveur de Relution
Une organisation cible sur le serveur avec une licence Relution Shield

Serveur Relution Shield

Relution Server 5.26+
Ubuntu 22.04+ UDP ports 500 et 4500
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 souhaitée pour que Relution Shield attribue des IP internes, par exemple 10.1.0.0/16
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: Adresses IP des serveurs DNS internes, par exemple 10.1.0.1,10.1.0.2.

Installation

L’installation de Relution Shield est exigeante et demande de l’attention et du temps. Faites également attention aux variables qui doivent être définies. Vérifiez les commandes et les configurations avant de les enregistrer.

Exécutez 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éez le fichier d’environnement /opt/relution-shield/.env (assurez-vous de remplacer <%Relution Host%>)

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

Changez 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
```

Ajustez /etc/ufw/before.rules. Ajoutez les lignes suivantes au début du fichier, avant les lignes contenant *filter (assurez-vous 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
...

Ajustez /etc/ufw/before.rules. Ajoutez les lignes suivantes au début du fichier, après les lignes contenant *filter (assurez-vous 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

Ajustez /etc/ufw/sysctl.conf, ajoutez 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émarrez le pare-feu Ubuntu
```
ufw disable && ufw enable
```

Préparer la configuration du bouclier de Relution

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éez les certificats et les clés nécessaires (assurez-vous de remplacer <%Relution Shield Host%>)

# 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

# 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éez le fichier de configuration /opt/relution-shield/etc/ipsec.conf (assurez-vous de remplacer <%Relution Shield Host%>, <%VPN CIDR%>, <%Relution Host%> et <%DNS Servers%>`).

# 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émarrez 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émarrez 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échargez le certificat dans /opt/relution-shield/etc/ipsec.d/cacerts/ca-cert.pem et donnez-lui un nom comme ‘<%Relution Shield Host%> CA Certificate’.
3. Téléchargez le certificat dans /opt/relution-shield/etc/ipsec.d/certs/server-cert.pem et donnez-lui un nom comme ‘<%Relution Shield Host%> Server Certificate’
4. Téléchargez l’archive PKCS12 dans /opt/relution-shield/pki/ca.vpn.staging.relution.xyz.p12 et donnez-lui un nom comme ‘<%Relution Shield Host%> CA Key Pair’
Créer une autorité de certification et un modèle de certificat
1. Naviguez 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édez à “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églez le “Subject Name” sur CN=${device.uuid}@<%Relution Host%> (Notez le CN= au début).
  3. Activer “Signature” et “Cryptage de la clé”
  4. Ajouter un “Subect Alternative Name” de type “Email” avec ${device.uuid}@<%Relution Host%> (Pas de CN= au début)
  5. Activez le “renouvellement automatique” et définissez 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éfinissez “Server” et “Remote identifier” à la valeur de <%Relution Shield Host%>
4. Définissez “Local identifier” à ${device.uuid}@<%Relution Host%>
5. Définissez “Machine authentication” sur “Certificate” et sélectionnez le modèle de certificat créé précédemment.
6. Activer “Enable extended authentication (EAP)” (Activer l’authentification étendue (EAP))
7. Définissez 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.
Ajustez 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éfinissez “User Certificate” sur le modèle de certificat généré précédemment.
4. Définissez le “CA certificate” sur le “<%Relution Shield Host%> CA Certificate” téléchargé précédemment.
5. Définissez “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.

Bouclier de Relution (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 #