=Download=
https://my.vmware.com/group/vmware/details?downloadGroup=VSP510-VCLI-510&productId=285

oder

cp /export/share/tmp/VMware-vSphere-CLI-5.1.0-780721.x86_64.tar.gz

=Vorbereitung=
apt-get install libssl-dev perl-doc libxml-libxml-perl

=Entpacken=
tar -xvzf VMware-vSphere-CLI-5.1.0-780721.x86_64.tar.gz
=Installieren=
cd vmware-vsphere-cli-distrib/
sed -ie "s/proxy =0/proxy =1/" vmware-install.pl
./vmware-install.pl

=Anpassungen=
==.profle==
echo "export PERL_LWP_SSL_VERIFY_HOSTNAME=0" >> ~/.profile
=.visdkrc=
cat ~/.visdkrc
VI_SERVER = 192.168.240.40
VI_USERNAME = root
VI_PASSWORD = sysadm
VI_PROTOCOL = https
VI_PORTNUMBER = 443

=backup=
vicfg-cfgbackup --username root -password 'geheim' -server canceron -s canceron.cfg.tgz

VMware vSphere CLI 5.1

2012-12-13T15:11:32Z

192.168.242.1: /* Download */

IPTables - from scratch

2012-12-03T14:11:01Z

192.168.242.1: /* Regeln */

==Die Verwendung von Firewalls mit iptables==

Der Linux-Kernel enthält fortgeschrittene Tools für Packet-Filtering, der Prozess für die Kontrolle von Netzwerkpaketen bei ihrem Versuch einzudringen, durch und aus dem System hinaus zu dringen. Kernels vor der 2.4 Version konnten Pakete mit ipchains manipulieren, die Listen von Regeln verwendeten, die für Pakete in jeder Phase des Filterungsprozesses angewandt werden. Die Einführung des 2.4-Kernels hat iptables mit sich gebracht, die den ipchains gleichen, aber deren Wirkungsbereich und Kontrollmöglichkeiten bei der Filterung von Paketen erweitern.

==iptables Allgemein==

Iptables beinhaltet das englische Wort tables, was für Tabellen steht, und genauso kann man es sich auch vorstellen, denn in seinen 3 Tabellen sammeln sich die Ketten in denen Regeln zum Kontrollieren, Manipulieren oder Extrahieren von Paketen angegeben werden.

===Tabellen===
Wie Pakete verarbeitet werden wird schon in den Tabellen vorgegeben. iptables besitzt standardmäßig drei Tabellen: '''mangle''', '''nat''' und '''filter'''.

Die Tabelle '''mangle''' (übersetzt: zerhauen) ermöglicht es dem Kernel, Daten im Paket-Header zu verändern.

'''NAT''' wird benutzt um interne und externe IP-Adressen zu übersetzen (= '''N'''etwork '''A'''dress '''T'''ranslation). Regeln in dieser Tabelle ändern die IP und/oder den Port des Ziels.

Die Tabelle '''filter''' prüft alle für die Firewall ankommenden Pakete und entscheidet ob sie durchgelassen oder geblockt werden.

Jede dieser Tabellen besitzt nun mehrere Ketten:
:'''mangle''' (Paketmanipulationen): enthält alle Ketten
:'''nat''' (Network Adress Translation): enthält die Ketten PREROUTING, OUTPUT und POSTROUTING
:'''filter''' (Paketfilter): enthält die Ketten FORWARD, INPUT und OUTPUT

===Ketten===
Die Ketten sind eine Sammlung von Regeln. D.h. das jede Kette mehrere Regeln besitzen kann um ein Paket durchzulassen oder zu blockieren. Es sind fünf Typen von Standardketten vorhanden. Manche dieser Ketten werden von allen Paketen und einige nur, je nachdem welches Ziel sie haben, durchlaufen. Man könnte auch sagen die Ketten unterscheiden '''wo''' welche Regeln angewendet werden. Die Regeln einer Kette werden nacheinander abgearbeitet und wenn eine zutrifft, ist die Bearbeitung in dieser Kette beendet (es gibt Ausnahmen):

*'''PREROUTING''': alle Pakete kommen hier durch bevor eine Routing-Entscheidung getroffen wird
*'''FORWARD''': für alle Pakete, die von der einen zu einer anderen Netzwerkschnittstelle weitergeleitet werden - also keine Pakete die an einen lokalen Dienst gerichtet sind
*'''INPUT''': für Pakete die über eine Schnittstelle hereinkommen und einen Dienst auf dem Rechner ansprechen
*'''OUTPUT''': für die über eine Schnittstelle herausgehenden Pakete, die von einem lokalen Dienst kommen
*'''POSTROUTING''': alle Pakete kommen am Ende der Verarbeitung hier durch

===Regeln===

Mit einer Regel wird entschieden was mit einem Paket passieren soll. Jede besitzt bestimmte Parameter nach denen sie überprüft ob die Informationen eines Paketes auf sie zutreffen. Wenn die Parameter zutreffend sind, wird das Paket meist an ein neues Ziel verwiesen oder es wird eine Methode angewandt. Für die Bearbeitung der Pakete gibt es mehrere Ziele und Methoden. Häufig benutzte sind:

*'''ACCEPT''': das Paket kann passieren
*'''REJECT''': das Paket wird zurückgewiesen und ein Fehlerpaket wird gesendet
*'''LOG''': schreibt einen Eintrag in die syslog
*'''DROP''': das Paket wird ignoriert und keine Antwort gesendet
*'''REDIRECT''': die Ziel-Adresse des Paketes wird hiermit so verändert, dass es zum lokalen Rechner gesendet wird
*'''MASQUERADE''': die Quell-Adresse des Paketes wird durch die IP-Adresse der Schnittstelle ersetzt, auf dem es den Rechner verlässt
*'''SNAT'''
*'''DNAT'''

----

Somit funktioniert iptables wie eine Art Sammlung von Schablonen die nacheinander auf ein Paket abgebildet werden und bei einem Treffer eine bestimmte Aktion auf das Paket ausführen. Falls keine der Schablonen passen sollte wird eine Standard Aktion ausgeführt die für alle Pakete gilt die nicht auf eine Schablone passen.

Konzept-Bild

[[file:iptables-konzept.jpeg|750px]]

===Syntax Allgemein===

Wie schon zu erwarten bedient man iptables mit dem Befehl '''iptables'''. Folgende Dinge sind vorab zu beachten:

Die Momentan in der '''filter''' Tabelle gesetzten Ketten und Regeln kann man sich mit
root@hutze:~# iptables -L
ausgeben lassen, wobei man die Ausgabe noch mit den Operanden
-n # für numerical
-v # für verbose
erweitern kann.

Dabei ist es wichtig zu bemerken das jede iptables zeile ohne '''-t''' option von einem '''-t filter''' ausgeht.
Was bedeutet das es die Filter Tabelle geschrieben wird.
Um die anderen Tabellen zu schreiben braucht man '''-t nat''' und '''-t mangle'''

Die 3 Tabellen von iptables spricht man jeweils mit
iptables ['''-t filter''']
iptables '''-t nat'''
iptables '''-t mangle'''
an.

Jeder dieser Tabellen Angaben folgt für gewöhnlich eine Kette. Diese sind: '''INPUT''' '''OUTPUT''' und '''FORWARD''' sowie ausschließlich für ''nat'' und ''mangle'' auch '''PREROUTING''' und '''POSTROUTING'''. Und müssen mit dem davor stehenden Operanden '''-A''' ( '''A'''ppend - englisch für Anhängen ) definiert werden.

Beispiele:
iptables -A '''INPUT'''
iptables -t nat -A '''POSTROUTING'''

Wenn man also Regeln aufstellen will muss man immer die Tabelle und das dazugehörige Kettenglied übergeben, damit der Router genau weiß was wo zu tun ist.

Die Tabellen und Regeln von iptables könnte man theoretisch auch alle einzeln nacheinander in der Konsole eingeben was aber nicht ganz Sinn der Sache ist. Also bedienen wir uns für unsere Firewall einem simplen Bash-Skript.

==Positionierung der Firewall==

Eine Firewall kann man unter Linux ganz einfach mit einem vi-Dokument beginnen. Damit die daraus entstehende Firewall auch ausgeführt wird müssen wir es in den entsprechenden Verzeichnissen vermerken. Das Skript selbst sollte nach '''/etc/init.d/''' mit einem '''softlink''' mit dem '''prefix "S99"''' in '''/etc/rc2.d''' damit es beim Starten automatisch ausgeführt wird.
root@hutze:~# touch firewall
root@hutze:~# mv firewall /etc/init.d
root@hutze:~# ln -s /etc/init.d/firewall /etc/rc2.d/S99firewall

==Der Rumpf==
Zuerst wird in dem firewall-Skript ein case start - stop Block angelegt:

'''#!/bin/bash'''
'''case $1 in'''
'''start)'''
'''echo "starte firewall"'''
''';;'''
'''stop)'''
'''echo "stoppe firewall"'''
''';;'''
'''*)'''
'''echo "usage: $0 start|stop"'''
''';;'''
'''esac'''

==Filter Tabelle==
Beginnen wir unsere Firewall mit ihrer simpelsten Funktion: dem Paketfilter.
===Flushing===

Bevor wir unsere eigenen Regeln entwerfen, sollten wir sichergehen das sich keine alten Regeln einschleichen und zu unerwarteten Komplikationen führen.
Dieses wird durch das sogenannte "flushing" erreicht, welches mit folgender Zeile geschieht:
#!/bin/bash
case $1 in
start)
echo "starte firewall"
'''iptables -F'''
;;
stop)
echo "stoppe firewall"
'''iptables -F'''
;;
esac

Ohne flushing kann es auch passieren das sich unsere Regeln bei jedem Neustart der Firewall addieren.

;Verwendete Syntax
:Der Operand '''-F''' löst das flushing aus mit dem alle Regeln in der angegebenen Tabelle ( hier "-t filter" da keine angegeben ) entfernt werden

;Wichtig
:Wenn man zukünftig auch Regeln in die ''nat'' und ''mangle'' Tabellen schreiben möchte, muss man dazu sichergehen das auch diese bei jedem Start und Stop jeweils geflusht werden damit keine Komplikationen entstehen.

===Default policy===

Als nächstes definieren wir was passieren soll falls keine unserer Regeln zutreffen sollte, auch gennannt '''"default policy"'''

Dies geschieht mit folgenden Zeilen:

#!/bin/bash
case $1 in
start)
echo "starte firewall"
iptables -F
'''iptables -P INPUT DROP'''
'''iptables -P OUTPUT DROP'''
'''iptables -P FORWARD DROP'''
;;
stop)
echo "stoppe firewall"
iptables -F
'''iptables -P INPUT ACCEPT'''
'''iptables -P OUTPUT ACCEPT'''
'''iptables -P FORWARD ACCEPT'''
;;
esac

