Relution Shield (Add-on)

Relution Shield ermöglicht einen sicheren Zugriff vom Internet auf das organisationsinterne Intranet und kombiniert Virtual Private Network (VPN), Public Key Infrastructure (PKI) und UEM - MDM. Weitere Informationen: Relution Shield →.

Für das Upgrade von Relution Shield 1.x siehe Migration von 1.x zu 2.x →

Voraussetzungen

Die Installation von Relution Shield ist anspruchsvoll und erfordert Aufmerksamkeit und Zeit. Befehle und Konfigurationen vor dem Speichern sorgfältig prüfen – besonders auf Variablen achten, die gesetzt werden müssen.

Relution Applikation Server

Der bestehende Relution Applikation Server, auf dem Relution Shield konfiguriert und die VPN-Profile für die Endgeräte verwaltet werden.

Relution-Server (Version 5.26+)
Eine Zielorganisation auf dem Server mit Relution Shield-Lizenz

Relution Shield Server

Ein separater Server, auf dem Relution Shield als VPN-Komponente installiert wird.

Ubuntu 22.04+
- Version prüfen: lsb_release -a
UDP Port 500 und 4500 müssen frei und von außen erreichbar sein
- Wird in Schritt 5 der Firewall-Einrichtung freigegeben
  Status prüfen: sudo ufw status verbose
Ausgehender Datenverkehr zu allen Zielen, die durch Relution Shield geschützt werden sollen
Ausgehender Datenverkehr via HTTPS zum Relution Server
Der Server muss vom Internet aus erreichbar sein
Empfohlen: Öffentlicher DNS-Eintrag
- z.B. vpn.meinedomain.de

Vorbereitung von Relution

Anlegen eines technischen Users und API-Access-Tokens

Neue Berechtigung mit der Rolle Relution Shield Zugangsprüfung erstellen: unter Home > Benutzer > Berechtigungen > Hinzufügen im Abschnitt Geräte den Punkt Relution Shield Zugangsprüfung aktivieren
Neuen Benutzer ohne Passwort (Passwortbasierte Authentifizierung deaktivieren) in der Zielorganisation erstellen
Wird der Benutzer in der Global-Organisation angelegt, kann Relution Shield Zugriffschecks für alle Organisationen auf dem Relution Server durchführen (Benötigt Relution Shield 2.0 oder neuer).
Dem Benutzer die neu erstellte Berechtigung zuweisen
API-Access-Token für den Benutzer erstellen und Gültigkeitsdauer deaktivieren
Benutzer speichern

Relution Shield Server

Erforderliche Parameter

Relution Host: Hostname des Relution-Servers
z.B. mdm.meinedomain.de
Relution API Token: Siehe vorheriger Schritt
Anlegen eines technischen Users und API-Access-Tokens →
VPN CIDR: Der private IP-Adressbereich, aus dem Relution Shield den verbundenen Geräten eine interne IP-Adresse zuweist, z.B. 10.1.0.0/16. Dieser Bereich darf sich nicht mit dem bestehenden Netzwerk überschneiden.
Network interface: Name der Netzwerkschnittstelle, die der Relution Shield Server verwendet, z.B. eth0 – prüfen via ip a
Relution Shield Host: Hostname von Relution Shield
z.B. vpn.meinedomain.de
DNS-Server: Die IP-Adressen der internen DNS-Server des Netzwerks, z.B. 10.1.0.1,10.1.0.2. Diese werden den verbundenen Geräten mitgeteilt, damit interne Hostnamen (z.B. Intranet-Ressourcen) aufgelöst werden können.

Installation

