Top-Themen

AppleEntwicklungHardwareInternetLinuxMicrosoftMultimediaNetzwerkeOff TopicSicherheitSonstige SystemeVirtualisierungWeiterbildungZusammenarbeit

Aktuelle Themen

Administrator.de FeedbackApache ServerAppleAssemblerAudioAusbildungAuslandBackupBasicBatch & ShellBenchmarksBibliotheken & ToolkitsBlogsCloud-DiensteClusterCMSCPU, RAM, MainboardsCSSC und C++DatenbankenDatenschutzDebianDigitiales FernsehenDNSDrucker und ScannerDSL, VDSLE-BooksE-BusinessE-MailEntwicklungErkennung und -AbwehrExchange ServerFestplatten, SSD, RaidFirewallFlatratesGoogle AndroidGrafikGrafikkarten & MonitoreGroupwareHardwareHosting & HousingHTMLHumor (lol)Hyper-VIconsIDE & EditorenInformationsdiensteInstallationInstant MessagingInternetInternet DomäneniOSISDN & AnaloganschlüsseiTunesJavaJavaScriptKiXtartKVMLAN, WAN, WirelessLinuxLinux DesktopLinux NetzwerkLinux ToolsLinux UserverwaltungLizenzierungMac OS XMicrosoftMicrosoft OfficeMikroTik RouterOSMonitoringMultimediaMultimedia & ZubehörNetzwerkeNetzwerkgrundlagenNetzwerkmanagementNetzwerkprotokolleNotebook & ZubehörNovell NetwareOff TopicOpenOffice, LibreOfficeOutlook & MailPapierkorbPascal und DelphiPeripheriegerätePerlPHPPythonRechtliche FragenRedHat, CentOS, FedoraRouter & RoutingSambaSAN, NAS, DASSchriftartenSchulung & TrainingSEOServerServer-HardwareSicherheitSicherheits-ToolsSicherheitsgrundlagenSolarisSonstige SystemeSoziale NetzwerkeSpeicherkartenStudentenjobs & PraktikumSuche ProjektpartnerSuseSwitche und HubsTipps & TricksTK-Netze & GeräteUbuntuUMTS, EDGE & GPRSUtilitiesVB for ApplicationsVerschlüsselung & ZertifikateVideo & StreamingViren und TrojanerVirtualisierungVisual StudioVmwareVoice over IPWebbrowserWebentwicklungWeiterbildungWindows 7Windows 8Windows 10Windows InstallationWindows MobileWindows NetzwerkWindows ServerWindows SystemdateienWindows ToolsWindows UpdateWindows UserverwaltungWindows VistaWindows XPXenserverXMLZusammenarbeit
GELÖST

Stateful Inspection mit FWbuilder und iptables

Frage Sicherheit Firewall

Mitglied: pkrix89

pkrix89 (Level 1) - Jetzt verbinden

12.11.2012, aktualisiert 12:36 Uhr, 2582 Aufrufe, 1 Kommentar

Hallo zusammen

ich verzweifle grad ein bisschen an meiner iptables-Firewall..

Szenario:
Ein Kunde bekommt von uns einen mobilen Router mit Stromversorgung über einen USB-Port, der "stealth" zwischen den Rechner und den Netzwerkport geschaltet wird. Der Rechner bekommt dann ganz normal eine IP via DHCP aus dem Netzwerk, in dem er lokal angeschlossen wurde. Der Router hingegen hat eine feste IP, mit der er eine VPN-Verbindung zu unserem Kundensupport-System aufbaut. Nun kann der Kunde, wenn er die richtige IP im Browser mit HTTPs eingibt, auf eine Webseite zugreifen, über die der Kunde einige Funktionen zur Verfügung gestellt bekommt.

Die Funktion, für die ich gerade eine (oder mehrere) Firewallregel(n) konfigurieren muss, bevor das produktiv geschaltet wird, ist die, dass der Kunde über das Webportal eine virtuelle Maschine starten kann. Auf diese kann er dann per VNC zugreifen, um an einer seiner Produktionsmaschinen (die wir bauen und verkaufen) Wartungsprogramme laufen zu lassen. Der Vorteil ist einfach, dass nicht wegen jeder "Kleinigkeit" ein Monteur zum Kunden geschickt werden muss. Zusätzlich kann der Kunde und auch gleichzeitig ein Mitarbeiter aus unserem technischen Support auf die VM schauen, um zusammen einem eventuellen Problem auf die Schliche zu kommen.