;Verwendete Syntax
:Wie in Syntax Allgemein angegeben muss die '''"default policy"''' auf alle 3 Anlaufstellen angewendet werden.
:Nach der Anlaufstelle geben wir an was mit den Paketen zu tun ist.
:Mit '''DROP''' lässt die gestartete Firewall alle Pakete fallen die nicht auf eine Regel passen.
:Mit '''ACCEPT''' lässt die gestoppte Firewall alle Pakete durch.

===ESTABLISHED und RELATED Pakete===

Ein Vorteil von iptables zu seinen Vorgängern ist die Funktion seinen Paketfilter nur auf die ersten Pakete einer Verbindung zu begrenzen und so Ressourcen zu sparen.

Dieses wird erreicht mit folgenden Zeilen

#!/bin/bash
case $1 in
start)
echo "starte firewall"
iptables -F
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
'''iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT'''
'''iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT'''
'''iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT'''
;;
stop)
echo "stoppe firewall"
iptables -F
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
;;
esac

;Verwendete Syntax
:Die neuen Funktionen die wir hier verwenden beinhalten:
:'''-m state''': Das Modul von iptables das erkennt ob ein Paket eine Verbindung initiiert oder zu einer bereits errichteten Verbindung gehört.
:'''--state ESTABLISHED,RELATED''': Der Status nach dem das Paket untersucht wird, wobei
:'''ESTABLISHED''': Für alle Pakete steht die nicht das erste Paket einer Verbindung ist die in beide Richtungen sendet. (TCP)
:'''RELATED''': Für alle Pakete steht die eine 2t Verbindung öffnen wollen. (FTP,ICMP)
:'''-j ACCEPT''': Benutzt die angegebene Operation auf das Paket, hier ACCEPT.

===loopback device===

Nun haben wir schon ein paar Regeln aber noch keine die bisher zutreffen kann. Wenn wir diese Firewall aktivieren würden wäre unser eigener Router Nichtmal mehr in der Lage mit sich selbst zu kommunizieren. Da er dies über das sogennante '''"loopback device"''' lassen wir jetzt unsere ersten Pakete durch.

#!/bin/bash
case $1 in
start)
echo "starte firewall"
iptables -F
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
'''iptables -A OUTPUT -o lo -j ACCEPT'''
'''iptables -A INPUT -i lo -j ACCEPT'''
;;
stop)
echo "stoppe firewall"
iptables -F
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
;;
esac

;Verwendete Syntax
:Hier geben wir nun zum ersten mal zur Anlaufstelle auch das jeweilige Interface das angelaufen wird mit an:
:Mit '''-o lo''' beschreiben wir als ''output'' also Ausgang die Schnittstelle ''lo'' was für das loopback device steht
:Genauso '''-i lo''' wobei lo hier als Eingang angegeben wird. In einem Satz:
:Alle Pakete die von unserem Router aus lo Ausgehen durchlassen
:Alle Pakete die an unserem Router an lo Ankommen durchlassen

===Fernwartung===

Angenommen unser Router mit der Firewall steht nicht im selben Netz wie unser üblicher Arbeitsrechner, ist es von Vorteil auch von außen auf ihn zugreifen zugreifen zu können. In unserem Beispiel ist das äußere Netz auch ein LAN.
#!/bin/bash
case $1 in
start)
echo "starte firewall"
iptables -F
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
iptables -A INPUT -i lo -j ACCEPT
'''iptables -A INPUT -i eth0 -s 192.168.241.10 -p tcp --dport 22 -m state --state NEW -j ACCEPT'''
;;
stop)
echo "stoppe firewall"
iptables -F
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
;;
esac

;Verwendete Syntax
:'''-s''': Passt auf die angegebene Quell IP-Adresse, hier 192.168.241.10
:'''-p''': Passt auf ein Protokoll, hier tcp
:'''-dport''': Passt auf Ziel Port, hier 22 (ssh)
:'''--state NEW''': Passt auf Pakete die eine Verbindung Initiieren

===DNS-Server und HTTP===

Jetzt möchten wir mit unserem Router ins Internet gehen können. Dazu müssen wir 2 Dinge tun, zuerst müssen wir erlauben das er auf DNS-Server zugreifen kann.

#!/bin/bash
case $1 in
start)
echo "starte firewall"
iptables -F
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -i eth0 -s 192.168.241.10 -p tcp --dport 22 -m state --state NEW -j ACCEPT
'''iptables -A OUTPUT -o eth0 -p tcp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT'''
'''iptables -A OUTPUT -o eth0 -p udp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT'''
;;
stop)
echo "stoppe firewall"
iptables -F
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
;;
esac

;Verwendete Syntax
:'''-d''': Das selbe Prinzip wie auch bei '''-s''' aber auf eine Ziel Adresse
----
Dann müssen wir auch noch eine Regel für HTTP aufstellen damit wir auch Internetseiten aufrufen dürfen
#!/bin/bash
case $1 in
start)
echo "starte firewall"
iptables -F
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -i eth0 -s 192.168.241.10 -p tcp --dport 22 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p udp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
'''iptables -A OUTPUT -o eth0 -p tcp --dport 80 -m state --state NEW -j ACCEPT'''
;;
stop)
echo "stoppe firewall"
iptables -F
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
;;
esac