Folgenden Befehl ausführen:
```
sudo apt update && sudo apt upgrade
```
Docker inklusive docker-compose installieren (nicht via snap)
Docker Installationsanleitung →
Installationsverzeichnis und Compliance-Verzeichnis erstellen:
```
mkdir -p /opt/relution-shield/compliance
```
Umgebungsdatei /opt/relution-shield/.env erstellen:
```
touch /opt/relution-shield/.env
vi /opt/relution-shield/.env
```
Den Platzhalter <%Relution Host%> durch den tatsächlichen Hostnamen ersetzen, z.B. RELUTION_HOSTNAME=mdm.meinedomain.de
```
RELUTION_HOSTNAME=<%Relution Host%>
RELUTION_REST_API_ACCESS_TOKEN=<%Relution API Token%>
```
Wenn das API-Access-Token zu einem Benutzer aus der Global-Organisation gehört, muss der globale Scope für den Zugriffscheck aktiviert werden
(Benötigt Relution Shield 2.0 oder neuer):
```
RELUTION_ACCESS_CHECK_SCOPE=global
```

Ubuntu-Firewall ufw

Standard-Weiterleitungsrichtlinie in /etc/default/ufw auf DEFAULT_FORWARD_POLICY="ACCEPT" setzen:
```
vi /etc/default/ufw
```
```
DEFAULT_FORWARD_POLICY="ACCEPT"
```
SSH und die erforderlichen IPSec UDP-Ports freigeben:
```
ufw allow ssh
ufw allow 500,4500/udp
```

Folgende Zeilen am Anfang der Datei /etc/ufw/before.rules einfügen – vor den erforderlichen Zeilen, die *filter enthalten:

vi /etc/ufw/before.rules

# Relution Shield additional rules
*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

# Don't delete these required lines, otherwise there will be errors
*filter
...

<%VPN CIDR%> und <%Network interface%> an den drei Stellen ersetzen.

Folgende Zeilen am Ende der Datei /etc/ufw/before.rules einfügen – nach den erforderlichen Zeilen, die *filter enthalten:

vi /etc/ufw/before.rules

...
# End required lines

# Relution Shield additional rules
-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

<%VPN CIDR%> an zwei Stellen ersetzen.

Folgende Zeilen am Ende der Datei /etc/ufw/sysctl.conf einfügen:

vi /etc/ufw/sysctl.conf

# Relution Shield IPv4 forwarding kernel configuration
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

Ubuntu-Firewall neu starten:
```
ufw disable && ufw enable
```

Konfiguration von Relution Shield vorbereiten:

Erforderliche Zertifikate und Schlüssel erstellen:

cd /opt/relution-shield
# Create mounted directories
mkdir -v -p pki/{cacerts,certs,private}
docker run -ti --volume "$(pwd)/pki:/opt/pki" relution/relution-shield:latest bash

# Now in docker container
cd /opt

# Create CA private key
pki --gen --type rsa --size 4096 --outform pem > pki/private/ca-key.pem

Es wird eine Zeile im Terminal angezeigt plugin ’tpm’: failed to load…, die auf ein fehlendes TPM Plugin hinweist.
Diese Meldung kann ignoriert werden. Es handelt sich dabei nicht um einen Fehler.

Den Platzhalter <%Relution Shield Host%> ersetzen, z.B. "CN=ca.vpn.meinedomain.de":

# Create certificate
pki --self --ca --lifetime 3650 --in pki/private/ca-key.pem \
    --type rsa --dn "CN=ca.<%Relution Shield Host%>" --outform pem > pki/cacerts/ca-cert.pem

# Generate server key, signed by the CA
pki --gen --type rsa --size 4096 --outform pem > pki/private/server-key.pem

# Generate certificate, signed by the CA
pki --pub --in pki/private/server-key.pem --type rsa \
    | pki --issue --lifetime 1825 \
        --cacert pki/cacerts/ca-cert.pem \
        --cakey pki/private/ca-key.pem \
        --dn "CN=<%Relution Shield Host%>" --san "<%Relution Shield Host%>" \
        --flag serverAuth --flag ikeIntermediate --outform pem \
    >  pki/certs/server-cert.pem