Da wir jedoch wesentlich viele Maschinen haben (es laufen immer nur einige wenige, jedoch halten wir viele auf Bedarf vor) werden die IP's der Maschinen via DHCP vergeben, was für mich die Firewallkonfiguration nicht unbedingt leichter macht ;)

Zielsetzung:
Ein fester Parameter, den ich für die von der Webseite dynamisch angepassten iptables-Firewall nutzen kann, ist natürlich die MAC-Adresse. Diese ist für jede VM in der Datenbank hinterlegt, um beispielsweise für Firewallregeln auf diese zurückgreifen zu können. Um nun den VNC-Zugriff auf diese Maschinen soweit einschränken zu können, dass der Kunde nur auf die ihm zugewiesenen VM's kommt, hatte ich mir überlegt, VNC-Anfragen (Syn) generell zu erlauben, und nur die Antwortpakete (ack) von der Firewall dynamisch durchzulassen oder eben zu verwerfen. Auf diese Idee bin ich gekommen, weil ich durch eine Recherche im Internet festgestellt habe, dass man bei iptables eine MAC-Adresse nur als Source angeben kann, leider nicht als Destination. Sollte für dieses Szenario jemand eine bessere Idee haben, bin ich gerne bereit darüber zu sprechen ;)

Problem:
Heute habe ich nach langem googlen (am Freitag hatte ich es aus Frust abgebrochen..) herausgefunden, dass der FWbuilder wohl ein Modul lädt, was automatisch für jede Regel entsprechende Regeln für die Antwortpakete erstellt, was ja auch erstmal ne super Sache ist, und die Konfiguration wesentlich vereinfacht. der Nachteil ist, dass diese Funktionalität für dieses eine Szenario sehr hinderlich ist. Wenn ich nun in Regel 16 die Verbindungsanfrage mit folgender Regel freischalte (gekürzt auf einen Kunden mit einer Maschine, um die Übersichtlichkeit nicht zu verlieren):
01.
$IPT="/sbin/iptables" 
02.
#Dem Kunden VNC-Anfragen gestatten: 
03.
$IPT -N Cid4937X3018.0 
04.
$IPT -a INPUT -i br3 -p tcp -m tcp -d 192.168.0.0/24 --dport 5900 -m state --state NEW -j Cid4937X3018.0 
05.
$IPT -N In_RULE_16 
06.
$IPT -A Cid4937X3018.0 -s 192.168.0.x -j In_RULE_16 
07.
# Für jeden Kunden eine Zeile, da ich VNC-SYN ja für die Kunden global freischalten lassen möchte 
08.
$IPT -N Cid4937X3018.1 
09.
$IPT -A FORWARD -i br3 -p tcp -m tcp -d 192.168.0.0/24 --dport 5900 -m state --state NEW -j Cid4937X3018.1 
10.
$IPT -A Cid4937X3018.1 -s 192.168.0.x -j In_RULE_16 
11.
# Für jeden Kunden eine Zeile, da ich VNC-SYN ja für die Kunden global freischalten lassen möchte 
12.
$IPT -A In_RULE_16 -j LOG --log-level info --log-prefix "RULE 16 -- ACCEPT " 
13.
$IPT -A In_RULE_16 -j ACCEPT
Diese Regel schaltet jedoch dummerweise auch automatisch durch dieses geladene Modul die Antwortpakete frei, was allerdings denkbar ungünstig ist, weil der Kunde A so beispielsweise auf die VM einer Maschine von Kunde B gelangen kann. Daher habe ich eine Regel für die Antwortpakete erstellt, die jedoch beim Compilieren im FWBuilder eine Fehlermeldung ausspuckt
01.
#Dem Kunden die VNC-Antworten SEINER VM's gestatten: 
02.
Firewall:Policy:17: error: TCPService object with option "established" is not dupportet by firewall platform "iptables". Use stateful rule instead.
Frage:
Welche Möglichkeiten habe ich nun, um dieses Szenario zu realisieren? Irgendwelche Ideen? (Am besten, ohne dass ich die ganzen anderern Regeln anfassen muss, weil das sind dann doch schon einige Hundert Zeilen Code -.-*

Von FWbuilder generierter Code (ohne die ganzen Regeln):
Anbei noch der Rest der Firewall-Konfiguration, die vom FWbuilder generiert wird. Ausgenommen habe ich sämtliche von mir erstellten Regeln, jedoch habe ich einen Hinweis an der Stelle eingebaut, wo normal das Regelwerk käme. Ich denke, dass das "Vorgeplänkel" vor dem Regelwerk bei der Problemlösung sinnvoll sein könnte. Also bei Bedarf stehen die folgenden 400 Zeilen zur Verfügung ;)
01.
FWBDEBUG="" 
02.
 
