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

  1. Relution-Server
  2. 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 bei der Firewall-Einrichtung freigegeben (ufw allow 500,4500/udp)
      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

Hardware

Der Ressourcenbedarf richtet sich nach der Anzahl der angebundenen Geräte. Relution Shield ist vor allem rechenintensiv: Die Verschlüsselung der VPN-Verbindungen beansprucht in erster Linie die CPU, der Bedarf an Arbeitsspeicher fällt dagegen vergleichsweise gering aus. Bei der Dimensionierung des Servers liegt der Schwerpunkt daher auf ausreichend CPU-Kernen.

Anzahl GeräteCPURAM
bis 1002 Kerne4 GB
bis 2.5008 Kerne8 GB
bis 4.0008 Kerne16 GB

Dimensionierungen für mehr als 4.000 Geräte sind auf Anfrage erhältlich.


Anlegen eines technischen Users und API-Access-Tokens

Neu in 26.5
  1. Neue Berechtigung mit der Rolle Relution Shield Zugangsprüfung erstellen: unter Benutzer → Berechtigungen → Hinzufügen im Abschnitt Geräte den Punkt Relution Shield Zugangsprüfung aktivieren (in der Global-Organisation: Relution Shield Zugangsprüfung (Global))

  2. Neuen Benutzer ohne Passwort (Passwortbasierte Authentifizierung deaktivieren) in der Zielorganisation erstellen

    Wird der Benutzer in der Global-Organisation angelegt, kann Relution Shield Zugriffsprüfungen für alle Organisationen auf dem Relution Server durchführen (benötigt Relution Shield 2.0 oder neuer). In der Global-Organisation heißt die Berechtigung Relution Shield Zugangsprüfung (Global). Zusätzlich muss in der .env RELUTION_ACCESS_CHECK_SCOPE=global gesetzt werden (siehe Installation →).
  3. Dem Benutzer die neu erstellte Berechtigung zuweisen und den Benutzer speichern

  4. API-Access-Token für den Benutzer erstellen: unter Verwendungszweck die Option API wählen, im Feld API-Bereiche den Eintrag Relution Shield (shield) aktivieren und im Feld Ablaufdatum ein passendes Datum festlegen (vorbelegt sind 30 Tage, möglich ist höchstens 1 Jahr)

    Neues Access Token mit Verwendungszweck API und API-Bereich Relution Shield

Ab Relution 26.5 gilt ein API-Access-Token nur für die ausgewählten API-Bereiche. Relution Shield benötigt ausschließlich den Bereich Relution Shield (shield). Fehlt er, lehnt der Relution-Server die Zugriffsprüfung ab. Relution Shield behandelt das wie einen nicht erreichbaren Server: Mit dem Standardwert RELUTION_SERVER_NOT_REACHABLE_ALLOW_DEVICE=true werden Geräte mit gültigem Zertifikat ohne Zugriffsprüfung zugelassen, im Log erscheint Relution: Could not retrieve status, temporarily accepting ….

API-Access-Tokens, die vor dem Update auf Relution 26.5 erstellt wurden, erhalten beim Update automatisch alle API-Bereiche und funktionieren unverändert weiter.

Ab Relution 26.5.5 laufen API-Access-Tokens immer ab. Das Ablaufdatum lässt sich nach dem Erstellen nicht mehr ändern. Tokens, die zuvor ohne Ablaufdatum erstellt wurden, laufen 30 Tage nach dem Update ab; unter Relution 26.5.5 und 26.5.6 mit deaktivierter Gültigkeitsdauer erstellte Tokens 30 Tage nach dem Erstellen. Ist das Token abgelaufen oder der technische Benutzer gesperrt bzw. deaktiviert, lehnt der Relution-Server die Zugriffsprüfung ab, und Relution Shield verhält sich wie bei fehlendem API-Bereich.

Ab Relution 27.0.1 ist die Laufzeit nach oben begrenzt: Das Ablaufdatum liegt höchstens 1 Jahr nach dem Erstellen, das spätestmögliche Datum zeigt der Dialog an. Die Höchstlaufzeit lässt sich über relution.security.access-token.max-lifetime (Umgebungsvariable RELUTION_SECURITY_ACCESSTOKEN_MAXLIFETIME) weiter verkürzen.

Vor dem Ablauf wird daher ein neues Token erstellt, in der .env als RELUTION_REST_API_ACCESS_TOKEN eingetragen und Relution Shield mit cd /opt/relution-shield && docker compose up -d neu gestartet.


