# iptables und eine DMZ-IP, nicht interface

## benjamin200

Ich möchte heute Abend/Nacht meinen Hardware Router, testweise, gegen einen Gentoo Router ersetzen. Als kleine Hilfe nehme ich das HowTo "Gentoo Home Router Guide" von gentoo.org

Gibt es eine Möglichkeit eine IP des privaten / lokalen Netzes in die DMZ zu nehmen, so das alle Ports offen sind? Ich möchte kein physikalisches Interface dafür verwenden, zudem ich wie die meisten von uns zuhause nur einen L2-Switch habe.

Anregungen, Tips und Code willkommen  :Smile: 

Danke im voraus.

Gruß,

Benjamin

----------

## slick

Hmm... also ich verstehe die Frage noch nicht ganz. Was für eine DMZ hast Du? So eine richtige wie z.B. auf dem Bild hier? Also so wie ich das verstanden habe hast Du nur einen Router, auf einen Seite hängt INet, auf der anderen LAN, korrekt? So und Du möchtest jetzt das ein PC aus dem LAN so zu erreichen wäre, als würde es eine richtige DMZ sein (wie auf dem Bild) und der Rechner liegt darin (und ohne eine neue NIC einzubauen)?

Also wenn dem so ist, dann machst Du ja vermutlich NAT nach außen. Traffic von außen läßt Du nur zu wenn er von drinnen angestoßen wurde:

Auszug:

```
iptables -A INPUT -i $EXTERN -m state --state ESTABLISHED,RELATED -j ACCEPT

iptables -A FORWARD -i $EXTERN -o $INTERN -m state --state ESTABLISHED,RELATED -j ACCEPT

iptables -t nat -A POSTROUTING -o $EXTERN -j MASQUERADE
```

Dann möchtest Du z.B. einen Webserver im LAN betreiben der von extern erreichbar ist:

```
iptables -t nat -A PREROUTING  -i $EXTERN -p tcp --dport 80 -m state --state NEW -j DNAT --to $IP-INTERN

iptables -A FORWARD -i $EXTERN -o $INTERN -p tcp -d $IP-INTERN --dport 80 -m state --state NEW -j ACCEPT
```

Dieses "alle Ports offen" verwirrt mich noch etwas. Du könntest da z.B. alles von von extern kommt mit --state NEW auf einen Rechner umleiten. Das wäre dann aber so als würde dieser Rechner direkt am (externen) Netz hängen, von daher paßt das dann mit der "DMZ" nicht mehr so recht.

----------

## benjamin200

 *Quote:*   

> 
> 
> Hmm... also ich verstehe die Frage noch nicht ganz. Was für eine DMZ hast Du? So eine richtige wie z.B. auf dem Bild hier?
> 
> 

 

Morgen Slick,

nein so ein Szenario meine ich nicht.

 *Quote:*   

> 
> 
> Dieses "alle Ports offen" verwirrt mich noch etwas. Du könntest da z.B. alles von von extern kommt mit --state NEW auf einen Rechner umleiten. Das wäre dann aber so als würde dieser Rechner direkt am (externen) Netz hängen, von daher paßt das dann mit der "DMZ" nicht mehr so recht.
> 
> 

 

Ich würde es gern erläutern. Eine echte Firewall besitzt ja in der Regel drei Schnittstellen. Externes, Lokales und ein DMZ Interface. Jedes dieser physikalischen Interfaces liegt in einem andren Subnetz und wird durch Policies geschützt.

Wenn du die billigen SOHO-Router kennst, Netgear, SMC etc, kannst hast du nur 2 Schnittstellen, Intern (LAN) und Extern (WAN). Hier kann fast immer eine IP als DMZ angegeben werden, wo Programme die mehrere Ports dynamisch öffnen auch mit diesem Soho Router laufen. Ich wollte einfach mal klären, ob es möglich ist eine sollche DMZ mit iptables zu erstellen?

Hoffe ich habs einigermaßen gut erklären können  :Smile: 

 *Quote:*   

> 
> 
> Auszug: 
> 
> Code: 
> ...

 

Kurze Frage dazu: Wo deklarierst du $Extern und $Intern? Hab iptables rules manuell mit Angabe der Interfaces eth0 bzw. ppp0 erstellt. Übersichtlicher wäre eine solche Lösung wie von dir gepostet.

Gruß,

Benjamin

----------

## slick

 *Quote:*   

> hast du nur 2 Schnittstellen, Intern (LAN) und Extern (WAN). 

 

Genau das was ich meinte.

 *Quote:*   

> Hier kann fast immer eine IP als DMZ angegeben werden

 

Folgende Regeln (ungetestet) sollten allen (neuen) eingehenden (TCP-) Traffic auf eine Maschine umbiegen. "Normaler" Traffic von bestehenden Verbindungen ins LAN ist davon nicht betroffen. Macht genau das was die DMZ-IP-Funktion im Router macht.

```
iptables -t nat -A PREROUTING -i $EXTERN -p tcp -m state --state NEW -j DNAT --to $IP-INTERN 

iptables -A FORWARD -i $EXTERN -o $INTERN -p tcp -d $IP-INTERN -m state --state NEW -j ACCEPT 
```

 *Quote:*   

> Wo deklarierst du $Extern und $Intern? 

 

Ich benutze nicht das iptables-initscript sondern habe mir ein eigenes initscript für die Reglen geschreiben. So kann ich darin Variablen definieren. Kurz gesagt, ersetze: $EXTERN mit dem dem extern Interface (ppp0), $INTERN mit dem internen Interface (eth0) und $IP-INTERN mit der IP des "DMZ-Host". Wenn Du ein eingenes Init-Script schreiben willst, kann ich heute abend mal ein leere Muster posten. Aber im Prinzip brauchst Dir nur die anderen initscripte anschauen, das Prinzip ist leicht verständlich.