===ICMP===

Jetzt wollen wir testen können ob unser Router erreichbar ist. Dazu müssen wir ICMP freischalten
#!/bin/bash
case $1 in
start)
echo "starte firewall"
iptables -F
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -i eth0 -s 192.168.241.10 -p tcp --dport 22 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p udp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp --dport 80 -m state --state NEW -j ACCEPT
'''iptables -A INPUT -i eth0 -p icmp --icmp-type 8 -j ACCEPT'''
;;
stop)
echo "stoppe firewall"
iptables -F
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
;;
esac

;Verwendete Syntax
:'''--icmp-type 8''' Beschränkt erlaubte ICMP Pakete auf typ 8 ( echo )

==NAT Tabelle==

NAT steht für Network Address Translation, also eine Übersetzung von Netzwerk Adressen, sei es in Namen oder auch einfach nur in andere IP-Adressen. Iptables kann diesen Job übernehmen und zwar auf verschiedene Art und Weise.

;Wichtig
:Da wir nun beginnen NAT regeln in die firewall zu schreiben dürfen wir nicht vergessen die Zeile zum flushen eben jener hinzuzufügen

===MASQUERADE===

Masquerading ist wohl die simpelste Form von NAT, hiermit ersetzt der Router einfach jede Quell IP-Adresse jedes zu routenden Paketes mit seiner eigenen, sowie bei einem Antwort Paket die Ziel Adresse wieder mit der Original Quell Adresse.In iptables erreicht man diese Funktion mit folgender Zeile
#!/bin/bash
case $1 in
start)
echo "starte firewall"
iptables -F
'''iptables -F -t nat'''
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -i eth0 -s 192.168.241.10 -p tcp --dport 22 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p udp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp --dport 80 -m state --state NEW -j ACCEPT
iptables -A INPUT -i eth0 -p icmp --icmp-type 8 -j ACCEPT
'''iptables -t nat -A POSTROUTING -j MASQUERADE -o eth0 -s 172.23.242.0/24'''
;;
stop)
echo "stoppe firewall"
iptables -F
'''iptables -F -t nat'''
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
;;
esac

;Verwendete Syntax
:'''-t nat''': Hier sehen wir zum ersten mal wie man eine andere Tabelle außer Filter anspricht
:'''POSTROUTING''': Damit der Router weiß das er den Adressen Tausch NACH dem Routing ausführen soll
:'''-j MASQUERADE''': Eine weitere Aktion die auf ein Paket ausgeführt werden kann, hier unser NAT
:'''-s 172.23.242.0/24''': Hier wird nicht nur eine IP-Adresse, sondern ein ganzer Netzbereich als Quelle angegeben

===SNAT===

SNAT ist Masquerading sehr ähnlich, der einzige Unterschied besteht darin das man sich bei SNAT die ersetzende IP-Adresse wählen kann. Da wir schon Masquerading eingebaut haben, hängen wir SNAT nicht auch noch mit in unsere Firewall.

Hier aber ein Beispiel:
iptables -t nat -A POSTROUTING -j SNAT -o eth0 -s 172.23.242.0/24 --to-source 192.168.242.100

;Verwendete Syntax
:'''-j SNAT''': Die auszuführende Aktion, hier SNAT
:'''--to-source 192.168.242.100''': Die Angabe zu welcher IP-Adresse ersetzt wird, hier die des Routers.

===NETMAP===

Eine weiter Form des NAT in iptables ist NETMAP. Statt wie bei MASQUERADE oder SNAT, ersetzt NETMAP die Quell Adresse nicht nur mit einer bestimmten Adresse, sondern bildet das gesamte Quell Netz auf ein anderes ab.

Beispiel:
iptables -t nat -A POSTROUTING -j NETMAP -o eth0 -s 172.23.242.0/24 --to 195.145.95.0/24

;Verwendete Syntax
:'''-j NETMAP''': Aktion die auf Pakete ausgeführt wird, hier NETMAP
:

===DNAT, port forwarding===

Da das interne Netz nicht von außen angesprochen werden kann, wie es bei normalen Routern die ins Internet führen ja auch der Fall ist, bedient man sich hierfür einer Technik namens port forwarding, was bedeutet das ein Programm das über einen bestimmten Port mit dem Router kommuniziert an eine andere IP-Adresse und einen anderen Port weitergeleitet wird.
#!/bin/bash
case $1 in
start)
echo "starte firewall"
iptables -F
iptables -F -t nat
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -i eth0 -s 192.168.241.10 -p tcp --dport 22 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p udp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp --dport 80 -m state --state NEW -j ACCEPT
iptables -A INPUT -i eth0 -p icmp --icmp-type 8 -j ACCEPT
iptables -t nat -A POSTROUTING -j MASQUERADE -o eth0 -s 172.23.242.0/24
'''iptables -t nat -A PREROUTING -j DNAT -i eth0 --dport 3333 --to-dest 172.23.242.100:22'''
;;
stop)
echo "stoppe firewall"
iptables -F
iptables -F -t nat
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
;;
esac

;Verwendete Syntax
:'''PREROUTING''': Paket wird nach der Routingentscheidung geändert
:'''-j DNAT''': Aktion die auf Pakete ausgeführt wird, hier DNAT
:'''--to-dest 172.23.242.100:22''': IP-Adresse und Port zu denen weitergeleitet wird
:In einem Satz:
:Ändere bei allen Paketen die auf eth0 ankommen und den Port 3333 ansprechen die Ziel Adresse zu 172.23.242.100 und Port zu 22

