Absicherung NFS: Difference between revisions

Revision as of 20:05, 18 October 2022

Grundlagen

802.1x

802.1x ist ein Standard zur Authentifizierung in Netzwerken. Ein Client (Supplicant) kann welcher sich physisch an einem Switchport (Authenticator) verbindet oder drahtlos mit einer SSID verbindet wird dabei über einen Server (Authentication Server, z.B. RADIUS) authentifiziert.

RADIUS

RADIUS (Remote Authentication Dial In User Service) ist ein Protokoll für zentrale Authentifizierung, Autorisierung und Accounting in Netzwerken. Das Protokoll arbeitet auf OSI Layer 7 (Anwendungsebene).

EAP

EAP steht für Extensible Authentication Protocol (RFC3748) und ist ein allgemeines Authentifizierungsprotokoll welches mehere Authentifizierungsverfahren unterstützt. Das im nachfolgenden verwendet Verfahren EAP-TLS ist in RFC5216 definiert. Der Ablauf von EAP-TLS zusammen mit RADIUS als Authentication Server sieht folgendermaßen aus :

Kommunikation zwischen Supplicant und Authenticator:
1. Authenticator schickt ein EAP-Request/Identity Paket an den Supplicant
2. Supplicant antwortet mit EAP-Response/Identity an den Authenticator
Kommunikation zwischen RADIUS Server und Supplicant (der Authenticator tunnelt die EAP Pakete)
1. Der RADIUS Server schickt ein EAP-TLS/Start Paket an den Supplicant
2. Supplicant antwortet mit EAP/Reponse Paket und EAP-Type=EAP-TLS, TLS Records: client-hello, opt. cipher-spec ansonsten TLS_NULL_WITH_NULL_NULL
3. RADIUS Server antwortet mit EAP/Request und EAP-Type=EAP-TLS, TLS Records: server-hello und weiter TLS Records
4. Der TLS Handshake erfolgt durch EAP/Request und EAP/Response Pakete bei denen die Nutzdaten die TLS Records enthalten
5. Nach Empfang des TLS finished records verschickt der Supplicant eine weiter EAP/Response EAP-Type=EAP-TLS Nachricht
6. RADIUS Antwortet mit EAP-Success

Paketformat

Die EAPoL Nachrichten, welche zwischen Supplicant (Client) und Authenticator (Switch) ausgetauscht werden sind Ethernet Frames welche ein 802.1x Paket als Payload haben. Im 802.1x Paket ist wiederum der Payloadtype auf EAP gesetzt. Kommt ein solches Layer2 Paket am Authenticator an entfernt dieser den Ethernet und 802.1x Header und verpackt das EAP Paket in ein RADIUS Paket welches mittel UDP/IP an den RADIUS Server übertragen wird. Der Switch Tunnelt also die EAP Pakete welche er vom Client erhält zum RADIUS Server. Durch dieses Prinzip muss der RADIUS Server weder Teil desselben Layer 2 Segments sein, noch eine IP Adresse im gleichen Subnetz wie Supplicant oder Authenticator besitzen. Dies erlaubt Unternehmensweit einen einzigen RADIUS Server zu betreiben. Aufgrund der Ausfallsicherheit sollte jedoch mindestens ein weiterer RADIUS Server zur Verfügung stehen.

Umsetzung

Plan

Step 1: Authentifizierung mit 802.1x. 1x Switch, 1x Client und 1x RADIUS Server

Step 2: CSR in TPM generieren oder Zertifikat mit Schluessel importieren.

Step 3: Zertifikat aus TPM fuer 802.1x verwenden.

Step 1

FreeRADIUS Server aufsetzen und konfigurieren
1. FREERADIUS kann aus den apt Paketquellen installiert werden mit:
  sudo apt install freeradius
2. radtest ist ein Kommandozeilentool mit welchem die Kommunikation mit einem RADIUS Server getestet werden kann. Mit folgendem Befehlt kann die Erreichbarkeit des RADIUS Server auf localhost getestet werden:
  radtest {username} {password} {hostname} 10 {radius_secret}
3. hierfür muss ein client in der config Datei clients.conf angelegt werden mit dem entsprechenden RADIUS Secret und Hostname/IP. Außerdem muss ein Benutzer angelegt werden in der users.conf mit {username} und {password}.