Erforderliche Parameter

  1. Relution Host: Hostname des Relution-Servers
    z.B. mdm.meinedomain.de
  2. Relution API Token: API-Access-Token mit dem API-Bereich Relution Shield (shield), siehe vorheriger Schritt
    Anlegen eines technischen Users und API-Access-Tokens →
  3. 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.
  4. Network interface: Name der Netzwerkschnittstelle, die der Relution Shield Server verwendet, z.B. eth0 – prüfen via ip a
  5. Relution Shield Host: Hostname von Relution Shield
    z.B. vpn.meinedomain.de
  6. 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

  1. Folgenden Befehl ausführen:

    sudo apt update && sudo apt upgrade
    
  2. Docker inklusive docker-compose installieren (nicht via snap)
    Docker Installationsanleitung →

  3. Installationsverzeichnis und Compliance-Verzeichnis erstellen:

    mkdir -p /opt/relution-shield/compliance
    
  4. 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
    
  5. Ubuntu-Firewall ufw

    1. Standard-Weiterleitungsrichtlinie in /etc/default/ufw auf DEFAULT_FORWARD_POLICY="ACCEPT" setzen:

      vi /etc/default/ufw
      
      DEFAULT_FORWARD_POLICY="ACCEPT"
      
    2. SSH und die erforderlichen IPSec UDP-Ports freigeben:

      ufw allow ssh
      ufw allow 500,4500/udp
      
    3. 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.

    before.rules Übersicht

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

      before.rules Übersicht

    2. 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
      
    3. Ubuntu-Firewall neu starten:

      ufw disable && ufw enable
      
  6. Konfiguration von Relution Shield vorbereiten:

    1. 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:2-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 kann ignoriert werden:

      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.
    2. 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
      
    3. Konfigurationsdatei /opt/relution-shield/etc/strongswan.conf erstellen und folgenden Inhalt einfügen:

      vi /opt/relution-shield/etc/strongswan.conf
      
Vollständiges Konfigurationsbeispiel anzeigen
# 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
        }

    }
}
  1. 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:

Vollständiges Konfigurationsbeispiel anzeigen
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"
    }
}
  1. Relution Shield mit Docker installieren:

    1. 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}
            RELUTION_SERVER_NOT_REACHABLE_ALLOW_DEVICE: ${RELUTION_SERVER_NOT_REACHABLE_ALLOW_DEVICE:-}
            DEVICE_STATE_CACHE_DURATION_MINUTES: ${DEVICE_STATE_CACHE_DURATION_MINUTES:-}
            RELUTION_HEALTHCHECK_ID: ${RELUTION_HEALTHCHECK_ID:-}
          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.

    2. Relution Shield starten:

      cd /opt/relution-shield && docker compose up -d
      
    3. 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
      
    4. 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.

VariablennameBeschreibungWerteerforderlichBenötigte Relution-Shield-Version
RELUTION_HOSTNAMEHostname des Relution-Servers, z.B. mdm.meinedomain.deja1.0.0
RELUTION_REST_API_ACCESS_TOKENAPI-Token für den Zugriff auf den Relution-Server (Bei Relution Shield 1.x.y: REST_API_ACCESS_TOKEN)ja2.0.0
RELUTION_ACCESS_CHECK_SCOPEScope für den Access-Checkglobal / localnein (Standardwert: local)2.0.0
RELUTION_SERVER_NOT_REACHABLE_ALLOW_DEVICEVerbindung mit gültigem Zertifikat erlauben wenn der Relution-Server für den Konformitätscheck nicht erreicht werden kanntrue / falsenein (Standardwert: true)26.2.0
DEVICE_STATE_CACHE_DURATION_MINUTESDauer in Minuten, die der einmal geladene Konformitätsstatus lokal gecacht wird, bevor erneut beim Relution-Server nachgefragt wirdNumerischer Wertnein (Standardwert: 1)26.2.0
RELUTION_HEALTHCHECK_IDGeräte-ID, die ohne Zugriffsprüfung zugelassen wird, z.B. für eine Monitoring-Verbindung (Bei Relution Shield 1.x.y: HEALTHCHECK_ID)nein2.0.0

Eine Variable aus der .env wirkt nur, wenn sie in der compose.yml unter environment an den Container übergeben wird. Die compose.yml aus der Installationsanleitung übergibt alle Variablen dieser Tabelle; nicht gesetzte optionale Variablen erhalten den Standardwert. Relution Shield vor Version 26.2.0 ignoriert RELUTION_SERVER_NOT_REACHABLE_ALLOW_DEVICE und DEVICE_STATE_CACHE_DURATION_MINUTES und verwendet immer die Standardwerte.


Zugriffsprüfung