Folgende TPM-Fehlermeldung ignorieren:
plugin ’tpm’: failed to load - tpm_plugin_create not found and no plugin file available

# Prepare Key Pair archive, will be needed for Relution later
openssl pkcs12 -export -out "pki/ca.<%Relution Shield Host%>.p12" -inkey pki/private/ca-key.pem -in pki/cacerts/ca-cert.pem

# Exit the docker container
exit

Der private Schlüssel der Zertifizierungsstelle (CA) muss sicher aufbewahrt werden, da im Falle des Diebstahls die Sicherheit der VPN Public Key Infrastructure (PKI) kompromitiert ist.

Zertifikatsdateien an die entsprechenden Orte verschieben:

mkdir -v -p /opt/relution-shield/etc/swanctl/{x509,x509ca,private}
mv pki/cacerts/ca-cert.pem /opt/relution-shield/etc/swanctl/x509ca/ca-cert.pem
mv pki/private/server-key.pem /opt/relution-shield/etc/swanctl/private/server-key.pem
mv pki/certs/server-cert.pem /opt/relution-shield/etc/swanctl/x509/server-cert.pem

Konfigurationsdatei /opt/relution-shield/etc/strongswan.conf erstellen und folgenden Inhalt einfügen:

vi /opt/relution-shield/etc/strongswan.conf

# strongswan.conf - strongSwan configuration file
#
# Refer to the strongswan.conf(5) manpage for details
#
# Configuration changes should be made in the included files

charon {
    load_modular = yes

    threads = 64

    start-scripts {
        creds = swanctl --load-creds
        conns = swanctl --load-conns
        pools = swanctl --load-pools
    }

    processor {
        priority_threads {
          high = 2
          medium = 8
        }
    }

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

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

        bypass-lan {
            interfaces_use = lo
        }

    }
}

Konfigurationsdatei /opt/relution-shield/etc/swanctl/swanctl.conf erstellen:

vi /opt/relution-shield/etc/swanctl/swanctl.conf

Die Platzhalter <%Relution Shield Host%>, <%VPN CIDR%>, <%Relution Host%> und <%DNS Servers%> ersetzen:

relution-shield-default {
    version = 2
    dpd_delay = 0s
    send_cert = always
    encap = yes
    # Listen on all interfaces for incoming connections
    local_addrs = 0.0.0.0
    proposals = chacha20poly1305-sha512-curve25519-prfsha512,aes256gcm16-sha384-prfsha384-ecp384,aes256-sha384-modp4096,aes256-sha256-modp4096,aes256-sha384-ecp384,aes256-sha256-ecp384,aes256-sha256-ecp256
    pools = relution-shield
    children {
        child {
            start_action = none
            esp_proposals = chacha20poly1305-sha512,aes256gcm16-ecp384,aes256-sha256,aes256-sha384-modp4096,aes256-sha256-modp4096,aes256-sha384-ecp384,aes256-sha256-ecp384,aes256-sha256-ecp256
            # Server can route all traffic, including internet-bound
            local_ts = 0.0.0.0/0
            # Accept client's dynamically assigned IP
            remote_ts = dynamic
            # Ensures reconnection when the client is reachable again
            dpd_action = restart
            updown = /usr/libexec/ipsec/_updown iptables
        }
    }
    local {
        auth = pubkey
        certs = server-cert.pem
        id = <%Relution Shield Host%>
    }
    remote {
        auth = eap-tls
        eap_id = %any
        id = "*@<%Relution Host%>"
        cacerts = ca-cert.pem
    }
}

connections {
    relution-shield-eaptls : relution-shield-default {
        remote {
            id = "*@<%Relution Host%>"
        }
    }
    relution-shield-eaptls-windows : relution-shield-default {
        remote {
            id = "%any"
        }
    }
}

pools {
   relution-shield {
        addrs = <%VPN CIDR%>
        dns = <%DNS Servers%>
    }
}