Switch mit 3 VLANs eingerichtet. VLAN 50 wurde für die "Infrastruktur" verwendet. In diesem VLAN besaßen der Switch und der RADIUS Server ihre IP Adressen. Darüber hinaus wurden VLAN 10 und VLAN 20 eingerichtet als Test VLANs für den Client. Die Einrichtung mit Netgear war etwas umständlich, weil die GUI teilweise unübersichtlich ist und gewöhnungsbedürftige Mechanismen zum bearbeiten der Config hat. Die finale Switch config ist weiter unten zu sehen.

Damit der Switch sich mit dem RADIUS Server verbinden kann muss er als Client in der clients.conf hinterlegt sein. Dort wird eine entsprechendes Secret festgelegt welches im nächsten Schritt auf dem Switch hinterlegt werden muss.

Im Switch haben wir anschließend den RADIUS Server mit seinem Secret eingetragen. Leider bietet die Netgear GUI keinen Button um die Verbindung zu testen. Da wir in einem Untermenü TODO vergessen haben die Authentifizierungsmöglichkeit 802.1x allgemein zu aktivieren blieben erste Verbindungsversuche mit einem Client am Switch erfolglos. Durch das starten von Freeradius im Debug Modus mit freeradius -X kann überprüft werden ob die Daten vom Client am überhaupt am RADIUS Server ankommen. Nach dem tätigen der fehlenden Einstellung gelang eine erste Verbindung mit dem zuvor konfigurierten Username und cleartext Password mittels EAP-PWD (Achtung unsicher!)

Auf dem Switch haben wir eingestellt, dass bei "Access-Accept" als Antwort VLAN10 und bei "Access-Reject", also standardmäßig das VLAN 20 zugewiesen wird. Ein test mit EAP-PWD war erfolgreich.

