Relution Shield (Add-on)

Relution Shield ermöglicht einen sicheren Zugriff vom Internet auf das organisationsinterne Intranet und kombiniert Virtual Private Network (VPN), Private 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

Relution Server

Relution-Server
Eine Zielorganisation auf dem Server mit Relution Shield-Lizenz

Relution Shield Server

Relution Server 5.26+
Ubuntu 22.04+
UDP Port 500 und 4500
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

Vorbereitung von Relution

Anlegen eines technischen Users und API-Access-Tokens

Erstellen Sie eine neue Berechtigungsrolle mit der Berechtigung „Relution Shield Zugangsprüfung“
Erstellen Sie einen neuen Benutzer ohne Passwort in der Zielorganisation
Weisen Sie die Rolle dem Benutzer zu
Erstellen Sie einen API-Access-Token für den Benutzer
Wenn der technische Benutzer in der “Global”-Organisation angelegt wird, kann Relution Shield Zugriffschecks für alle Organisationen auf dem Relution Server durchführen (Benötigt Relution Shield 2.0 oder neuer).

Relution Shield Server

Erforderliche Parameter

Relution Host: Hostname des Relution-Servers, z.B. yourserver.relution.io
Relution API Token: Siehe vorheriger Schritt (Anlegen eines technischen Users und API-Access-Tokens →)
VPN CIDR: Der gewünschte IP-Bereich, aus dem Relution Shield interne IPs zuweist, z.B. 10.1.0.0/16
Network interface: Name der Netzwerkschnittstelle für Relution Shield, z.B. eth0
Relution Shield Host: Hostname von Relution Shield, z.B. vpn.yourserver.relution.io
DNS-Server: IP-Adressen der internen DNS-Server, z.B. 10.1.0.1,10.1.0.2

Installation

Die Installation von Relution Shield ist anspruchsvoll und erfordert Aufmerksamkeit und Zeit. Prüfen Sie die Befehle und Konfigurationen, bevor Sie diese speichern. Achten Sie besonders auf Variablen, die gesetzt werden müssen.

Führen Sie sudo apt update && upgrade aus.
Installieren Sie Docker inklusive docker-compose: Docker Installationsanleitung → (Nicht via snap).
Erstellen Sie das Installationsverzeichnis und das Compliance-Verzeichnis:
```
mkdir -p /opt/relution-shield/compliance
```
Erstellen Sie eine Umgebungsdatei /opt/relution-shield/.env (stellen Sie sicher, dass Sie <%Relution Host%> ersetzen):
```
touch /opt/relution-shield/.env
vi /opt/relution-shield/.env
```
```
RELUTION_HOSTNAME=<%Relution Host%>
RELUTION_REST_API_ACCESS_TOKEN=<access token generated above>
```
Wenn das API-Access-Token zu einem technischen 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

Ändern Sie die Standard-Weiterleitungsrichtlinie in /etc/default/ufw zu DEFAULT_FORWARD_POLICY="ACCEPT"
```
vi /etc/default/ufw
```
Erlauben Sie SSH und die erforderlichen IPSec UDP-Ports
```
ufw allow ssh
ufw allow 500,4500/udp
```

Fügen Sie die folgenden Zeilen am Anfang der Datei /etc/ufw/before.rules hinzu, vor den erforderlichen Zeilen, die *filter enthalten (stellen Sie sicher, dass Sie <%VPN CIDR%> und <%Network interface%> ersetzen - 3 Stellen):

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
...

Fügen Sie die folgenden Zeilen am Ende der Datei /etc/ufw/before.rules hinzu, nach den erforderlichen Zeilen, die *filter enthalten (stellen Sie sicher, dass Sie <%VPN CIDR%> ersetzen):

...
# 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

Passen Sie /etc/ufw/sysctl.conf, an und fügen Sie die folgenden Zeilen am Ende der Datei hinzu:

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

Starten Sie die Ubuntu-Firewall neu
```
ufw disable && ufw enable
```

Bereiten Sie die Konfiguration von Relution Shield vor:

Erstellen Sie die erforderlichen Zertifikate und Schlüssel (stellen Sie sicher, dass Sie <%Relution Shield Host%> ersetzen):

# 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.

# 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

# 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.

Verschieben Sie die Zertifikatsdateien an die entsprechenden Orte:

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

Erstellen Sie die Konfigurationsdatei /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
        }

    }
}

Erstellen Sie die Konfigurationsdatei /opt/relution-shield/etc/swanctl/swanctl.conf (stellen Sie sicher, dass Sie <%Relution Shield Host%>, <%VPN CIDR%>, <%Relution Host%> and <%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

Erstellen Sie die Datei /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._

Starten Sie Relution Shield in/opt/relution-shield via docker compose up -d

Relution Shield Auto-Start einrichten. Erstellen Sie dazu die Datei /etc/systemd/system/relution-shield-networkd-post-restarter.service

[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

Starten Sie den Dienst mit systemctl enable relution-shield-networkd-post-restarter --now

Relution konfigurieren

Zertifikats-Einrichtung

Importieren Sie die Zertifikate in die Zielorganisation:
1. Navigieren Sie zu “Einstellungen” > “Zertifikate”
2. Laden Sie das Zertifikat unter /opt/relution-shield/etc/swanctl/x509ca/ca-cert.pem hoch und geben Sie ihm einen Namen wie ‘<%Relution Shield Host%> CA-Zertifikat’
3. Laden Sie das Zertifikat unter /opt/relution-shield/etc/swanctl/x509/server-cert.pem hoch und geben Sie ihm einen Namen wie ‘<%Relution Shield Host%> Server-Zertifikat’
4. Laden Sie das PKCS12-Archiv unter /opt/relution-shield/pki/<%Relution Shield Host%>.p12 hoch und geben Sie ihm einen Namen wie ‘<%Relution Shield Host%> CA-Schlüsselpaar’
5. Sichern Sie den Inhalt von /opt/relution-shield/pki/ extern und entfernen Sie das Verzeichnis
Erstellen Sie eine Zertifizierungsstelle und ein Zertifikat-Template:
1. Navigieren Sie zu “Einstellungen” > “Zertifizierungsstellen”
2. Fügen Sie eine neue Zertifizierungsstelle vom Typ “Built In” hinzu und wählen Sie das zuvor hochgeladene Zertifikat ‘<%Relution Shield Host%> CA-Schlüsselpaar’
3. Navigieren Sie zu “Einstellungen” > “Zertifikatsvorlagen”
4. Fügen Sie eine neue Zertifikatsvorlage hinzu:
  1. Wählen Sie die zuvor erstellte Zertifizierungsstelle aus
  2. Setzen Sie “Name des Inhabers” auf CN=${device.uuid}@<%Relution Host%> (Beachten Sie das CN= am Anfang)
  3. Aktivieren Sie “Signatur” und “Schlüsselverschlüsselung”
  4. Fügen Sie einen “Subject Alternative Name” vom Typ “Email” mit ${device.uuid}@<%Relution Host%> hinzu (Kein CN= am Anfang)
  5. Aktivieren Sie “automatische Verlängerung” und setzen Sie passende Werte, z.B. 60 Tage oder 180 Tage

Beispiel iOS-Konfiguration

Erstellen Sie eine neue iOS-Richtlinie oder erweitern Sie eine bestehende
Fügen Sie eine VPN-Konfiguration hinzu:
1. Wählen Sie den Typ “IKEv2”
2. Aktivieren Sie “Per App und Konto-VPN” (siehe auch Relution Hub Docs →)
3. Setzen Sie “Server” und “Entfernte ID” auf den Wert von <%Relution Shield Host%>
4. Setzen Sie “Lokale ID” auf ${device.uuid}@<%Relution Host%>
5. Setzen Sie “Authentifizierungsmethode” auf “Zertifikat” und wählen Sie die zuvor erstellte Zertifikat-Vorlage
6. Aktivieren Sie “Erweiterte Authentifizierung (EAP)”
7. Setzen Sie sowohl die IKE SA-Parameter als auch die Untergeordnete SA-Parameter auf “AES-256”, “SHA2-256”, “DH-Gruppe 16: 4096-Bit-Gruppe”, “1440” Minuten
8. Optional: Fügen Sie unten eine Test-Domain zu “Safari-Domänen” hinzu, um die VPN-Verbindung automatisch zu aktivieren, wenn die Domain über Safari aufgerufen wird
Fügen Sie eine “Zertifikat”-Konfiguration zur Richtlinie hinzu und wählen Sie das zuvor hochgeladene “<%Relution Shield Host%> CA-Zertifikat”
Optional fügen Sie eine “App zu VPN Mapping”-Konfiguration hinzu und wählen die zuvor erstellte VPN-Konfiguration sowie eine weitere Browser-App wie Firefox oder Chrome, um den VPN-Zugang zu testen. Es wird empfohlen, auch eine App-Konformität hinzuzufügen, damit sichergestellt wird, dass diese App installiert ist.
Veröffentlichen Sie die Richtlinie und weisen Sie sie einem Gerät zu. Die VPN kann jetzt manuell über “Einstellungen” > “Allgemein” > “VPN & Geräteverwaltung” > “VPN” verbunden werden. Relution Shield wird auch automatisch verbunden, wenn die in Safari konfigurierten Domains aufgerufen oder die Browser-App geöffnet wird.
Passen Sie die Konfiguration an, um die Konten, Apps und Domains einzuschließen, die nur über Relution Shield zugänglich sein sollen.

Beispiel Android Enterprise-Konfiguration

Erstellen Sie eine neue Android Enterprise-Richtlinie oder erweitern Sie eine bestehende
Fügen Sie eine “StrongSwan VPN Profil”-Konfiguration hinzu:
1. Wählen Sie “IKEv2 EAP-TLS” als “VPN-Typ”
2. Setzen Sie “Server” und “Server-Identität” auf den Wert von <%Relution Shield Host%>
3. Setzen Sie “Benutzerzertifikat” auf die zuvor erstellte Zertifikat-Vorlage
4. Setzen Sie “CA-Zertifikat” auf das zuvor hochgeladene “<%Relution Shield Host%> CA-Zertifikat”
5. Setzen Sie “Client-Identität” auf ${device.uuid}@<%Relution Host%>
6. Setzen Sie “Nur diese Apps verwenden das VPN” auf einen Browser wie Firefox
Fügen Sie eine “StrongSwan VPN Einschränkungen”-Konfiguration hinzu und wählen Sie das zuvor erstellte VPN-Profil als Standardprofil aus.
Veröffentlichen Sie die Richtlinie und weisen Sie sie einem Gerät zu. Die VPN kann nun manuell über die StrongSwan-App verbunden werden. Relution Shield wird auch automatisch verbunden, wenn die zuvor konfigurierte Browser-App geöffnet wird.
Passen Sie die Konfiguration an, 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 in /opt/relution-shield stoppen via docker compose down
Erstellen bzw. ändern der folgenden Dateien, wie in der Anleitung im Vorangegangenen 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
Start von Relution Shield in /opt/relution-shield via docker compose up -d

Relution Shield (Add-on)

Voraussetzungen #

Relution Server #

Relution Shield Server #

Vorbereitung von Relution #

Anlegen eines technischen Users und API-Access-Tokens #

Relution Shield Server #

Erforderliche Parameter #

Installation #

Relution konfigurieren #

Zertifikats-Einrichtung #

Beispiel iOS-Konfiguration #

Beispiel Android Enterprise-Konfiguration #

Major Upgrades #

Upgrade von 1.x zu 2.x #

Voraussetzungen

Relution Server

Relution Shield Server

Vorbereitung von Relution

Anlegen eines technischen Users und API-Access-Tokens

Relution Shield Server

Erforderliche Parameter

Installation

Relution konfigurieren

Zertifikats-Einrichtung

Beispiel iOS-Konfiguration

Beispiel Android Enterprise-Konfiguration

Major Upgrades

Upgrade von 1.x zu 2.x