Allerdings solltest Du bei dieser Vorgehensweise wissen was Du tust. Der "DMZ-Host" sollte sicher konfiguriert sein. Du solltest Dir an den anderen Rechner im LAN Paketfilter einrichten um zu verhindern das Traffic zwischen dem "DMZ-Host" und den anderen Rechnern entsteht. Denn der "DMZ-Rechner" ist dann der anfälligste im Netz. 

Auf der anderen Seite ist dann der Gentoo-Router vollkommen überflüssig, denn es bringt kaum noch Vorteile. Die kritische Maschine ist ja dann nicht mehr der Router sondern der "DMZ-Host". Von daher kannst Du auch gleich den "DMZ-Host" direkt als Router ans Netz hängen.

----------

## benjamin200

 *Quote:*   

> 
> 
> Code: 
> 
> iptables -t nat -A PREROUTING -i $EXTERN -p tcp -m state --state NEW -j DNAT --to $IP-INTERN 
> ...

 

Danke, genau das wollte ich erreichen.

 *Quote:*   

> 
> 
> Wenn Du ein eingenes Init-Script schreiben willst, kann ich heute abend mal ein leere Muster posten. Aber im Prinzip brauchst Dir nur die anderen initscripte anschauen, das Prinzip ist leicht verständlich. 
> 
> 

 

Gerne, daran wäre ich natürlich interessiert  :Smile: 

 *Quote:*   

> 
> 
> Allerdings solltest Du bei dieser Vorgehensweise wissen was Du tust. Der "DMZ-Host" sollte sicher konfiguriert sein. Du solltest Dir an den anderen Rechner im LAN Paketfilter einrichten um zu verhindern das Traffic zwischen dem "DMZ-Host" und den anderen Rechnern entsteht. Denn der "DMZ-Rechner" ist dann der anfälligste im Netz. 
> 
> Auf der anderen Seite ist dann der Gentoo-Router vollkommen überflüssig, denn es bringt kaum noch Vorteile. Die kritische Maschine ist ja dann nicht mehr der Router sondern der "DMZ-Host". Von daher kannst Du auch gleich den "DMZ-Host" direkt als Router ans Netz hängen.
> ...

 

Du hast natürlich Recht, aber manchmal (nicht als dauerlösung) möchte ich die Option einer DMZ haben. Somit ist die Lösung für mich akzeptabel.

----------

## slick

Was mir grad noch einfällt, Du könntest das ganze noch etwas sicherer gestalten, wenn Du eth0 2 IPs aus 2 verschiedenen Netzen gibts. In Netz 1 kommen dann die LAN-Rechner, in Netz 2 der "DMZ-Host". Dann kannst/mußt Du den Zugriff aus dem "LAN" auf den "DMZ-Host" und vor allem umgekehrt sehr fein über iptables auf dem Router regeln weil aller Verkehr dann über den Router laufen muss.

----------

## benjamin200

 *Quote:*   

> 
> 
> Was mir grad noch einfällt, Du könntest das ganze noch etwas sicherer gestalten, wenn Du eth0 2 IPs aus 2 verschiedenen
> 
> 

 

das würde ich hinbekommen...

 *Quote:*   

> 
> 
> In Netz 1 kommen dann die LAN-Rechner, in Netz 2 der "DMZ-Host". Dann kannst/mußt Du den Zugriff aus dem "LAN" auf den "DMZ-Host" und vor allem umgekehrt sehr fein über iptables auf dem Router regeln weil aller Verkehr dann über den Router laufen muss.
> 
> 

 

... aber wie spezifiziere ich eth0-lan1 bzw. eth0-lan2?

----------

## slick

mehrere IPs auf ein interface

/etc/conf.d/net

```
config_eth0=( 

"192.168.0.1 netmask 255.255.255.0 broadcast 192.168.0.255" 

"192.168.1.1 netmask 255.255.255.0 broadcast 192.168.1.255" 

) 
```

bei iptables würde ich dann nur mit IPs arbeiten, evt. geht auch eth0:0 bzw. eth0:1 in den regeln, weiß nicht genau, müßtest mal mit ifconfig schauen und testen.

EDIT: Ok, habs mal nachgeschlagen, also die erste Ip sollte eth0 sein, die zweite eth0:0 die dritte eth0:1 usw... die Angaben können dann auch in iptables so verwendet werden. 

```
iptables ... -i eth0:0 ...
```

Solltest aber selbst erstmal antesten, hatte ich bisher kaum was mit zu tun.Last edited by slick on Wed Jun 15, 2005 8:36 am; edited 1 time in total

----------

## benjamin200

 *Quote:*   

> 
> 
> mehrere IPs auf ein interface 
> 
> /etc/conf.d/net 
> ...

 

Merci, ich werde es testen Slick.

Achja, mir ist noch was aufgefallen. Der Gentoo Software-Router verhält sich etwas anders als mein Hardware-Router. Wenn ich per öffentlicher IP aus dem lokalen Netz den Router ansprechen will geschieht das woll über das lokale Netz, da z.B. Ports offen sind (nmap öffentlichIP) wenn ich diese von intern scanne.

Denkst du es handelt sich um einen Fehler in meinen iptables oder checkt iptables ab das die Anfrage von intern an den Routern nicht übers Internet gehen muss und leitet somit direkt aufs lokale Netz um?

----------

## slick

Hmm.. kann ich leider nicht mit Gewissheit beantworten. Vielleicht hat noch ein Netzwerk-Guru eine Antwort?

Aber ich _vermute_ es läuft wie folgt:

Du beginnst von intern die externe IP anzusprechen. Das geht über NAT raus und ein Eintrag in der NAT-Tabelle wird erstellt das dies von intern initialisiert wurde. Jetzt kommt das Paket von "extern" wieder rein und in der NAT-Tabelle steht das es das darf. Von daher ist von innen gesehen außen alles offen.

----------

## benjamin200

 *Quote:*   

> 
> 
> Du beginnst von intern die externe IP anzusprechen. Das geht über NAT raus und ein Eintrag in der NAT-Tabelle wird erstellt das dies von intern initialisiert wurde. Jetzt kommt das Paket von "extern" wieder rein und in der NAT-Tabelle steht das es das darf. Von daher ist von innen gesehen außen alles offen.
> 
> 

 