Um das setup mobil zu gestalten haben wir den RADIUS Server auf einen Raspberry Pi migriert und ebenfalls die zwei Test VLANs 10 und 20 auf dem PI angelegt. So konnten wir mittels eines Pings überprüfen ob der Client dem richtigen VLAN zugewiesen wurde und bei der Demo "beweisen" das dies der Fall ist. Damit das ganze noch einfacher sichtbar ist wurde eine DHCP Server installiert der Adressen für in VLAN 10 (192.168.10.0/24 und VLAN 20 (192.168.20.0/24) vergibt.

Um eine Authentifizierung mit EAP-TLS zu demonstrieren haben wir eine ca erstellt mit einem ROOT, Server und einem Client Zertifikat. Dafür haben wir die im Verzeichnis certs liegenden openssl config templates von freeradius ausgefüllt und die Zertifikate mittels des Makefiles erstellen lassen. Das Makefile benutzt die entsprechenden openssl Befehle mit der config als Parameter.

Das Client Zertifikat inklusive private key haben wir im Anschluss auf den Test Laptop geladen und eine Zertifikatsbasierte Authentifizierung unter Nutzung von EAP-TLS erfolgreich getestet. Dafür haben wir in der GUI des Clients die 802.1x Security für die drahtgebundene Verbindung aktiviert, das Client Zertifikat inklusive private key und das ROOT CA Zertifikat, welches zur Überprüfung des Server Zertifikates benötigt wird, angegeben. Standardmäßig akzeptiert der freeradius RADIUS Server alle von der ROOT CA signierten Zertifikate. Die Verbindung gab erfolgreich ein "Access-Accept" zurück.

Um auch bei EAP-TLS in der RADIUS Antwort ein VLAN Tag mitzugeben haben wir die Datei mods-available/check-eap-tls bearbeitet.

update config {
   Access-Accept
}
update reply {
   Tunnel-Type = "VLAN",
   Tunnel-Medium-Type = "IEEE-802",
   Tunnel-Private-Group-Id = "10"
}

Step 2

Ziel in Step 2 ist die Erstellung eines private key im TPM 2.0 Chip um mittels openssl eine zugehörige CSR zu erstellen. Für die Kommunikation mit dem TPM 2.0 Chip haben wir die tpm2-pksc11 Library verwendet. Da die Paketquellen der Library und der Abhängigkeiten je nach Betriebssystemversion unterschiedliche Versionen aufweisen, haben wir uns für eine Installation from Source entschieden. Ein Shell Skript mit unserer Installationsroutine sieht wie folgt aus:

#!/bin/bash 
### ATTENTION READ BEFORE STARTING THIS SCRIPT ###
### IF cffi version mismatch errors occures install python3-cffi WITH SYNAPTIC \(°~°)/ ###

set -euo pipefail

VERSION_LIMIT=4.12
CURRENT_VERSION=$(uname -r | cut -c1-3)
if (( $(echo "$CURRENT_VERSION > $VERSION_LIMIT" |bc -l) )); then
    echo "SUCCESS Kernel version: $CURRENT_VERSION > Version Limit: $VERSION_LIMIT "
else
    echo "FAILURE Kernel version: $CURRENT_VERSION < Version Limit: $VERSION_LIMIT "
    exit
fi

# in case one command has an error exit the script
sudo mkdir -p /etc/tpm2_pkcs11

sudo apt update -y
sudo apt upgrade -y
sudo apt install git -y
sudo apt install python3-pip -y 

# Install p11-kit from apt
sudo apt install p11-kit libp11-kit-dev -y 

# Install p11 tool from apt
sudo apt install gnutls-bin -y

# Install tpm2_pkcs11 from source
wget https://github.com/tpm2-software/tpm2-pkcs11/releases/download/1.8.0/tpm2-pkcs11-1.8.0.tar.gz
tar -xzf tpm2-pkcs11-1.8.0.tar.gz

# get prerequisites
sudo apt install -y automake autoconf make sqlite3 libsqlite3-dev libyaml-dev libglib2.0-dev uuid-dev pandoc python3-cffi 

# install tpm2-tss dependency
sudo apt -y install \
  autoconf-archive \
  libcmocka0 \
  libcmocka-dev \
  procps \
  iproute2 \
  build-essential \
  git \
  pkg-config \
  gcc \
  libtool \
  automake \
  libssl-dev \
  uthash-dev \
  autoconf \
  doxygen \
  libjson-c-dev \
  libini-config-dev \
  libcurl4-openssl-dev \
  libltdl-dev

# install python modules
pip install bcrypt cryptography pyyaml pyasn1 pyasn1_modules 


# install tpmp2-tss
wget https://github.com/tpm2-software/tpm2-tss/releases/download/3.2.0/tpm2-tss-3.2.0.tar.gz
tar -xzf tpm2-tss-3.2.0.tar.gz 

cd tpm2-tss-3.2.0
./configure
make -j$(nproc)
sudo make install
sudo udevadm control --reload-rules && sudo udevadm trigger
sudo ldconfig
cd ..

# install tpm2_pytss
pip install tpm2_pytss 

# install tpm2-tools
sudo apt install tpm2-tools -y
# install tpm2-abrmd
sudo apt install tpm2-abrmd -y 

# libengine-pkcs11-openssl needed for opennssl 3.0 communication with TPM 2.0 via wpa_supplicant
sudo apt install tpm2-openssl libengine-pkcs11-openssl -y

sudo apt install python3-stsci.distutils -y

cd tpm2-pkcs11-1.8.0
./configure
make
sudo make install

cd tools
pip install .
export PATH="/home/client/.local/bin:$PATH"
export PATH="$PWD:$PATH" 

cd ..
cd .. 

export PATH="$PWD:$PATH"

#export TPM2_PKCS11_STORE="/home/client/store"
export TPM2TOOLS_TCTI="device:/dev/tpmrm0"
export TPM2_PKCS11_TCTI="device:/dev/tpmrm0"

echo 'FINISHED SUCCESSFULLY'
echo 'FOR PERSISTENCE CHANGES ADD THE FOLLOWING TO YOU ENV IN BASHRC:'
echo 'export TPM2TOOLS_TCTI="device:/dev/tpmrm0"'
echo 'export TPM2_PKCS11_TCTI="device:/dev/tpmrm0"' 

echo 'ADD THE FOLLOWING CONFIG TO YOUR OPENNSL CONFIG IN /etc/ssl/openssl.cnf'
echo '[openssl_init]'
echo 'engines = engine_section'
echo 
echo '[engine_section]'
echo 'pkcs11 = pkcs11_section'
echo 
echo '[pkcs11_section]'
echo 'engine_id = pkcs11'
echo 'dynamic_path = /usr/lib/x86_64-linux-gnu/engines-3/libpkcs11.so'
echo 'MODULE_PATH = /usr/lib/x86_64-linux-gnu/pkcs11/libtpm2_pkcs11.so'
echo 'init = 0'

Diese Skript ist kümmert sich um keinerlei Fehlererkennung oder ähnliches und soll nur als Inspiration dienen. Nachfolgend sind einige Webseiten/Blogeinträge verlinkt die uns beim Troubleshooting während der Installation geholfen haben. ACHTUNG! Es ist äußert wichtig das bei der Installation von tpm2-tools p11-kit als installiert erkannt wird. Dies kann in den Installationslogs nachgelesen werden. Falls p11-kit nicht erkannt wurde funktionieren die nachfolgenden Schritte nicht. Bei uns musste das Paket libp11-kit-dev nachinstalliert werden.

Für die Erstellung der CSR haben wir folgenden code verwendet (Hinweis: da wir einige Probleme mit den Umgebungsvariablen hatten, haben wir bei sudo aufrufen -E zum beibehalten der user Umgebungsvariablen mitgegeben. Durch geschicktere Konfiguration kann dies vermieden werden. Zum Zugriff auf den TPM Chip werden standardmäßig root rechte benötigt, da auf Hardware Ressourcen zugegriffen wird.):

export TPM2TOOLS_TCTI="device:/dev/tpmrm0"
export TPM2_PKCS11_TCTI="device:/dev/tpmrm0" 

sudo -E tpm2_ptool init
sudo -E tpm2_ptool addtoken \
    --pid=1 \
    --sopin=sopin \
    --userpin=userpin \
    --label=label
sudo -E tpm2_ptool addkey \
    --algorithm=rsa2048 \
    --label=label \
    --userpin=userpin
sudo -E tpm2_ptool config \
    --key tcti \
    --value "device:/dev/tpmrm0" \
    --label label
TOKEN=`sudo -E p11tool --list-token-urls | grep "token=label"`
p11tool --login --list-all "${TOKEN}" --outfile p11tool.out
# Private key enthält die PKCS11 URI die später in der wpa_supplicant.conf angegeben werden muss
PRIVATE_KEY=`cat p11tool.out | grep private | awk '{ print $2 }'`

export GNUTLS_PIN=userpin
export GNUTLS_SO_PIN=sopin


SUBJ="/C=DE/ST=Berlin/L=Berlin/O=Rechnerbetriebsgruppe/OU=ProfessorIn/CN=Peter Meyer/emailAddress=peter.meyer@hu-berlin.example" 

yaml_rsa0=$(sudo -E tpm2_ptool export --label="label" --key-label="" --userpin="userpin")
auth_rsa0=$(echo "$yaml_rsa0" | grep "object-auth" | cut -d' ' -f2-)
# Hier muss noch -key angepasst werden, je nachdem welche Datei vom tpm2_ptool export ausgegeben wird
sudo openssl req -new -provider tpm2 -provider base -key 5.pem -passin "pass:$auth_rsa0" -subj "${SUBJ}" -out "$HOSTNAME".csr

Die durch diese Befehle erstellte CSR kann nun von der jeweiligen CA signiert werden.

Nützliche Links

https://github.com/tpm2-software/tpm2-pkcs11 von Source installiert, da dass Package aus den Packetmanager Quellen veraltet ist und für das Zusammenspiel mit openssl3 eine neuere Funktion benötigt wurde.

Folgende Artikel helfen bei allen möglichen Fehlern während der Installation:

Zusätzliche Dependency die benötigt wird: https://github.com/tpm2-software/tpm2-openssl

https://www.howtoinstall.me/ubuntu/18-04/libengine-pkcs11-openssl/

https://github.com/tpm2-software/tpm2-pkcs11/issues/766

https://stackoverflow.com/questions/43325110/exception-version-mismatchcffi

https://stackoverflow.com/questions/62154342/configure-error-package-requirements-sqlite3-3-7-4-were-not-met

https://askubuntu.com/questions/1403837/how-do-i-use-openssl-1-1-1-in-ubuntu-22-04

Wir haben ein Install-Skript fuer Ubuntu 24 geschrieben.

Das generieren eines CSRs im TPM hat mit folgendem Tutorial funktionert: https://github.com/tpm2-software/tpm2-pkcs11/blob/master/docs/EAP-TLS.md (nach 2 Tagen Fehlersuche)

Die Zeilen für die Engine, die für Benutzung mit der wpa_supplicant benötigt werden dürfen bei Step 2 noch nicht in der config sein!

Step 3

Das generierte Client CSR auf den Radius Server geschickt, um es von unserer CA signieren zu lassen.

Damit haben wir ein Client CRT erhalten, welches wir zurück zum Client Laptop geschickt haben.

Um eine Authentisierung mit dem Radius Server vorzunehmen brauchen wir eine wpa_supklicant.conf Datei, welche folgendermaßen aufgebaut sein muss:

/etc/wpa_supplicant-wired-enx00e04c680106XXpZvOAl.conf

ctrl_interface=/run/wpa_supplicant
ap_scan=0
pkcs11_module_path=/usr/lib/x86_64-linux-gnu/opensc-pkcs11.so
network={
        key_mgmt=IEEE8021X
        eap=TLS
        identity="client"
        ca_cert="/home/client/src/ca.pem"
        client_cert="/home/client/src/03.pem"
        private_key="pkcs11:model=NPCT75x%00%02%01%00%24rls%00;manufacturer=Nuvoton;serial=0000000000000000;token=label;id=%64%33%34%64%34%32%65%32%39%62%36%64%36%65%63%65;type=private;pin-value=userpin"
}

Es unterscheidet sich je nach Verwendung von WLAN oder wired, wir haben hier eine Konfiguration für wired verwendet.

wpa_supplicant benutzt openssl, um mit dem TPM kommunizieren zu können. Openssl benötigt dafür eine Engine. Wir haben libengine-pkcs11-openssl verwendet. Um OpenSSL mitzugeben welche PKCS11 Engine es benutzen soll habe wir folgende Änderungen in der OpenSSL.conf vorgenommen: /etc/ssl/openssl

[openssl_init]
engines = engine_section
[engine_section]
pkcs11 = pkcs11_section
[pkcs11_section]
engine_id = pkcs11
dynamic_path = /usr/lib/x86_64-linux-gnu/engines-3/libpkcs11.so
MODULE_PATH = /usr/lib/x86_64-linux-gnu/pkcs11/libtpm2_pkcs11.so
init = 0

Ergebnisse

Eine erfolgreiche Authentifizierung mit wpa_supplicant sieht wie folgt aus:

sudo -E wpa_supplicant -c /etc/wpa_supplicant/wpa_supplicant-wired-enx00e04c680106.conf -i enx00e04c680106 -D wired

Successfully initialized wpa_supplicant
enx00e04c680106: Associated with 01:80:c2:00:00:03
enx00e04c680106: CTRL-EVENT-SUBNET-STATUS-UPDATE status=0
enx00e04c680106: CTRL-EVENT-EAP-STARTED EAP authentication started
enx00e04c680106: CTRL-EVENT-EAP-PROPOSED-METHOD vendor=0 method=4 -> NAK
enx00e04c680106: CTRL-EVENT-EAP-PROPOSED-METHOD vendor=0 method=13
enx00e04c680106: CTRL-EVENT-EAP-METHOD EAP vendor 0 method 13 (TLS) selected
enx00e04c680106: CTRL-EVENT-EAP-PEER-CERT depth=1 subject='/C=DE/ST=Berlin/L=Berlin/O=Rechnerbetriebsgruppe/emailAddress=admin@rbg.example/CN=Allm\xC3\x83\xC2\xA4chtige Rechnerbetriebgruppe ROOT'      hash=e058f4d62841026bda3814acaf39337fb2dc147456d6b45298d0472181b9f059
enx00e04c680106: CTRL-EVENT-EAP-PEER-CERT depth=0 subject='/C=DE/ST=Berlin/O=Rechnerbetriebsgruppe/CN=Allm\xC3\x83\xC2\xA4chtiger RADIUS/emailAddress=admin@rbg.example' hash=bf3be5e22ed92568dc215ada7a2e2babe8da4c9fb6fbf278f485669ad1161097 tod=2
enx00e04c680106: CTRL-EVENT-EAP-SUCCESS EAP authentication completed successfully
enx00e04c680106: CTRL-EVENT-CONNECTED - Connection to 01:80:c2:00:00:03 completed [id=0 id_str=]

Radius

RADIUS uses User Datagram Protocol (UDP) port 1812 for authentication and 1813 for accounting

• radiusd.conf Defines the configuration parameters for the RADIUS server. It includes references to all of the other configuration files.

• clients.conf Defines information necessary to configure the RADIUS client, including IP addresses and shared secrets. This file is referenced from the radiusd.conf file.

• dictionary Defines local attributes for the RADIUS server. This file references the default dictionary files. The default dictionary files include thousands of attribute definitions for over one hundred vendors.

• proxy.conf Defines upstream home servers, including information on IP addresses and shared secrets. It also defines Realms. The radiusd.conf file references the proxy.conf file.

• sites-enabled/default This is the default virtual server. This file handles authentication and accounting requests. It contains a configuration designed to work with the largest number of authentication protocols. The radiusd.conf file references the sites-enable/default file.

• sites-enabled/inner-tunnel This virtual server handles authentication methods that are carried inside of a TLS tunnel, as part of PEAP or EAP-TTLS authentication. The radiusd.conf file references the sql.conf file.

• users The traditional RADIUS configuration file for users. This file format is similar to the format defined in 1993. The files file references the users file.

Folgende Attribute wurden aus unseren Zertifikaten geparsed und können als Unterscheidungsmerkmal für die Authentifizierung verwendet werden:

(7) eap_tls: TLS - Creating attributes from certificate OIDs
(7) eap_tls:   TLS-Cert-Serial := "1a61a1346f833e3fa509ce4aeb6a41039685a4ed"
(7) eap_tls:   TLS-Cert-Expiration := "221204131436Z"
(7) eap_tls:   TLS-Cert-Valid-Since := "221005131436Z"
(7) eap_tls:   TLS-Cert-Subject :=  "/C=DE/ST=Berlin/L=Berlin/O=Rechnerbetriebsgruppe/emailAddress=admin@rbg.example/CN=Allm\\xC3\\x83\\xC2\\xA4chtige Rechnerbetriebgruppe ROOT"
(7) eap_tls:   TLS-Cert-Issuer := "/C=DE/ST=Berlin/L=Berlin/O=Rechnerbetriebsgruppe/emailAddress=admin@rbg.example/CN=Allm\\xC3\\x83\\xC2\\xA4chtige Rechnerbetriebgruppe ROOT"
(7) eap_tls:   TLS-Cert-Common-Name := "AllmÃ¤chtige Rechnerbetriebgruppe ROOT"
(7) eap_tls: TLS - Creating attributes from certificate OIDs
(7) eap_tls:   TLS-Client-Cert-Serial := "03"
(7) eap_tls:   TLS-Client-Cert-Expiration := "231005204308Z"
(7) eap_tls:   TLS-Client-Cert-Valid-Since := "221005204308Z"
(7) eap_tls:   TLS-Client-Cert-Subject := "/C=FR/ST=Radius/O=Example  Inc./CN=testing/emailAddress=testing@test.com"
(7) eap_tls:   TLS-Client-Cert-Issuer :=  "/C=DE/ST=Berlin/L=Berlin/O=Rechnerbetriebsgruppe/emailAddress=admin@rbg.example/CN=Allm\\xC3\\x83\\xC2\\xA4chtige Rechnerbetriebgruppe ROOT"
(7) eap_tls:   TLS-Client-Cert-Common-Name := "testing"
(7) eap_tls:   TLS-Client-Cert-X509v3-Extended-Key-Usage += "TLS Web Client Authentication"
(7) eap_tls:   TLS-Client-Cert-X509v3-Extended-Key-Usage-OID += "1.3.6.1.5.5.7.3.2"

Implementierung

Ein Programm schreiben, welches eine CSR erstellt, wobei der private key im TPM erstellt wird und anschließend eine wpa-supplicant config erstellt. Ähnlich wie hier nur für wired:

https://wiki.archlinux.org/title/wpa_supplicant

cat > wpa_supplicant.conf <<EOF
network={
    ssid="SSID"
    key_mgmt=WPA-EAP
    eap=TLS
    identity="testing"
    ca_cert="/etc/pki/SSID/ca.pem"
    client_cert="/etc/pki/SSID/client.crt"
    private_key="pkcs11:model=Intel;manufacturer=Intel;serial=0000000000000000;token=label;id=%32%62%37%30%65%62%36%32%66%33%32%62%31%63%65%37;object=0;type=private;pin-value=userpin"
}
EOF

Switch Config

Model: Netgear S350 8 Port PW: Radius#01

!
interface g1
 switchport hybrid allowed vlan add 10,20,50 tagged
 authentication port-control force-auth
!
interface g2
!
interface g3
 switchport hybrid pvid 10
 switchport hybrid allowed vlan add 10 untagged
!
interface g4
 switchport hybrid pvid 10
 switchport hybrid allowed vlan add 10 untagged
 switchport hybrid allowed vlan remove 1
 authentication unauth-vlan 20
!
interface g5
 authentication unauth-vlan 20
!
interface g6
!
interface g7
 switchport hybrid pvid 50
 switchport hybrid allowed vlan add 10,20 tagged
 switchport hybrid allowed vlan add 50 untagged
 switchport hybrid allowed vlan remove 1
 authentication port-control force-auth
!
interface g8
 switchport hybrid pvid 50
 switchport hybrid allowed vlan add 50 untagged
 switchport hybrid allowed vlan remove 1
 authentication port-control force-auth
!