==Logging==

Damit wir sehen können was so alles an unserer Firewall abprallt, nicht nur um Störenfriede zu erkennen, sondern auch um zu sehen was wir vielleicht für uns freischalten müssen, können wir ein logging einrichten das automatisch alle Pakete die nicht durchgelassen wurden an den syslog deamon weitergeben der die Vorkommnisse in die syslog schreibt.
#!/bin/bash
case $1 in
start)
echo "starte firewall"
iptables -F
iptables -F -t nat
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -i eth0 -s 192.168.241.10 -p tcp --dport 22 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p udp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp --dport 80 -m state --state NEW -j ACCEPT
iptables -A INPUT -i eth0 -p icmp --icmp-type 8 -j ACCEPT
iptables -t nat -A POSTROUTING -j MASQUERADE -o eth0 -s 172.23.242.0/24
iptables -t nat -A PREROUTING -j DNAT -i eth0 --dport 3333 --to-dest 172.23.242.100:22
'''iptables -A INPUT -j LOG --log-prefix "--iptables-in--"'''
'''iptables -A OUTPUT -j LOG --log-prefix "--iptables-out--"'''
'''iptables -A FORWARD -j LOG --log-prefix "--iptables-for--"'''
;;
stop)
echo "stoppe firewall"
iptables -F
iptables -F -t nat
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
;;
esac
Diese Zeilen sollten ganz am Ende bleiben, damit auch sichergestellt ist das nur Pakete die alle Regeln durchlaufen haben dort landen.

;Verwendete Syntax
:'''-j LOG''': Aktion die auf Pakete ausgeführt wird, hier LOG
:'''--log-prefix "--iptables-in--"''': Schreibt ''--iptables-in--'' , vor jedes Paket das am INPUT verworfen wurde,

Autostart von script mit udev

2012-11-27T08:18:53Z

Hauptseite

2012-09-24T08:50:49Z

192.168.242.1: /* New */

=== Dokumentation ===

* [[Aufgaben]]
* [[Lösungen]]
=== Grundlagen und Administration ===

* [[Linux Grundlagen]]
* [[Bootprozess]]

* [[Administration]]
* [[Kernelmodule]]
* [[Bash]]
* [[VI Crash]]
* [[Netzwerkkonfiguration unter Ubuntu]]
* [[Paketmanagement]]
* [[RPM]]
* [[Yum howto]]
* [[Nützliche Tools]]
* [[LVM]]
* [[sudo]]
* [[syslog-ng]]
* [[cron]]
* [[incron]]
* [[Screen]]
* [[PPA]]
* [[systemd]]
* [[Exploit]]
* [[WLAN]]
* [[Netstat unter Windows]]

=== Netzwerken ===
* [[SSH]]
* [[Ssh-tunnel]]
* [[NTP]]
* [[Rsync]]
* [[IP Befehle]]
* [[Tcpdump]]
* [[Cloud]]
* [[NET]]
* [[Udpcast]]
* [[Dynamic Host Configuration Protocol]]
* [[Ramdisk entpacken]]
* [[PXELinux]]
* [[Bing]]
* [[Nemesis]]
* [[Heartbeat]]
* [[DRBD]]
* [[RedHat Cluster Suite]]
* [[PACEMAKER]]
* [[CRM/CIB]]
* [[WLAN AccessPoint]]
* [[IPTables - from scratch]]
* [[Bintec]]
* [[Netzwerktechnik]]
* [[tcp/ip]]
* [[Nagios]]
* [[Betavine Connection Manager]]
* [[VLAN]]
* [[VPN Bintec zu Linux]]
* [[pix howto]]
* [[cisco howto]]
* [[Firewall Allgemein]]
* [[Subnetz mit Ubuntu Router]]
* [[Multicast Routing]]
* [[VPN Allgemein|VPN Allgemein (under construction)]]
* [[nTop]]
* [[Fritz unter Ubuntu 10.04]]
* [[DNS mit bind9]]

=== Dienste ===
* [[Untersuchung eines Linuxserver]]
* [[apache2]]
* [[Apache SSL]]
* [[PostgreSQL]]
* [[Tomcat 5.5]]
* [[Squid]]
* [[VLC]]
* [[VMware installation auf Ubuntu]]
* [[vpnc]]
* [[Wireless Tools]]
* [[Perl]]
* [[Joomla]]
* [[MySQL]]
* [[Typo3]]
* [[Samba]]

=== Hardware ===
* [[Computer]]
* [[RAM]]

=== Virtualisierung ===
* [[KVM]]
=== Misc ===
* [[Pflichtenheft]]
* [[Ubuntu]]

=== Mitarbeiter ===
* [[Systemaufbau]]
=== Grafisches ===
* [[Netzwerk]]
* [[Paketmanager]]
* [[CD Brennen]]
* [[EMail einrichten]]
* [[Drucker]]
* [[TS schneiden und brennen]]
* [[Video Konvert Misc]]
* [[VNC Server]]
* [[Unity]]

===== [[LibreOffice]] =====
* [[Erste Schritte in LibreOffice|Erste Schritte]]
* [[Dokumente mit LibreOffice|Writer]]
* [[Tabellenkalkulation mit LibreOffice|Calc]]
* [[Presentationen mit LibreOffice|Impress]]
* [[Vektorgrafiken mit LibreOffice|Draw]]
* [[Der LibreOffice Formeleditor|Math]]