So sehe ich das auch (jedenfalls so ähnlich).

 *Quote:*   

> 
> 
> Vielleicht hat noch ein Netzwerk-Guru eine Antwort? 
> 
> 

 

Ja, wäre interessant. Netzwerk-Guru bitte melden!

----------

## think4urs11

Hi,

ohne das jetzt wirklich rauszutracen (und daher ohne Anspruch auf Richtigkeit) würde ich sagen es läuft in etwa so:

- Paket kommt von 'innen'

- es wird gegen die Rulebase gecheckt ob es erlaubt wird

- Source-IP-wird umgeNATed auf 'IP von ppp0'

- Paket wird an Dest-IP geschickt (ebenfalls IP von ppp0)

Da nun normalerweise die FW-Regeln so aussehen das lokal<->lokal grundsätzlich erlaubt ist trifft das auch auf dieses Paket zu und ist daher auch erlaubt.

Bau dir mal eine Regel ein die genau das verbietet und du weißt ob ich recht habe  :Wink: 

HTH

T.

----------

## benjamin200

 *Quote:*   

> 
> 
> Bau dir mal eine Regel ein die genau das verbietet und du weißt ob ich recht habe 
> 
> 

 

bin leider noch nicht so fit in iptables, wenn du mir vielleicht behilflich sein könntest?

eth0 ist mein lokales-Netz

eth1 inteface für dsl, hierüber wird ppp0 initialisiert

ppp0 DSL-Vebrindung zu ISP

Meine Iptables richten sich nach dem Home-Router-Guide auf Gentoo, bis auf die Änderungen von eth1 auf ppp0, damit auch das Richtige Interface gefiltert wird.

Home-Router-Guide

 *Quote:*   

> 
> 
> Code Listing 5.3: Setting up iptables
> 
> First we flush our current rules
> ...

 

----------

## think4urs11

es steht schon eindeutig in deinen Regeln das es erlaubt ist.

Das NAT findet erst in POSTROUTING statt, d.h. als letzter Schritt bevor das Paket auf die Reise geht.

iptables -t nat -A POSTROUTING -o ppp0 -j MASQUERADE

Vorher erlaubst du aber schon das alles was 192.168.0.0/16 ist grundsätzlich alles darf nach 'wurscht wohin'

iptables -A FORWARD -i eth0 -s 192.168.0.0/255.255.0.0 -j ACCEPT

Was von eth0 kommt darf auf alles zugreifen das die Maschine anbietet- und von daher kommt das Paket ja

iptables -I INPUT 1 -i eth0 -j ACCEPT

Ergo -> von intern darfst du auf deine externe IP alles.

----------

## slick

Aber nicht vergessen  :Wink:  eth1 =/= ppp0

 *http://www.gentoo.org/doc/de/home-router-howto.xml wrote:*   

> Warning: Wenn das DSL-Interface läuft, erstellt es ppp0. Obwohl Ihre NIC eth1 genannt wird, ist die IP tatsächlich an ppp0 gebunden. Von jetzt an, wenn Sie ein Beispiel sehen, das 'eth1' nutzt, ersetzen Sie es mit 'ppp0'. 

 

----------

## benjamin200

 *Quote:*   

> 
> 
> Aber nicht vergessen  eth1 =/= ppp0 
> 
> 

 

hab ich angepasst:

 *Quote:*   

> 
> 
> Meine Iptables richten sich nach dem Home-Router-Guide auf Gentoo, bis auf die Änderungen von eth1 auf ppp0, damit auch das Richtige Interface gefiltert wird. 
> 
> 

 

 *Quote:*   

> 
> 
> es steht schon eindeutig in deinen Regeln das es erlaubt ist. 
> 
> Das NAT findet erst in POSTROUTING statt, d.h. als letzter Schritt bevor das Paket auf die Reise geht. 
> ...

 

Danke, nun ist ja damit alles klar. Die Policies werde ich noch verschärfen müssen. Alles soll aus dem internen Netz nun auch wieder nicht erlaubt werden. Slick wollte mir heute eine Pre-Config schicken, die bestimmt für mich interessant ist

Danke an euch beide.

----------

## benjamin200

Schützt die oben genannte Regel (angepasst mit ppp0) vor ...

 *Quote:*   

> 
> 
> Angriffsvektor IP-Spoofing - Mittel gegen die Angriffe 
> 
> Das einfachste Mittel gegen IP-Spoofing ist die Verwendung vernünftiger Regeln in der Firewall. Ist dem Administrator erst bewusst, dass IP-Spoofing in der Praxis existiert, dann gilt zumindest eine Firewall-Regel: Die Firewall muss von außen eingehende Pakete daraufhin überprüfen, ob deren IP-Header aus der IP-Range des internen Netzes stammen. Ist das der Fall, handelt es sich mit Sicherheit um eine gefälschte Adresse und beim Paket möglicherweise um einen Angriffsversuch, denn die internen Adressen befinden sich ja auf der anderen Seite der Firewall. Mit anderen Worten: Eingehende Pakete mit Adressen aus dem internen Adressbereich müssen blockiert werden. 
> ...

 

... IP-Spoofing?

```

```

Ich finde keinen Bezug der dies verbietet bzw. erlaubt. Bin mir aber nicht sicher.

----------

## slick

Bei einem NAT hast Du diese Problematik weniger. Wenn Du mit ... -m state --state ESTABLISHED,RELATED ... arbeitest führt iptables eine Liste welche Verbindungen von wo nach wo aufgebaut wurden und läßt deren Antworten von draußen wieder rein. Und wenn ein Angreifer extern die interne IP als Quelle hättest wie Du im LAN, würde das Paket dennoch nicht durchkommen, solange der Angreifer nicht weiß oder errät was grad eben in Deiner NAT-Tabelle steht was "reindarf". D.h. bei einem typischen und sauberen NAT bist Du save es sei denn der Angreifer fälscht die passenden Pakete zu einer Deiner bestehenden Verbindungen. Äußerst aufwendig schätze ich mal und wahrscheinlich wenig sinnbringend. Das Problem IP-Spoofing ist eher bei "normalen" Routern ohne NAT (oder schlechten iptables-Regeln)Last edited by slick on Wed Jun 15, 2005 2:06 pm; edited 3 times in total