03.
PATH="/sbin:/usr/sbin:/bin:/usr/bin:${PATH}" 
04.
export PATH 
05.
 
06.
 
07.
 
08.
LSMOD="/sbin/lsmod" 
09.
MODPROBE="/sbin/modprobe" 
10.
IPTABLES="/usr/sbin/iptables" 
11.
IP6TABLES="/usr/sbin/ip6tables" 
12.
IPTABLES_RESTORE="/usr/sbin/iptables-restore" 
13.
IP6TABLES_RESTORE="/usr/sbin/ip6tables-restore" 
14.
IP="/sbin/ip" 
15.
IFCONFIG="/sbin/ifconfig" 
16.
VCONFIG="/sbin/vconfig" 
17.
BRCTL="/sbin/brctl" 
18.
IFENSLAVE="/sbin/ifenslave" 
19.
IPSET="/usr/sbin/ipset" 
20.
LOGGER="/usr/bin/logger" 
21.
 
22.
log() { 
23.
    echo "$1" 
24.
    command -v "$LOGGER" >/dev/null 2>&1 && $LOGGER -p info "$1" 
25.
26.
 
27.
getInterfaceVarName() { 
28.
    echo $1 | sed 's/\./_/' 
29.
30.
 
31.
getaddr_internal() { 
32.
    dev=$1 
33.
    name=$2 
34.
    af=$3 
35.
    L=$($IP $af addr show dev $dev |  sed -n '/inet/{s!.*inet6* !!;s!/.*!!p}' | sed 's/peer.*//') 
36.
    test -z "$L" && { 
37.
        eval "$name=''" 
38.
        return 
39.
40.
    eval "${name}_list=\"$L\"" 
41.
42.
 
43.
getaddr() { 
44.
    getaddr_internal $1 $2 "-4" 
45.
46.
 
47.
getaddr6() { 
48.
    getaddr_internal $1 $2 "-6" 
49.
50.
 
51.
# function getinterfaces is used to process wildcard interfaces 
52.
getinterfaces() { 
53.
    NAME=$1 
54.
    $IP link show | grep ": $NAME" | while read L; do 
55.
        OIFS=$IFS 
56.
        IFS=" :" 
57.
        set $L 
58.
        IFS=$OIFS 
59.
        echo $2 
60.
    done 
61.
62.
 
63.
diff_intf() { 
64.
    func=$1 
65.
    list1=$2 
66.
    list2=$3 
67.
    cmd=$4 
68.
    for intf in $list1 
69.
    do 
70.
        echo $list2 | grep -q $intf || { 
71.
        # $vlan is absent in list 2 
72.
            $func $intf $cmd 
73.
74.
    done 
75.
76.
 
77.
find_program() { 
78.
  PGM=$1 
79.
  command -v $PGM >/dev/null 2>&1 || { 
80.
    echo "$PGM not found" 
81.
    exit 1 
82.
83.
84.
check_tools() { 
85.
  find_program $IPTABLES 
86.
 find_program $MODPROBE 
87.
  find_program $IP 
88.
89.
reset_iptables_v4() { 
90.
  $IPTABLES -P OUTPUT  DROP 
91.
  $IPTABLES -P INPUT   DROP 
92.
  $IPTABLES -P FORWARD DROP 
93.
 
94.
cat /proc/net/ip_tables_names | while read table; do 
95.
  $IPTABLES -t $table -L -n | while read c chain rest; do 
96.
      if test "X$c" = "XChain" ; then 
97.
        $IPTABLES -t $table -F $chain 
98.
      fi 
99.
  done 
100.
  $IPTABLES -t $table -X 
101.
done 
102.
103.
 
104.
reset_iptables_v6() { 
105.
  $IP6TABLES -P OUTPUT  DROP 
106.
  $IP6TABLES -P INPUT   DROP 
107.
  $IP6TABLES -P FORWARD DROP 
108.
 
109.
cat /proc/net/ip6_tables_names | while read table; do 
110.
  $IP6TABLES -t $table -L -n | while read c chain rest; do 
111.
      if test "X$c" = "XChain" ; then 
112.
        $IP6TABLES -t $table -F $chain 
113.
      fi 
114.
  done 
115.
  $IP6TABLES -t $table -X 
116.
done 
117.
118.
 
119.
 
120.
P2P_INTERFACE_WARNING="" 
121.
 
122.
missing_address() { 
123.
    address=$1 
124.
    cmd=$2 
125.
 
126.
    oldIFS=$IFS 
127.
    IFS="@" 
128.
    set $address 
129.
    addr=$1 
130.
    interface=$2 
131.
    IFS=$oldIFS 
132.
 
133.
 
134.
 
135.
    $IP addr show dev $interface | grep -q POINTOPOINT && { 
136.
        test -z "$P2P_INTERFACE_WARNING" && echo "Warning: Can not update address of interface $interface. fwbuilder can not manage addresses of point-to-point interfaces yet" 
137.
        P2P_INTERFACE_WARNING="yes" 
138.
        return 
139.
140.
 
141.
    test "$cmd" = "add" && { 
142.
      echo "# Adding ip address: $interface $addr" 
143.
      echo $addr | grep -q ':' && { 
144.
          $FWBDEBUG $IP addr $cmd $addr dev $interface 
145.
      } || { 
146.
          $FWBDEBUG $IP addr $cmd $addr broadcast + dev $interface 
147.
148.
149.
 
150.
    test "$cmd" = "del" && { 
151.
      echo "# Removing ip address: $interface $addr" 
152.
      $FWBDEBUG $IP addr $cmd $addr dev $interface || exit 1 
153.
154.
 
155.
    $FWBDEBUG $IP link set $interface up 
156.
157.
 
158.
list_addresses_by_scope() { 
159.
    interface=$1 
160.
    scope=$2 
161.
    ignore_list=$3 
162.
    $IP addr ls dev $interface | \ 
163.
      awk -v IGNORED="$ignore_list" -v SCOPE="$scope" \ 
164.
        'BEGIN { 
165.
           split(IGNORED,ignored_arr); 
166.
           for (a in ignored_arr) {ignored_dict[ignored_arr[a]]=1;} 
167.
168.
         (/inet |inet6 / && $0 ~ SCOPE && !($2 in ignored_dict)) {print $2;}' | \ 
169.
        while read addr; do 
170.
          echo "${addr}@$interface" 
171.
        done | sort 
172.
173.
 
174.
 
175.
update_addresses_of_interface() { 
176.
    ignore_list=$2 
177.
    set $1 
178.
    interface=$1 
179.
    shift 
180.
 
181.
    FWB_ADDRS=$( 
182.
      for addr in $*; do 
183.
        echo "${addr}@$interface" 
184.
      done | sort 
185.
186.
 
187.
    CURRENT_ADDRS_ALL_SCOPES="" 
188.
    CURRENT_ADDRS_GLOBAL_SCOPE="" 
189.
 
190.
    $IP link show dev $interface >/dev/null 2>&1 && { 
191.
      CURRENT_ADDRS_ALL_SCOPES=$(list_addresses_by_scope $interface 'scope .*' "$ignore_list") 
192.
      CURRENT_ADDRS_GLOBAL_SCOPE=$(list_addresses_by_scope $interface 'scope global' "$ignore_list") 
193.
    } || { 
194.
      echo "# Interface $interface does not exist" 
195.
      # Stop the script if we are not in test mode 
196.
      test -z "$FWBDEBUG" && exit 1 
197.
198.
 
199.
    diff_intf missing_address "$FWB_ADDRS" "$CURRENT_ADDRS_ALL_SCOPES" add 
200.
    diff_intf missing_address "$CURRENT_ADDRS_GLOBAL_SCOPE" "$FWB_ADDRS" del 
201.
202.
 
203.
clear_addresses_except_known_interfaces() { 
204.
    $IP link show | sed 's/://g' | awk -v IGNORED="$*" \ 
205.
        'BEGIN { 
206.
           split(IGNORED,ignored_arr); 
207.
           for (a in ignored_arr) {ignored_dict[ignored_arr[a]]=1;} 
208.
209.
         (/state/ && !($2 in ignored_dict)) {print $2;}' | \ 
210.
         while read intf; do 
211.
            echo "# Removing addresses not configured in fwbuilder from interface $intf" 
212.
            $FWBDEBUG $IP addr flush dev $intf scope global 
213.
            $FWBDEBUG $IP link set $intf down 
214.
         done 
215.
216.
 
217.
check_file() { 
218.
    test -r "$2" || { 
219.
        echo "Can not find file $2 referenced by address table object $1" 
220.
        exit 1 
221.
222.
223.
 
224.
check_run_time_address_table_files() { 
225.
226.
 
227.
228.
 
229.
load_modules() { 
230.
231.
    OPTS=$1 
232.
    MODULES_DIR="/lib/modules/`uname -r`/kernel/net/" 
233.
    MODULES=$(find $MODULES_DIR -name '*conntrack*' \! -name '*ipv6*'|sed  -e 's/^.*\///' -e 's/\([^\.]\)\..*/\1/') 
234.
    echo $OPTS | grep -q nat && { 
235.
        MODULES="$MODULES $(find $MODULES_DIR -name '*nat*'|sed  -e 's/^.*\///' -e 's/\([^\.]\)\..*/\1/')" 
236.
237.
    echo $OPTS | grep -q ipv6 && { 
238.
        MODULES="$MODULES $(find $MODULES_DIR -name nf_conntrack_ipv6|sed  -e 's/^.*\///' -e 's/\([^\.]\)\..*/\1/')" 
239.
240.
    for module in $MODULES; do 
241.
        if $LSMOD | grep ${module} >/dev/null; then continue; fi 
242.
        $MODPROBE ${module} ||  exit 1 
243.
    done 
244.
245.
 
246.
verify_interfaces() { 
247.
248.
    echo "Verifying interfaces: br0 br2 br3 br4 lo" 
249.
    for i in br0 br2 br3 br4 lo ; do 
250.
        $IP link show "$i" > /dev/null 2>&1 || { 
251.
            log "Interface $i does not exist" 
252.
            exit 1 
253.
254.
    done 
255.
256.
 
257.
prolog_commands() { 
258.
    echo "Running prolog script" 
259.
 
260.
261.
 
262.
epilog_commands() { 
263.
    echo "Running epilog script" 
264.
 
265.
266.
 
267.
run_epilog_and_exit() { 
268.
    epilog_commands 
269.
    exit $1 
270.
271.
 
272.
configure_interfaces() { 
273.
274.
    # Configure interfaces 
275.
    update_addresses_of_interface "br0 172.16.0.x/24" "" 
276.
    update_addresses_of_interface "br2 172.17.0.y/24" "" 
277.
    update_addresses_of_interface "br3 192.168.0.x/24" "" 
278.
    update_addresses_of_interface "lo 127.0.0.1/8" "" 
279.
280.
 
281.
script_body() { 
282.
    # ================ IPv4 
283.
 
284.
############################################## 
285.
############################################## 
286.
#                                            # 
287.
#           Regelwerk weggelassen            # 
288.
#                                            # 
289.
############################################## 
290.
############################################## 
291.
 
292.
ip_forward() { 
293.
294.
    echo 1 > /proc/sys/net/ipv4/ip_forward 
295.
296.
 
297.
reset_all() { 
298.
299.
    reset_iptables_v4 
300.
301.
 
302.
block_action() { 
303.
    reset_all 
304.
305.
 
306.
stop_action() { 
307.
    reset_all 
308.
    $IPTABLES -P OUTPUT  ACCEPT 
309.
    $IPTABLES -P INPUT   ACCEPT 
310.
    $IPTABLES -P FORWARD ACCEPT 
311.
312.
 
313.
check_iptables() { 
314.
    IP_TABLES="$1" 
315.
    [ ! -e $IP_TABLES ] && return 151 
316.
    NF_TABLES=$(cat $IP_TABLES 2>/dev/null) 
317.
    [ -z "$NF_TABLES" ] && return 152 
318.
    return 0 
319.
320.
status_action() { 
321.
    check_iptables "/proc/net/ip_tables_names" 
322.
    ret_ipv4=$? 
323.
    check_iptables "/proc/net/ip6_tables_names" 
324.
    ret_ipv6=$? 
325.
    [ $ret_ipv4 -eq 0 -o $ret_ipv6 -eq 0 ] && return 0 
326.
    [ $ret_ipv4 -eq 151 -o $ret_ipv6 -eq 151 ] && { 
327.
        echo "iptables modules are not loaded" 
328.
329.
    [ $ret_ipv4 -eq 152 -o $ret_ipv6 -eq 152 ] && { 
330.
        echo "Firewall is not configured" 
331.
332.
    exit 3 
333.
334.
 
335.
# See how we were called. 
336.
# For backwards compatibility missing argument is equivalent to 'start' 
337.
 
338.
cmd=$1 
339.
test -z "$cmd" && { 
340.
    cmd="start" 
341.
342.
 
343.
case "$cmd" in 
344.
    start) 
345.
        log "Activating firewall script by FWbuilder" 
346.
        check_tools 
347.
         prolog_commands 
348.
        check_run_time_address_table_files 
349.
 
350.
        load_modules " " 
351.
        configure_interfaces 
352.
        verify_interfaces 
353.
 
354.
         reset_all 
355.
 
356.
        script_body 
357.
        ip_forward 
358.
        epilog_commands 
359.
        RETVAL=$? 
360.
        ;; 
361.
 
362.
    stop) 
363.
        stop_action 
364.
        RETVAL=$? 
365.
        ;; 
366.
 
367.
    status) 
368.
        status_action 
369.
        RETVAL=$? 
370.
        ;; 
371.
 
372.
    block) 
373.
        block_action 
374.
        RETVAL=$? 
375.
        ;; 
376.
 
377.
    reload) 
378.
        $0 stop 
379.
        $0 start 
380.
        RETVAL=$? 
381.
        ;; 
382.
 
383.
    interfaces) 
384.
        configure_interfaces 
385.
        RETVAL=$? 
386.
        ;; 
387.
 
388.
    test_interfaces) 
389.
        FWBDEBUG="echo" 
390.
        configure_interfaces 
391.
        RETVAL=$? 
392.
        ;; 
393.
 
394.
    *) 
395.
        echo "Usage $0 [start|stop|status|block|reload|interfaces|test_interfaces]" 
396.
        ;; 
397.
 
398.
esac 
399.
 
400.
exit $RETVAL
Bin für jede Hilfe Dankbar!!

Viele Grüße pkrix89
Mitglied: pkrix89
16.11.2012 um 07:57 Uhr
Hallo zusammen,

ich habe das Problem endlich lösen können, und möchte euch an meiner Lösung teilhaben lassen ;)

Der FWbuilder hat die doofe Angewohnheit, noch vor das eigentliche Regelwerk folgende 3 Regeln zu setzen:
01.
    $IPTABLES -A INPUT   -m state --state ESTABLISHED,RELATED -j ACCEPT 
02.
    $IPTABLES -A OUTPUT  -m state --state ESTABLISHED,RELATED -j ACCEPT 
03.
    $IPTABLES -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
Diese Regeln bewirken, dass alle Pakete, die auf eine erlaubte Verbindungsanfrage (SYN) gesendet werden, automatisch gestattet werden. Dazu zählt natürlich auch die gesamte Kommunikation nach erfolgreichem Verbindungsaufbau.

Diese 3 Regeln habe ich nun an das Ende des Firewallscripts gepackt (direkt vor die DENY-ALL-Regel), und siehe da, das SYN-Paket wird durchgelassen, das ACK nur von den Clients, von denen ich es möchte. Einziger Nachteil: Es wurden auch noch ein paar andere Antwortpakete der betreffenden Hosts geblockt. Diese waren jedoch über das Firewall-Logfile leicht auszumachen und anschließend in dem Script nachzutragen. Im Großen und Ganzen war es sehr viel Aufwand für eine Kleinigkeit -.-*

Ich hoffe, ich konnte nachvollziehbar machen, was ich meine, und auch vielleicht dem Einen oder Anderen einen Nützlichen Hinweis liefern ;)

Vielen Dank für die vielen Aufrufe, auch wenn keiner etwas geantwortet hat ;)

Grüße, pkrix89
Bitte warten ..
Neuester Wissensbeitrag
Windows 10

Powershell 5 BSOD

(8)

Tipp von agowa338 zum Thema Windows 10 ...

Heiß diskutierte Inhalte
LAN, WAN, Wireless
gelöst Server erkennt Client nicht wenn er ausserhalb des DHCP Pools liegt (28)

Frage von Mar-west zum Thema LAN, WAN, Wireless ...

Microsoft
Ordner mit LW-Buchstaben versehen und benennen (19)

Frage von Xaero1982 zum Thema Microsoft ...

Outlook & Mail
gelöst Outlook 2010 findet ost datei nicht (19)

Frage von Floh21 zum Thema Outlook & Mail ...

Windows Server
Server 2008R2 startet nicht mehr (Bad Patch 0xa) (18)

Frage von Haures zum Thema Windows Server ...