===Sprachen===
*[[Perl]]
*[[Php]]

=== How To's ===

* [[Installation von Mediawiki unter Ubuntu]]
* [[Ungeschütztes Linux Hacken|Linux Grub Passwort Reset]]
* [[RAID|RAID einrichten]]
* [[Root RAID|Root RAID einrichten]]
* [[Runit|Runit einrichten]]

=== New ===
* [[CentOS]]
* [[LDAP]]
*[[Data recovery]]

Nagios

2012-08-07T09:26:12Z

192.168.242.1: /* Command not defined */

== Nagios ==
=== Aktivieren von External Commands ===
Nagios 3 is not configured to look for external commands in the
default configuration as a security feature. To enable external
commands, you need to allow the web server write access to the
nagios command pipe. the simplest way of doing this is to
set check_external_commands=1 in your nagios configuration,
and then change the permissions in a way which will be maintained
across package upgrades (otherwise dpkg will overwrite your
permission changes). The following is the recommended approach:

- activate external command checks in the nagios configuration. this
can be done by setting check_external_commands=1 in the file
/etc/nagios3/nagios.cfg.

sed -i "s/check_external_commands=0/check_external_commands=1/" /etc/nagios3/nagios.cfg

- perform the following commands to change directory permissions and
to make the changes permanent:

/etc/init.d/nagios3 stop
dpkg-statoverride --update --add nagios www-data 2710 /var/lib/nagios3/rw
dpkg-statoverride --update --add nagios nagios 751 /var/lib/nagios3
/etc/init.d/nagios3 start

This is done by intention and will not fixed. See also #538828 for more informations.

=== Mails Benachichtigungen Limitieren ===
If you want to receive only 1 mail, it's easy. Set the
notification_interval to 0. But if you want 2, I guess you might achieve
this using escalation and setting notification_interval to 0.
Defining escalation with first_notification 2, and last_notification 2,
it should work.

I must admit I haven't tried it though.

== Nagios Grapher ==
== Nagios Troubleshoot ==
=== External Command Error===

ERROR:

Error: Could not stat() command file '/var/lib/nagios3/rw/nagios.cmd'!

Lösung:

chmod g+x /var/lib/nagios3/rw

vi /etc/nagios3/nagios.cfg

check_external_commands=1

vi /etc/group

nagios:x:118:www-data

Quell:

I have run into this problem the last three times I have set up Nagios, and every time I fix it, I forget to document the process. So here's the documentation. The first few points are covered in the official Nagios documentation that comes with your package. The later points are not, and have more to do with OS configuration.

My configuration:

Debian 5.3
Nagios 3

Configure nagios.cfg

Make sure you have something like this in /etc/nagios3/nagios.cfg:

# EXTERNAL COMMAND OPTION
# Values: 0 = disable commands, 1 = enable commands

check_external_commands=1

# EXTERNAL COMMAND CHECK INTERVAL
# NOTE: Setting this value to -1 causes Nagios to check the external
# command file as often as possible.

command_check_interval=15s
#command_check_interval=-1

# EXTERNAL COMMAND FILE
command_file=/var/lib/nagios3/rw/nagios.cmd

You will need to restart Nagios for these settings to be loaded.
Configure cgi.cfg

Next, edit the /etc/nagios3/cgi.cfg file and check the following:

# SYSTEM/PROCESS COMMAND ACCESS
authorized_for_system_commands=nagiosadmin

# ... Other stuff cut

# GLOBAL HOST/SERVICE COMMAND ACCESS
authorized_for_all_service_commands=nagiosadmin
authorized_for_all_host_commands=nagiosadmin

This enables the user nagiosadmin to submit commands. You can check out the in-file documentation for setting up multiple users.

Restart Apache2 after you have done this.
Add www-data to the Nagios Group

Next, make sure that the user www-data is in the group nagios. You can check on this in /etc/group.
Set the Permissions

This last item is the tricky one. You need to set the correct permissions for the command pipe file (this is the file set in nagios.cfg). Nagios uses this pipe to pass data from the CGI to the backend daemon.

This file is located in /var/lib/nagios3/rw/nagios.cmd.

By default, it should have the following permissions:

# ls -l /var/lib/nagios3/rw/nagios.cmd
prw-rw---- 1 nagios nagios 0 2010-01-13 10:17 /var/lib/nagios3/rw/nagios.cmd

Notice that the group ownership is nagios. That's why you added www-data to the nagios group above.

But even with these permissions, you may (will?) still get an error. The reason for this is that the parent directory, rw, does not allow any user but nagios to access its contents:

# ls -lh /var/lib/nagios3
total 92K
-rw-r--r-- 1 nagios nagios 33K 2010-01-04 17:06 objects.precache
-rw------- 1 nagios www-data 48K 2010-01-13 10:17 retention.dat
drwx------ 2 nagios www-data 4.0K 2010-01-13 10:17 rw
drwxr-x--- 3 nagios nagios 4.0K 2010-01-04 16:00 spool

All you need to do to fix this is add the execute bit (x) to the rw directory:

# chmod g+x /var/lib/nagios3/rw

Now any member of the nagios group (including www-data) should be able to access the contents of the rw directory.

At this point, you should be able to execute Nagios Service Commands through the web interface. (If not, try doing a stop/start of nagios and try again).

===Command not defined ===
'''Problem:'''
You monitor a remote server with Nagios or Icinga and see the following errors in your Nagios/Icinga web interface:

NRPE: Command 'check_all_disks' not defined
NRPE: Command 'check_mysql_cmdlinecred' not defined
NRPE: Command 'check_procs' not defined

'''Lösung:'''

vi /etc/nagios/nrpe.cfg

... and add command definitions for each service check that gives and error (e.g. check_procs):

[...]
command[check_procs]=/usr/lib/nagios/plugins/check_procs -w 250 -c 400
command[check_all_disks]=/usr/lib/nagios/plugins/check_disk -w '20%' -c '10%' -e
command[check_mysql_cmdlinecred]=/usr/lib/nagios/plugins/check_mysql -H localhost -u 'nagios' -p 'howtoforge'
[...]

Save the file and restart the NRPE server:

/etc/init.d/nagios-nrpe-server restart

== Links ==
* http://nagios.manubulon.com/traduction/docs14en/templatetricks.html
* http://www.nagios-wiki.de/nagios/howtos/nagiosgrapher
* http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=571801
* http://osdir.com/ml/network.nagios.plugins/2008-05/msg00070.html

Nagios

2012-08-07T09:26:05Z

192.168.242.1: /* Command not defined */

2012-07-13T10:14:15Z

192.168.242.1: /* SSH Tunnel (Port Forwarding) */

==Clientseite==
ssh (OpenSSH client) ist ein Programm um auf einen entfernten Rechner zuzugreifen und dort Kommandos auszuführen. Es ersetzt
die Programme rlogin und rsh und stellt eine sichere verschlüsselte Verbindung zwischen zwei Rechnern durch ein
(unsicheres) Netz her.

ssh verbindet sich mit dem Zielrechner, worauf der Benutzer seine Identität über verschiedene Methoden nachweisen muss.

ssh [Optionen] Benutzer@Zielrechner [Kommando]

Wenn ein Kommando angegeben wird, wird dieses anstelle der Login-Shell ausgeführt.

===Optionen===
* -1 : Erzwingt die ausschließliche Benutzung von ssh Protokollversion 1
* -2 : Erzwingt die ausschließliche Benutzung von ssh Protokollversion 2
* -4 : Erzwingt die ausschließliche Benutzung von IPv4 Adressen
* -6 : Erzwingt die ausschließliche Benutzung von IPv6 Adressen
* -b ''Quelladresse'' : Benutzt die ''Quelladresse'' als Ursprung für die Verbindung. Nur nützlich bei Systemen mit
mehreren (IP-)Adressen
* -C : Aktiviert Kompression falls möglich. Dies ist für langsame Verbindungen (z.B. über 56k Modem) gedacht und
würde schnelle Netzwerke verlangsamen
* -l ''Benutzer'' : Gibt ''Benutzer'' an, alternativ zu ''Benutzer''@Zielrechner
* -p ''port'' : Gibt Zielport an
* -V : Zeigt die Versionsnummer an
* -v : ausführliche Ausgabe
* -X : Erlaubt X11 forwarding, damit können entfernte Programme mit grafischen Benutzerinterface (GUI) lokal angezeigt werden
* -x : Verbietet X11 forwarding

Beispiele

Zugriff auf einen bisher unbekannten Zielrechner
root@zero:~# ssh root@alita
The authenticity of host 'alita (192.168.242.10)' can't be established.
RSA key fingerprint is 8c:d1:1f:d2:5e:76:cd:75:74:c4:b7:b2:c7:f6:50:78.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added 'alita,192.168.242.10' (RSA) to the list of known hosts.
root@alita's password: Passwort_das_nicht_angezeigt_wird
...
root@alita:~#
Um die Identität des Zielrechners zu verifizieren, kann man den den Fingerprint des öffentlichen RSA Schlüssels
auf der Serverseite ausgeben lassen. Dieser kann dann mit dem oben angezeigten verglichen werden.

Zugriff auf bekannten Zielrechner
root@zero:~# ssh alita
root@alita's password: Passwort_das_nicht_angezeigt_wird
...
root@alita:~#

Zugriff als Benutzer christian und auf Port 9998
root@zero:~# ssh alita -l christian -p 9998
christian@alita's password: Passwort_das_nicht_angezeigt_wird
...
christian@alita:~$

Ausführen eines Kommandos auf dem Zielrechner
root@zero:~# ssh alita cat /etc/hostname
root@alita's password:
alita
root@zero:~#

Ausführen eines grafischen Programms auf dem Zielrechner und lokal anzeigen
root@zero:~# ssh -X root@alita kate

[[Image:kate.jpg]]