----------

## think4urs11

Trotzdem ist es kein Schaden die Möglichkeit des Spoofens abzustellen

entnomen aus dem Gentoo Security Handbuch

```
# for i in /proc/sys/net/ipv4/conf/*; do

        /bin/echo "1" > $i/rp_filter

done
```

Es wird geprüft ob das jeweilige Paket das da ankommt überhaupt von dort kommen kann (via routing table) und wenn nicht verworfen.

----------

## benjamin200

 *Quote:*   

> 
> 
> Äußerst aufwendig schätze ich mal und wahrscheinlich wenig sinnbringend. Das Problem IP-Spoofing ist eher bei "normalen" Routern ohne NAT (oder schlechten iptables-Regeln)
> 
> 

 

Danke für deine Antwort. Ich müsste es also mit mstate realisieren?

Sind die Regeln aus dem Gentoo Home Router Guide gut? Immerhin habe ich gelesen, das die PREROUTING Funktion/Regel als erstes und nicht zum Schluss gesetzt wird. Im Guide jedoch als letztes. Ist das schlichtweg egal oder ist das Not Save?

Siehe:

http://iptables-tutorial.frozentux.net/iptables-tutorial.html

----------

## slick

Meine EDIT von oben hier angehangen, zwecks Übersicht

Die einfachste NAT-Box sieht daher so aus (wenn Default-Policie DROP oder REJECT) und ist save

```

# Zugriff vom LAN auf den Router erlauben:

iptables -A INPUT -i $INTERN -j ACCEPT

# Zugriff von aus dem LAN über den Router nach draußen erlauben

iptables -A FORWARD -i $INTERN -o $EXTERN -j ACCEPT

# Zugriff des Routers selbst nach draußen erlauben

iptables -A OUTPUT -o $EXTERN -j ACCEPT

# Zugriff von außen auf den Router nur erlauben wenn Verbindung bereits besteht (kann ja nur von innen sein) 

iptables -A INPUT -i $EXTERN -m state --state ESTABLISHED,RELATED -j ACCEPT

# Zugriff von außen über den Router in LAN nur erlauben wenn Verbindung bereits besteht (kann ja nur von innen sein) 

iptables -A FORWARD -i $EXTERN -o $INTERN -m state --state ESTABLISHED,RELATED -j ACCEPT 

# alle ausgehenden Pakete in die NAT Tabelle eintragen die dann von ESTABLISHED,RELATED gelesen wird

# und Absenderadresse auf Externe Adresse ändern

iptables -t nat -A POSTROUTING -o $EXTERN -j MASQUERADE
```

Last edited by slick on Wed Jun 15, 2005 2:16 pm; edited 1 time in total

----------

## benjamin200

 *Quote:*   

> 
> 
> Trotzdem ist es kein Schaden die Möglichkeit des Spoofens abzustellen 
> 
> entnomen aus dem Gentoo Security Handbuch 
> ...

 

@Think4UrS11

Klasse das wäre also die Lösung des Problems. Merci  :Smile: 

@slick

wann kannst du die iptables vorlage posten?

----------

## slick

Sagen wir mal so ab max. 17:30. Bin noch @work

----------

## slick

Hier mein Initscript. Habs etwas gekürzt... sollte verständlich sein.

Bei den Regeln bin ich einen etwas anderen Weg gegangen, ich baue mir eigene "Kanäle" für die ich dann jeweils einzeln bessern die Regeln vergeben kann. Ist für mich übersichtlicher. z.B. alles FORWARD von EXT nach INT ist im "Kanal" FWD_EXT_INT. Man muß nur beachten das es die vorher "Kanäle" exitieren, bevor man die Pakete da rein schiebt. 

Dieses Script muß nach der Erstellung nach rp-pppoe (also wenn es ppp0 schon gibt) laufen, da sonst iptables natürlich das Interface nicht findet. Evt. Funktion depend() anpassen.

Wenn Fragen, dann fragen.  :Wink: 