secrets {
    private {
        file = "server-key.pem"
    }
}

Relution Shield mit Docker installieren:

Datei /opt/relution-shield/compose.yml erstellen und folgenden Inhalt einfügen. Die Platzhalter müssen hier nicht mehr angepasst werden, da sie bereits in der .env-Datei definiert wurden.

vi /opt/relution-shield/compose.yml

services:
  relution-shield:
    image: relution/relution-shield:2-latest
    restart: unless-stopped
    privileged: true
    cap_add:
      - NET_ADMIN
      - NET_RAW
      - SYS_MODULE
    network_mode: host
    ports:
      - "500:500/udp"
      - "4500:4500/udp"
    environment:
      RELUTION_HOSTNAME: ${RELUTION_HOSTNAME}
      RELUTION_REST_API_ACCESS_TOKEN: ${RELUTION_REST_API_ACCESS_TOKEN}
      RELUTION_ACCESS_CHECK_SCOPE: ${RELUTION_ACCESS_CHECK_SCOPE}
    volumes:
      - "./etc/swanctl:/etc/swanctl:ro"
      - "./etc/strongswan.conf:/etc/strongswan.conf:ro"
      - "./compliance:/opt/strongswan/compliance"

Falls Relution Shield 1.x verwendet wird, muss RELUTION_REST_API_ACCESS_TOKEN durch REST_API_ACCESS_TOKEN ersetzt werden.

Relution Shield starten:

cd /opt/relution-shield && docker compose up -d

Relution Shield Auto-Start einrichten – folgende Datei erstellen und öffnen:

vi /etc/systemd/system/relution-shield-networkd-post-restarter.service

Folgenden Inhalt einfügen und speichern:

[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

[Install]
WantedBy=multi-user.target

Dienst mit folgendem Befehl aktivieren:

systemctl enable relution-shield-networkd-post-restarter --now

Umgebungsvariablen

Die folgenden Umgebungsvariablen können verwendet werden, um Relution Shield zu konfigurieren.

Variablenname	Beschreibung	Werte	erforderlich	Benötigte Relution-Shield-Version
`RELUTION_HOSTNAME`	Hostname des Relution-Servers, z.B. `mdm.meinedomain.de`		ja	1.0.0
`RELUTION_REST_API_ACCESS_TOKEN`	API-Token für den Zugriff auf den Relution-Server (Bei Relution Shield 1.x.y: `REST_API_ACCESS_TOKEN`)		ja	2.0.0
`RELUTION_ACCESS_CHECK_SCOPE`	Scope für den Access-Check	`global` / `local`	nein (Standardwert: `local`)	2.0.0
`RELUTION_SERVER_NOT_REACHABLE_ALLOW_DEVICE`	Verbindung mit gültigem Zertifikat erlauben wenn der Relution-Server für den Konformitätscheck nicht erreicht werden kann	`true` / `false`	nein (Standardwert: `true`)	26.0.0
`DEVICE_STATE_CACHE_DURATION_MINUTES`	Dauer, die der einmal geladene Konformitätsstatus lokal gecacht wird, bevor erneut beim Relution-Server nachgefragt wird	Numerischer Wert	nein (Standardwert: `1`)	1.0.0

Relution konfigurieren

Zertifikats-Einrichtung

Zertifikate in die Zielorganisation importieren:
1. Navigieren zu Einstellungen > Zertifikate
2. Zertifikat ca-cert.pem vom Relution Shield Server /opt/relution-shield/etc/swanctl/x509ca/ca-cert.pem herunterladen, in <%Relution Shield Host%> CA-Zertifikat umbenennen und im Relution Applikation Server unter Einstellungen > Zertifikate > CA-Zertifikat hochladen
3. Zertifikat server-cert.pem vom Relution Shield Server /opt/relution-shield/etc/swanctl/x509/server-cert.pem herunterladen, in <%Relution Shield Host%> Server-Zertifikat umbenennen und im Relution Applikation Server unter Einstellungen > Zertifikate > Server-Zertifikat hochladen
4. PKCS12-Schlüsselpaar vom Relution Shield Server /opt/relution-shield/pki/ca.<%Relution Shield Host%>.p12 herunterladen, in <%Relution Shield Host%> CA-Schlüsselpaar umbenennen und im Relution Applikation Server unter Einstellungen > Zertifikate > CA-Schlüsselpaar hochladen
5. Inhalt von /opt/relution-shield/pki/ extern sichern und das Verzeichnis anschließend entfernen
Zertifizierungsstelle und Zertifikatsvorlage erstellen:
1. Navigieren zu Einstellungen > Zertifizierungsstellen
2. Neue Zertifizierungsstelle vom Typ Built In hinzufügen und das zuvor hochgeladene Zertifikat <%Relution Shield Host%> CA-Schlüsselpaar auswählen
3. Navigieren zu Einstellungen > Zertifikatsvorlagen
4. Neue Zertifikatsvorlage hinzufügen:
  1. Zuvor erstellte Zertifizierungsstelle auswählen
  2. Name des Inhabers auf CN=${device.uuid}@<%Relution Host%> setzen (das CN= am Anfang beachten)
  3. Im Feld Verwendung von Zertifikatsschlüsseln Signatur und Schlüsselverschlüsselung aktivieren
  4. Subject Alternative Name vom Typ Email mit ${device.uuid}@<%Relution Host%> hinzufügen (kein CN= am Anfang)
    Eingabe mit Enter bestätigen
  5. Automatische Verlängerung aktivieren und passende Werte setzen, z.B. 60 oder 180 Tage

Beispiel iOS-Konfiguration

Neue iOS-Richtlinie erstellen oder bestehende erweitern
VPN-Konfiguration hinzufügen:
1. Typ IKEv2 auswählen
2. Per App und Konto-VPN aktivieren (siehe auch Relution Hub Docs →)
3. Server und Entfernte ID auf den Wert von <%Relution Shield Host%> setzen
4. Lokale ID auf ${device.uuid}@<%Relution Host%> setzen
5. Authentifizierungsmethode auf Zertifikat setzen und die zuvor erstellte Zertifikatsvorlage auswählen
6. Erweiterte Authentifizierung (EAP) aktivieren
7. IKE SA-Parameter und Untergeordnete SA-Parameter auf AES-256, SHA2-256, DH-Gruppe 16: 4096-Bit-Gruppe, 1440 Minuten setzen
8. Optional: Test-Domain unter Safari-Domänen hinzufügen, um die VPN-Verbindung automatisch zu aktivieren, wenn die Domain über Safari aufgerufen wird
Zertifikat-Konfiguration zur Richtlinie hinzufügen und das zuvor hochgeladene <%Relution Shield Host%> CA-Zertifikat auswählen
Optional: App zu VPN Mapping-Konfiguration hinzufügen, die zuvor erstellte VPN-Konfiguration sowie eine Browser-App wie Firefox oder Chrome auswählen, um den VPN-Zugang zu testen. Empfohlen: App-Konformität hinzufügen, damit sichergestellt ist, dass die App installiert ist.
Richtlinie veröffentlichen und einem Gerät zuweisen. Die VPN-Verbindung lässt sich anschließend manuell über Einstellungen > Allgemein > VPN & Geräteverwaltung > VPN aktivieren. Relution Shield verbindet sich auch automatisch, wenn die in Safari konfigurierten Domains aufgerufen oder die Browser-App geöffnet wird.
Konfiguration anpassen, um die Konten, Apps und Domains einzuschließen, die nur über Relution Shield zugänglich sein sollen.

Beispiel Android Enterprise-Konfiguration

Neue Android Enterprise-Richtlinie erstellen oder bestehende erweitern
StrongSwan VPN Profil-Konfiguration hinzufügen:
1. IKEv2 EAP-TLS als VPN-Typ auswählen
2. Server und Server-Identität auf den Wert von <%Relution Shield Host%> setzen
3. Benutzerzertifikat auf die zuvor erstellte Zertifikatsvorlage setzen
4. CA-Zertifikat auf das zuvor hochgeladene <%Relution Shield Host%> CA-Zertifikat setzen
5. Client-Identität auf ${device.uuid}@<%Relution Host%> setzen
6. Nur diese Apps verwenden das VPN auf einen Browser wie Firefox setzen
StrongSwan VPN Einschränkungen-Konfiguration hinzufügen und das zuvor erstellte VPN-Profil als Standardprofil auswählen
Richtlinie veröffentlichen und einem Gerät zuweisen. Die VPN-Verbindung lässt sich anschließend manuell über die StrongSwan-App aktivieren. Relution Shield verbindet sich auch automatisch, wenn die zuvor konfigurierte Browser-App geöffnet wird.
Konfiguration anpassen, um die Apps einzuschließen, die nur über Relution Shield zugänglich sein sollen.

Major Upgrades

Upgrade von 1.x zu 2.x

Ablegen des privaten CA-Schlüssels /opt/relution-shield/etc/ipsec.d/private/ca-key.pem an einem sicheren Ort (außerhalb des Servers) falls noch nicht vorhanden

Relution Shield stoppen:

cd /opt/relution-shield && docker compose down

Erstellen bzw. ändern der folgenden Dateien wie in der Installationsanleitung beschrieben:
1. Erzeugen der neuen Verzeichnisse für Konfigurationsdateien
```
mkdir -v -p /opt/relution-shield/etc/swanctl/{x509,x509ca,private}
```
2. Erstellen von etc/swanctl/swanctl.conf
3. Anpassen von /opt/relution-shield/compose.yml
4. Anpassen von /opt/relution-shield/.env
5. Anpassen von /opt/relution-shield/etc/strongswan.conf

Verschieben der folgenden Dateien

Alter Pfad	Neuer Pfad
`/opt/relution-shield/etc/ipsec.d/cacerts/ca-cert.pem`	`/opt/relution-shield/etc/swanctl/x509ca/ca-cert.pem`
`/opt/relution-shield/etc/ipsec.d/certs/server-cert.pem`	`/opt/relution-shield/etc/swanctl/x509/server-cert.pem`
`/opt/relution-shield/etc/ipsec.d/private/server-key.pem`	`/opt/relution-shield/etc/swanctl/private/server-key.pem`

Entfernen des Verzeichnisses /opt/relution-shield/etc/ipsec.d
Entfernen von /opt/relution-shield/etc/ipsec.conf
Entfernen von /opt/relution-shield/etc/ipsec.secrets

Relution Shield starten:

cd /opt/relution-shield && docker compose up -d

docs

Relution Shield (Add-on)

Voraussetzungen #

Relution Applikation Server #

Relution Shield Server #

Vorbereitung von Relution #

Anlegen eines technischen Users und API-Access-Tokens #

Relution Shield Server #

Erforderliche Parameter #

Installation #

Umgebungsvariablen #

Relution konfigurieren #

Zertifikats-Einrichtung #

Beispiel iOS-Konfiguration #

Beispiel Android Enterprise-Konfiguration #

Major Upgrades #

Upgrade von 1.x zu 2.x #

Voraussetzungen

Relution Applikation Server

Relution Shield Server

Vorbereitung von Relution

Anlegen eines technischen Users und API-Access-Tokens

Relution Shield Server

Erforderliche Parameter

Installation

Umgebungsvariablen

Relution konfigurieren

Zertifikats-Einrichtung

Beispiel iOS-Konfiguration

Beispiel Android Enterprise-Konfiguration

Major Upgrades

Upgrade von 1.x zu 2.x