===Authentifizierung mit Schlüssel===
====Schlüsselpaar erstellen====
xinux@zero:~$ ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (/home/xinux/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/xinux/.ssh/id_rsa.
Your public key has been saved in /home/xinux/.ssh/id_rsa.pub.
The key fingerprint is:
a7:13:ec:54:a3:4f:29:32:f8:98:04:ea:0c:b9:62:04 xinux@zero
The key's randomart image is:
+--[ RSA 2048]----+
| |
| |
|E . o |
|.o . . . o o |
|+. o o S + |
|=. . + = B |
|o+ o . + . |
|o . |
| |
+-----------------+
xinux@zero:~$

====Übertragen des öffentlichen Schlüssels====
xinux@zero:~$ ssh-copy-id -i .ssh/'''id_rsa.pub''' root@alita
root@alita's password: Passwort_das_nicht_angezeigt_wird
Now try logging into the machine, with "ssh 'root@alita'", and check in:

.ssh/authorized_keys

to make sure we haven't added extra keys that you weren't expecting.

xinux@zero:~$

====Einloggen auf Remoterechner====
root@zero:~# ssh root@alita
Linux alita 2.6.28-13-generic #44-Ubuntu SMP Tue Jun 2 07:57:31 UTC 2009 i686

The programs included with the Ubuntu system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Ubuntu comes with ABSOLUTELY NO WARRANTY, to the extent permitted by
applicable law.

To access official Ubuntu documentation, please visit:
http://help.ubuntu.com/

0 packages can be updated.
0 updates are security updates.

Last login: Thu Jul 2 13:54:13 2009 from zero.alpha.quadrant
root@alita:~#

===scp secure copy===
scp steht für Secure Copy und ermöglicht es, Dateien in einem Netzwerk zu kopieren. Es baut auf ssh auf und benutzt
entsprechend Authentifizierung und Verschlüsselung.

scp [Optionen] Benutzer@Rechner1:/Pfad/zu/Datei lokaler_Dateipfad
scp [Optionen] lokaler Dateipfad Benutzer@Rechner2:/Pfad/zu/Datei2

====Optionen====
* -1 : Erzwingt die ausschließliche Benutzung von ssh Protokollversion 1
* -2 : Erzwingt die ausschließliche Benutzung von ssh Protokollversion 2
* -4 : Erzwingt die ausschließliche Benutzung von IPv4 Adressen
* -6 : Erzwingt die ausschließliche Benutzung von IPv6 Adressen
* -C : Benutzt Komprimierung
* -P port: Benutzt Port auf dem Zielrechner; Achtung: großes P!
* -p : Verändert nicht die Zeiten der letzten Veränderung der Datei
* -r : rekursives Kopieren; scp folgt dabei auch symbolischen Links
* -v : ausführliche Ausgabe

Beispiele

Kopieren aller Dateien und Verzeinissen von einem lokalen Verzeichnis in ein entferntes Verzeichnis
root@zero:~# scp -r /etc/* root@alita:/tmp/
root@alita's password:
powerbtn.sh 100% 517 0.5KB/s 00:00
...

Kopieren eines entfernten Verzeichnisses in ein lokales Verzeichnis
root@zero:~# scp -r root@alita:/root /root/alita_backup/
root@alita's password:
.bashrc 100% 2227 2.2KB/s 00:00
...

==Serverseite==
===SSH Server installieren===
root@alita:~# apt-get install openssh-server
...

====Konfigurationsdatei====
/etc/ssh/sshd_config
# What ports, IPs and protocols we listen for
Port 22

# Use these options to restrict which interfaces/protocols sshd will bind to
#ListenAddress ::
#ListenAddress 0.0.0.0
Protocol 2
# HostKeys for protocol version 2
HostKey /etc/ssh/ssh_host_rsa_key
HostKey /etc/ssh/ssh_host_dsa_key
#Privilege Separation is turned on for security
UsePrivilegeSeparation yes

# Lifetime and size of ephemeral version 1 server key
KeyRegenerationInterval 3600
ServerKeyBits 768
...

Zusätzlichen Port zum Lauschen auf Anfragen hinzufügen

/etc/ssh/sshd_config
# What ports, IPs and protocols we listen for
Port 22
'''Port 9998'''
# Use these options to restrict which interfaces/protocols sshd will bind to
#ListenAddress ::
#ListenAddress 0.0.0.0

===RSA Key Fingerprint anzeigen===
root@alita:/etc/ssh# ssh-keygen -f /etc/ssh/ssh_host_rsa_key.pub -l
2048 8c:d1:1f:d2:5e:76:cd:75:74:c4:b7:b2:c7:f6:50:78 /etc/ssh/ssh_host_rsa_key.pub (RSA)
= SSH Tunnel (Port Forwarding) =
-f lässt den Prozess im Hintergrund laufen
-g erlaubt remoteusern den lokal geöffneten ssh tunnel zu benutzen
-p gibt den Port an über den sich SSH verbinden soll
-N ist eine nützliche Option um das öffnen einer remoteshell zu unterbinden

-R leitet den Port vom remoteserver auf localhost weiter
-L leitet den Port von localhost auf remoteserver weiter
Format [bind_address:]port:host:hostport
Wenn keine [bind_address:] angegeben wird localhost eingesetzt

ssh -p '''''SERVERPORT''''' -f -g -N -l '''''USER''''' '''''SSHSERVER''''' -L '''''BINDADDRESS''''':'''''LOCALPORT''''':'''''ZIEL''''':'''''ZIELPORT'''''

Alles was auf '''''BINDADDRESS''''' port '''''LOCALPORT''''' ankommt schicke durch tunnel zu '''''ZIEL''''' port '''''ZIELPORT'''''

Beispiele:

*Umleiten von Jdownloader Linkgrabber von alice aus
**bob port 9666 ---> alice port 9666
root@alice:~# ssh -f -N ''SSHSERVER'' -R localhost:9666:localhost:9666
*Umleiten von VNC von bob aus
**bob port 5900 ---> donald port 5900
root@bob:~# ssh -f -N donald -L 5900:localhost:5900
*Umleiten von Samba von charlie aus
**donald port 139 ---> charlie port 139
ssh -p 9387 -f -g -N ''SSHSERVER'' -L 139:''ZIEL'':139

Ports schliessen:
fuser -vk -n tcp 139