```
#!/sbin/runscript

depend() {

    need net

}

# ping von extern erlauben (0|1)

ALLOW_PING=1

# ping-versuche loggen (0|1)

LOG_PING=1

# Geräte definieren

INT="eth0"

EXT="ppp0"

# Pfad zu interfaces

IPV4PATH="/proc/sys/net/ipv4"

flush() {

# alle regeln löschen, alle verbindungen sperren

   if test -r /proc/net/ip_tables_names; then

      for name in `cat /proc/net/ip_tables_names`; do

         iptables -F -t $name

         iptables -X -t $name

      done;

   fi

   iptables -F

   iptables -X

   iptables -Z

   iptables -P INPUT REJECT

   iptables -P FORWARD DROP

   iptables -P OUTPUT REJECT

   tc qdisc del dev $EXT root &> /dev/null

   tc qdisc del dev $EXT ingress &> /dev/null

}

# nach allen Programmen prüfen

checkconfig() {

   if [ ! -x "$(which iptables)" ] ; then

      eerror "iptables need to be installed"

      return 1

   fi

}

start() {

   checkconfig || return 1

   ebegin "Starting NAT"

# Interface-Konfiguration setzen

   echo "0" > $IPV4PATH/ip_forward

   echo "0" > $IPV4PATH/ip_dynaddr

   echo "1" > $IPV4PATH/tcp_syncookies

   echo "1" > $IPV4PATH/icmp_echo_ignore_broadcasts

   echo "0" > $IPV4PATH/icmp_echo_ignore_all

   echo "1" > $IPV4PATH/icmp_ignore_bogus_error_responses

   echo "1" > $IPV4PATH/conf/all/rp_filter

   echo "0" > $IPV4PATH/conf/all/accept_redirects

   echo "0" > $IPV4PATH/conf/all/accept_source_route

# Default Policy und flush

   flush

# incoming traffic in INT

   iptables -N INP_INT

   iptables -A INP_INT -j ACCEPT

# outgoing traffic on INT

   iptables -N OUT_INT

   iptables -A OUT_INT -j ACCEPT

# incoming traffic in EXT

   iptables -N INP_EXT

   iptables -A INP_EXT -m state --state ESTABLISHED,RELATED -j ACCEPT

   # ssh

   iptables -A INP_EXT -p tcp --dport 22 -j ACCEPT

   # ping nach config loggen

   if [ "${LOG_PING}" == "1" ] ; then

      iptables -A INP_EXT -p icmp --icmp-type echo-request -m limit --limit 1/s --limit-burst 4 -j LOG --log-level info --log-prefix "PING: "

   fi

   # ping nach config freigeben

   if [ "${ALLOW_PING}" == "1" ] ; then

      iptables -A INP_EXT -p icmp --icmp-type echo-request -j ACCEPT

   fi

# outgoing traffic on EXT

   iptables -N OUT_EXT

   iptables -A OUT_EXT -j ACCEPT

# forward from INT > EXT

   iptables -N FWD_INT_EXT

   iptables -A FWD_INT_EXT -j ACCEPT

# forward from EXT > INT

   iptables -N FWD_EXT_INT

   iptables -A FWD_EXT_INT -m state --state ESTABLISHED,RELATED -j ACCEPT

# in eigene Regeln schieben 

   iptables -A INPUT -i $INT -j INP_INT

   iptables -A OUTPUT -o $INT -j OUT_INT

   iptables -A INPUT -i $EXT -j INP_EXT

   iptables -A OUTPUT -o $EXT -j OUT_EXT

   iptables -A FORWARD -i $INT -o $EXT -j FWD_INT_EXT

   iptables -A FORWARD -i $EXT -o $INT -j FWD_EXT_INT

   iptables -A INPUT -i lo -j ACCEPT

   iptables -A OUTPUT -o lo -j ACCEPT

   # Masquerade

   iptables -A POSTROUTING -t nat -o $EXT -j MASQUERADE

   # MTU

   iptables -A FORWARD -p TCP --tcp-flags SYN,RST SYN -j TCPMSS --clamp-mss-to-pmt

   echo "1" > $IPV4PATH/ip_dynaddr

   echo "1" > $IPV4PATH/ip_forward

   eend $?

}

#

stop() {

      checkconfig || return 1

      ebegin "Stopping NAT"

      echo "0" > $IPV4PATH/ip_forward

      echo "0" > $IPV4PATH/ip_dynaddr

      flush

      iptables -A INPUT -i lo -j ACCEPT

      iptables -A OUTPUT -o lo -j ACCEPT

      iptables -A INPUT -i $INT -j ACCEPT

      iptables -A OUTPUT -o $INT -j ACCEPT

      iptables -A INPUT -i $EXT -j REJECT

      iptables -A OUTPUT -o $EXT -j REJECT

      eend $?

}

```

----------

## benjamin200

Danke Slick,

ich werde das heute Abend mal ausprobieren. Bin leider immer noch @work. Mal sehen ob ich das heute noch hinbiegen. 

Den Vorschlag von Think4UrS11 mit IP-Spoofing Detection im Kernel wirst du auch aktivieren, nehme ich mal an!

----------

## benjamin200

bin eben noch am spielen mit den Regeln und versuche gerade Port-Forwarding zu aktivieren. Leider habe ich da so meine Probleme. Wer helfen kann bitte unter ...

iptables Portforwarding verwenden

https://forums.gentoo.org/viewtopic-t-349653.html

...posten. Danke  :Smile: 

----------

## benjamin200

Hi,

das mit dem umbiegen auf eine DMZ IP (im lokalen Netz) haut noch nicht so hin:

```

server benjamin # iptables -t nat -A PREROUTING -i ppp0 -p tcp -m state --state NEW -j DNAT --to 192.168.0.4

iptables: No chain/target/match by that name

server benjamin # iptables -A FORWARD -i ppp0 -o eth0 -p tcp -d 192.168.0.4 -m state --state NEW -j ACCEPT

iptables: No chain/target/match by that name

server benjamin #    

```

Was fehlt mir noch?

----------

## benjamin200

BUMP  :Smile: 

----------

## benjamin200

BUMP (die zweite)  :Smile: 

----------

## benjamin200

 *Quote:*   

> 
> 
> Hi, 
> 
> das mit dem umbiegen auf eine DMZ IP (im lokalen Netz) haut noch nicht so hin: 
> ...

 

Hab von slick die Info das es an meinen Kernel-Einstellungen liegen könnte (also nicht sicher). Die Kernel-Settings habe ich aus dem Gentoo-Home-Router Guide übernommen. Siehe:

 *Quote:*   

> 
> 
> The next thing you'll need is support for iptables and NAT (and packet shaping if you want). The following list is split up into required (*), suggested (x), and shaper (s) features. It does not matter whether you build the features into the kernel or as a module so long as when the feature is needed, the correct module(s) are loaded (module loading is left to the reader as a fun exercise however). 
> 
> Code Listing 2.2: Network Options
> ...

 

Was könnte mir da noch fehlen?

Gruß

Benjamin

----------

## slick

 *Quote:*   

> [s] Packet mangling

 

Mach das mal testweise fest in den Kernel... 

ansonsten evt. mal "spaßeshalber" alles fest  in den Kernel ... rausgenommen sind die ja wieder schnell...

(Habe momentan meine Kernelconfig nicht hier im Büro)

----------

## benjamin200

 *Quote:*   

> 
> 
> Zitat: 
> 
> [s] Packet mangling 
> ...

 

ich werds heute Abend checken, und gebe anschließend bescheid.

 *Quote:*   

> 
> 
> (Habe momentan meine Kernelconfig nicht hier im Büro)
> 
> 

 