Bei jedem Verbindungsaufbau fragt Relution Shield beim Relution Server ab, ob das Gerät zugelassen wird. Das Ergebnis hängt vom Status des Geräts und von den Einstellungen unter Einstellungen → Relution Shield ab:

  • Geräte, die Relution nicht kennt oder die sich nicht im Status Konform, Nicht konform oder Inaktiv befinden (z.B. Einschreibung ausstehend…), werden immer abgelehnt.
  • Inaktive Geräte erlauben (Standard: aktiviert): Inaktive Geräte werden zugelassen.
  • Nicht konforme Geräte zulassen (Standard: deaktiviert): Nicht konforme Geräte werden abgelehnt, solange die Option deaktiviert ist.

Mit RELUTION_ACCESS_CHECK_SCOPE=global gelten die Einstellungen der Global-Organisation, unabhängig von der Organisation des Geräts.

Relution Shield speichert das Ergebnis je Gerät im Verzeichnis /opt/relution-shield/compliance und verwendet es für die in DEVICE_STATE_CACHE_DURATION_MINUTES festgelegte Dauer. Änderungen am Gerätestatus wirken deshalb erst nach Ablauf dieser Zeit.

Für jede Verbindung protokolliert Relution Shield das Ergebnis der Zugriffsprüfung mit Relution: accepting … bzw. Relution: rejecting …. Aktive Verbindungen und das laufende Protokoll lassen sich auf dem Relution Shield Server anzeigen:

cd /opt/relution-shield
docker compose exec relution-shield swanctl --list-sas
docker compose exec relution-shield swanctl --log

Zertifikats-Einrichtung

  1. 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 und im Relution Applikation Server unter Einstellungen → Zertifikate über Hinzufügen hochladen, als Name <%Relution Shield Host%> CA-Zertifikat eintragen

    3. Zertifikat server-cert.pem vom Relution Shield Server /opt/relution-shield/etc/swanctl/x509/server-cert.pem herunterladen und im Relution Applikation Server unter Einstellungen → Zertifikate über Hinzufügen hochladen, als Name <%Relution Shield Host%> Server-Zertifikat eintragen

    4. PKCS12-Schlüsselpaar vom Relution Shield Server /opt/relution-shield/pki/ca.<%Relution Shield Host%>.p12 herunterladen und im Relution Applikation Server unter Einstellungen → Zertifikate über Hinzufügen hochladen, als Name <%Relution Shield Host%> CA-Schlüsselpaar eintragen

    5. Inhalt von /opt/relution-shield/pki/ extern sichern und das Verzeichnis anschließend entfernen

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

Zertifikatsvorlage


Beispiel iOS-Konfiguration

  1. Neue iOS-Richtlinie erstellen oder bestehende erweitern

  2. VPN-Konfiguration hinzufügen:

    1. Typ IKEv2 auswählen

    2. VPN-Verbindung für Apps und Konten 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

  3. Zertifikat-Konfiguration zur Richtlinie hinzufügen und das zuvor hochgeladene <%Relution Shield Host%> CA-Zertifikat auswählen

  4. Optional: App zu VPN Zuordnung-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.

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

  6. Konfiguration anpassen, um die Konten, Apps und Domains einzuschließen, die nur über Relution Shield zugänglich sein sollen.

Erforderliche Konfigurationen einer Relution-Shield-Richtlinie

iOS VPN-Konfiguration


Beispiel Android Enterprise-Konfiguration

  1. Neue Android Enterprise-Richtlinie erstellen oder bestehende erweitern

  2. StrongSwan VPN Profil-Konfiguration hinzufügen:

    1. IKEv2 EAP-TLS als VPN-Typ auswählen

    2. Server und Serveridentitä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. Identität des Kunden (Client-Identität) auf ${device.uuid}@<%Relution Host%> setzen

    6. Unter Apps die Option Nur diese Apps können das VPN nutzen wählen und einen Browser wie Firefox hinzufügen

  3. StrongSwan Restriktionen-Konfiguration hinzufügen und das zuvor erstellte VPN-Profil als Standardprofil auswählen

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

  5. Konfiguration anpassen, um die Apps einzuschließen, die nur über Relution Shield zugänglich sein sollen.

Android Enterprise VPN-Übersicht

Android Enterprise VPN-Konfiguration


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.
  1. Relution Shield stoppen:

    cd /opt/relution-shield && docker compose down
    
  2. 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

    6. Verschieben der folgenden Dateien

    Alter PfadNeuer 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
    1. Entfernen des Verzeichnisses /opt/relution-shield/etc/ipsec.d

    2. Entfernen von /opt/relution-shield/etc/ipsec.conf

    3. Entfernen von /opt/relution-shield/etc/ipsec.secrets

    4. Relution Shield starten:

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

Wie hilfreich war dieser Artikel?