wäre nett wenn du mir deine Kernel Network Settings bereitstellen kansnt. 

Bin ebenso noch @work, puhh ist das heiß heute  :Smile: 

----------

## slick

Ich mag keine modularen Kernel... hier meine 2.6.10-gentoo-r6 Config (komplett)

```
CONFIG_X86=y

CONFIG_MMU=y

CONFIG_UID16=y

CONFIG_GENERIC_ISA_DMA=y

CONFIG_GENERIC_IOMAP=y

CONFIG_EXPERIMENTAL=y

CONFIG_CLEAN_COMPILE=y

CONFIG_BROKEN_ON_SMP=y

CONFIG_LOCK_KERNEL=y

CONFIG_LOCALVERSION=""

CONFIG_SWAP=y

CONFIG_SYSVIPC=y

CONFIG_POSIX_MQUEUE=y

CONFIG_SYSCTL=y

CONFIG_LOG_BUF_SHIFT=14

CONFIG_KOBJECT_UEVENT=y

CONFIG_IKCONFIG=y

CONFIG_IKCONFIG_PROC=y

CONFIG_KALLSYMS=y

CONFIG_FUTEX=y

CONFIG_EPOLL=y

CONFIG_SHMEM=y

CONFIG_CC_ALIGN_FUNCTIONS=0

CONFIG_CC_ALIGN_LABELS=0

CONFIG_CC_ALIGN_LOOPS=0

CONFIG_CC_ALIGN_JUMPS=0

CONFIG_MODULES=y

CONFIG_MODULE_UNLOAD=y

CONFIG_MODULE_FORCE_UNLOAD=y

CONFIG_OBSOLETE_MODPARM=y

CONFIG_KMOD=y

CONFIG_X86_PC=y

CONFIG_M586=y

CONFIG_X86_GENERIC=y

CONFIG_X86_CMPXCHG=y

CONFIG_X86_XADD=y

CONFIG_X86_L1_CACHE_SHIFT=7

CONFIG_RWSEM_XCHGADD_ALGORITHM=y

CONFIG_X86_PPRO_FENCE=y

CONFIG_X86_F00F_BUG=y

CONFIG_X86_WP_WORKS_OK=y

CONFIG_X86_INVLPG=y

CONFIG_X86_BSWAP=y

CONFIG_X86_POPAD_OK=y

CONFIG_X86_ALIGNMENT_16=y

CONFIG_X86_INTEL_USERCOPY=y

CONFIG_HPET_TIMER=y

CONFIG_PREEMPT=y

CONFIG_X86_UP_APIC=y

CONFIG_X86_UP_IOAPIC=y

CONFIG_X86_LOCAL_APIC=y

CONFIG_X86_IO_APIC=y

CONFIG_X86_MCE=y

CONFIG_NOHIGHMEM=y

CONFIG_PROC_MM=y

CONFIG_HAVE_DEC_LOCK=y

CONFIG_PM=y

CONFIG_ACPI=y

CONFIG_ACPI_BOOT=y

CONFIG_ACPI_INTERPRETER=y

CONFIG_ACPI_SLEEP=y

CONFIG_ACPI_SLEEP_PROC_FS=y

CONFIG_ACPI_AC=y

CONFIG_ACPI_BATTERY=y

CONFIG_ACPI_BUTTON=y

CONFIG_ACPI_FAN=y

CONFIG_ACPI_PROCESSOR=y

CONFIG_ACPI_THERMAL=y

CONFIG_ACPI_BLACKLIST_YEAR=0

CONFIG_ACPI_BUS=y

CONFIG_ACPI_EC=y

CONFIG_ACPI_POWER=y

CONFIG_ACPI_PCI=y

CONFIG_ACPI_SYSTEM=y

CONFIG_APM=y

CONFIG_APM_CPU_IDLE=y

CONFIG_APM_RTC_IS_GMT=y

CONFIG_PCI=y

CONFIG_PCI_GOANY=y

CONFIG_PCI_BIOS=y

CONFIG_PCI_DIRECT=y

CONFIG_PCI_MMCONFIG=y

CONFIG_PCI_LEGACY_PROC=y

CONFIG_PCI_NAMES=y

CONFIG_BINFMT_ELF=y

CONFIG_STANDALONE=y

CONFIG_PREVENT_FIRMWARE_BUILD=y

CONFIG_PNP=y

CONFIG_BLK_DEV_LOOP=y

CONFIG_BLK_DEV_CRYPTOLOOP=y

CONFIG_BLK_DEV_NBD=y

CONFIG_BLK_DEV_RAM_COUNT=16

CONFIG_INITRAMFS_SOURCE=""

CONFIG_IOSCHED_NOOP=y

CONFIG_IOSCHED_AS=y

CONFIG_IOSCHED_DEADLINE=y

CONFIG_IOSCHED_CFQ=y

CONFIG_IDE=y

CONFIG_BLK_DEV_IDE=y

CONFIG_BLK_DEV_IDEDISK=y

CONFIG_IDEDISK_MULTI_MODE=y

CONFIG_IDE_GENERIC=y

CONFIG_BLK_DEV_IDEPCI=y

CONFIG_IDEPCI_SHARE_IRQ=y

CONFIG_BLK_DEV_GENERIC=y

CONFIG_BLK_DEV_RZ1000=y

CONFIG_BLK_DEV_IDEDMA_PCI=y

CONFIG_BLK_DEV_VIA82CXXX=y

CONFIG_BLK_DEV_IDEDMA=y

CONFIG_NET=y

CONFIG_PACKET=y

CONFIG_NETLINK_DEV=y

CONFIG_UNIX=y

CONFIG_INET=y

CONFIG_IP_MULTICAST=y

CONFIG_IP_ADVANCED_ROUTER=y

CONFIG_IP_MULTIPLE_TABLES=y

CONFIG_IP_ROUTE_FWMARK=y

CONFIG_SYN_COOKIES=y

CONFIG_NETFILTER=y

CONFIG_BRIDGE_NETFILTER=y

CONFIG_IP_NF_CONNTRACK=y

CONFIG_IP_NF_CONNTRACK_MARK=y

CONFIG_IP_NF_CT_PROTO_SCTP=y

CONFIG_IP_NF_FTP=y

CONFIG_IP_NF_IRC=y

CONFIG_IP_NF_TFTP=y

CONFIG_IP_NF_AMANDA=y

CONFIG_IP_NF_QUEUE=y

CONFIG_IP_NF_IPTABLES=y

CONFIG_IP_NF_MATCH_LIMIT=y

CONFIG_IP_NF_MATCH_IPRANGE=y

CONFIG_IP_NF_MATCH_MAC=y

CONFIG_IP_NF_MATCH_PKTTYPE=y

CONFIG_IP_NF_MATCH_MARK=y

CONFIG_IP_NF_MATCH_MULTIPORT=y

CONFIG_IP_NF_MATCH_TOS=y

CONFIG_IP_NF_MATCH_RECENT=y

CONFIG_IP_NF_MATCH_ECN=y

CONFIG_IP_NF_MATCH_DSCP=y

CONFIG_IP_NF_MATCH_AH_ESP=y

CONFIG_IP_NF_MATCH_LENGTH=y

CONFIG_IP_NF_MATCH_TTL=y

CONFIG_IP_NF_MATCH_TCPMSS=y

CONFIG_IP_NF_MATCH_HELPER=y

CONFIG_IP_NF_MATCH_STATE=y

CONFIG_IP_NF_MATCH_CONNTRACK=y

CONFIG_IP_NF_MATCH_OWNER=y

CONFIG_IP_NF_MATCH_PHYSDEV=y

CONFIG_IP_NF_MATCH_ADDRTYPE=y

CONFIG_IP_NF_MATCH_REALM=y

CONFIG_IP_NF_MATCH_SCTP=y

CONFIG_IP_NF_MATCH_COMMENT=y

CONFIG_IP_NF_MATCH_CONNMARK=y

CONFIG_IP_NF_MATCH_HASHLIMIT=y

CONFIG_IP_NF_FILTER=y

CONFIG_IP_NF_TARGET_REJECT=y

CONFIG_IP_NF_TARGET_LOG=y

CONFIG_IP_NF_TARGET_ULOG=y

CONFIG_IP_NF_TARGET_TCPMSS=y

CONFIG_IP_NF_NAT=y

CONFIG_IP_NF_NAT_NEEDED=y

CONFIG_IP_NF_TARGET_MASQUERADE=y

CONFIG_IP_NF_TARGET_REDIRECT=y

CONFIG_IP_NF_TARGET_NETMAP=y

CONFIG_IP_NF_TARGET_SAME=y

CONFIG_IP_NF_NAT_IRC=y

CONFIG_IP_NF_NAT_FTP=y

CONFIG_IP_NF_NAT_TFTP=y

CONFIG_IP_NF_NAT_AMANDA=y

CONFIG_IP_NF_MANGLE=y

CONFIG_IP_NF_TARGET_TOS=y

CONFIG_IP_NF_TARGET_ECN=y

CONFIG_IP_NF_TARGET_DSCP=y

CONFIG_IP_NF_TARGET_MARK=y

CONFIG_IP_NF_TARGET_CLASSIFY=y

CONFIG_IP_NF_TARGET_CONNMARK=y

CONFIG_BRIDGE=y

CONFIG_NET_SCHED=y

CONFIG_NET_SCH_CLK_JIFFIES=y

CONFIG_NET_SCH_CBQ=y

CONFIG_NET_SCH_HTB=y

CONFIG_NET_SCH_HFSC=y

CONFIG_NET_SCH_PRIO=y

CONFIG_NET_SCH_RED=y

CONFIG_NET_SCH_SFQ=y

CONFIG_NET_SCH_TEQL=y

CONFIG_NET_SCH_TBF=y

CONFIG_NET_SCH_GRED=y

CONFIG_NET_SCH_DSMARK=y

CONFIG_NET_SCH_NETEM=y

CONFIG_NET_SCH_INGRESS=y

CONFIG_NET_QOS=y

CONFIG_NET_ESTIMATOR=y

CONFIG_NET_CLS=y

CONFIG_NET_CLS_TCINDEX=y

CONFIG_NET_CLS_ROUTE4=y

CONFIG_NET_CLS_ROUTE=y

CONFIG_NET_CLS_FW=y

CONFIG_NET_CLS_U32=y

CONFIG_CLS_U32_PERF=y

CONFIG_NET_CLS_RSVP=y

CONFIG_NET_CLS_ACT=y

CONFIG_NET_ACT_POLICE=y

CONFIG_NET_ACT_MIRRED=y

CONFIG_NET_ACT_IPT=y

CONFIG_IRDA=y

CONFIG_NETDEVICES=y

CONFIG_DUMMY=y

CONFIG_TUN=y

CONFIG_NET_ETHERNET=y

CONFIG_MII=y

CONFIG_NET_PCI=y

CONFIG_8139CP=y

CONFIG_8139TOO=y

CONFIG_8139TOO_PIO=y

CONFIG_8139TOO_TUNE_TWISTER=y

CONFIG_VIA_RHINE=y

CONFIG_VIA_RHINE_MMIO=y

CONFIG_PPP=y

CONFIG_PPP_MULTILINK=y

CONFIG_PPP_FILTER=y

CONFIG_PPP_ASYNC=y

CONFIG_PPP_SYNC_TTY=y

CONFIG_PPP_DEFLATE=y

CONFIG_PPP_BSDCOMP=y

CONFIG_PPPOE=y

CONFIG_INPUT=y

CONFIG_INPUT_MOUSEDEV=y

CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024

CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768

CONFIG_SOUND_GAMEPORT=y

CONFIG_SERIO=y

CONFIG_SERIO_I8042=y

CONFIG_INPUT_KEYBOARD=y

CONFIG_KEYBOARD_ATKBD=y

CONFIG_VT=y

CONFIG_VT_CONSOLE=y

CONFIG_HW_CONSOLE=y

CONFIG_INOTIFY=y

CONFIG_UNIX98_PTYS=y

CONFIG_LEGACY_PTYS=y

CONFIG_LEGACY_PTY_COUNT=256

CONFIG_GEN_RTC=y

CONFIG_VGA_CONSOLE=y

CONFIG_DUMMY_CONSOLE=y

CONFIG_SPEAKUP_DEFAULT="none"

CONFIG_SOUND=y

CONFIG_SND=y

CONFIG_SND_TIMER=y

CONFIG_SND_PCM=y

CONFIG_SND_RAWMIDI=y

CONFIG_SND_SEQUENCER=y

CONFIG_SND_OSSEMUL=y

CONFIG_SND_MIXER_OSS=y

CONFIG_SND_PCM_OSS=y

CONFIG_SND_MPU401_UART=y

CONFIG_SND_AC97_CODEC=y

CONFIG_SND_VIA82XX=y

CONFIG_USB_ARCH_HAS_HCD=y

CONFIG_USB_ARCH_HAS_OHCI=y

CONFIG_EXT2_FS=y

CONFIG_EXT3_FS=y

CONFIG_JBD=y

CONFIG_DNOTIFY=y

CONFIG_AUTOFS4_FS=y

CONFIG_ISO9660_FS=y

CONFIG_JOLIET=y

CONFIG_ZISOFS=y

CONFIG_ZISOFS_FS=y

CONFIG_UDF_FS=y

CONFIG_UDF_NLS=y

CONFIG_PROC_FS=y

CONFIG_PROC_KCORE=y

CONFIG_SYSFS=y

CONFIG_DEVFS_FS=y

CONFIG_DEVFS_MOUNT=y

CONFIG_TMPFS=y

CONFIG_TMPFS_XATTR=y

CONFIG_RAMFS=y

CONFIG_NFS_FS=y

CONFIG_NFS_V3=y

CONFIG_NFS_V4=y

CONFIG_LOCKD=y

CONFIG_LOCKD_V4=y

CONFIG_SUNRPC=y

CONFIG_SUNRPC_GSS=y

CONFIG_RPCSEC_GSS_KRB5=y

CONFIG_SMB_FS=y

CONFIG_SMB_NLS_DEFAULT=y

CONFIG_SMB_NLS_REMOTE="cp850"

CONFIG_MSDOS_PARTITION=y

CONFIG_NLS=y

CONFIG_NLS_DEFAULT="iso8859-1"

CONFIG_NLS_CODEPAGE_437=y

CONFIG_NLS_CODEPAGE_850=y

CONFIG_NLS_ISO8859_1=y

CONFIG_NLS_ISO8859_15=y

CONFIG_EARLY_PRINTK=y

CONFIG_4KSTACKS=y

CONFIG_X86_FIND_SMP_CONFIG=y

CONFIG_X86_MPPARSE=y

CONFIG_CRYPTO=y

CONFIG_CRYPTO_HMAC=y

CONFIG_CRYPTO_MD5=y

CONFIG_CRYPTO_SHA1=y

CONFIG_CRYPTO_SHA256=y

CONFIG_CRYPTO_SHA512=y

CONFIG_CRYPTO_DES=y

CONFIG_CRYPTO_TWOFISH=y

CONFIG_CRYPTO_AES_586=y

CONFIG_CRYPTO_DEFLATE=y

CONFIG_CRC_CCITT=y

CONFIG_CRC32=y

CONFIG_LIBCRC32C=y

CONFIG_ZLIB_INFLATE=y

CONFIG_ZLIB_DEFLATE=y

CONFIG_GENERIC_HARDIRQS=y

CONFIG_GENERIC_IRQ_PROBE=y

CONFIG_X86_BIOS_REBOOT=y

CONFIG_PC=y
```

----------

## benjamin200

Hi

"Packet mangling" ist jetzt aktiviert, trotzdem selber Fehler. Ich mach jetzt mal im Net- und Iptables-Bereich alles rein. 

Feedback folgt!

Gruß,

Benjamin

----------

## benjamin200

 *Quote:*   

> 
> 
> Feedback folgt! 
> 
> 

 

Es funkioniert, blöd ist nur das ich nicht weiß, welche Option im Kernel dafür verantwortlich ist.

Zweites Problem:

Wenn ich folgende Befehle Eingebe:

```

# iptables -t nat -A PREROUTING -i ppp0 -p tcp -m state --state NEW -j DNAT --to 192.168.0.4

# iptables -A FORWARD -i ppp0 -o eth0 -p tcp -d 192.168.0.4 -m state --state NEW -j ACCEPT

```

kann ich nur den FORWARD Eintrag löschen, bei PREROUTING heißt es:

```

iptables -t nat -D PREROUTING -i ppp0 -p tcp -m state --state NEW -j DNAT --to 192.168.0.4

iptables: Bad rule (does a matching rule exist in that chain?)

```

Weiß jemand Rat?

Danke und Gruß,

Benjamin

----------

## benjamin200

 *Quote:*   

> 
> 
> kann ich nur den FORWARD Eintrag löschen, bei PREROUTING heißt es: 
> 
> Code: 
> ...

 

Mit iptables -X PREROUTING kann die Rule entfernt werden.

 *Quote:*   

> 
> 
> # iptables -t nat -A PREROUTING -i ppp0 -p tcp -m state --state NEW -j DNAT --to 192.168.0.4 
> 
> # iptables -A FORWARD -i ppp0 -o eth0 -p tcp -d 192.168.0.4 -m state --state NEW -j ACCEPT 
> ...

 

Mir kommt es jedoch so vor, als würden die oben genannten Befehle nicht alle Ports weiterleiten. Vor allem bei dynamischer Portvergabe scheint es noch zu Probleme zu führen. Gib es hier noch einen anderen Ansatz Punkt, wirklich alle Anfragen auf eine IP umzubiegen?

----------

