[IPFW] Netzwerk darf alles, "Internet" nichts?

stagger · 24 März 2005

Hi,

ich bin neulich von Gentoo auf FreeBSD umgestiegen und habe im Moment so meine Mühe mit der Firewall. Da ist auch schon ein nettes Buch unterwegs, aber so lange will ich meinen Server nicht als Zielscheibe im Netz stehen haben. Es geht um folgendes: Bei Gentoo hatte ich Shorewall laufen, eine Art Frontend für iptables, das mir folgende Einstellung kinderleicht ermöglichte: "Die Rechner aus dem Heimnetz dürfen was sie wollen, aber von außen ist alles dicht". Sowas hatte ich mit ipfw versucht, bin aber nur soweit gekommen, dass anscheinend alle Pakete, wie HTTP-Anfragen, das Netzwerk verlassen haben, doch die eigentlichen Daten aus dem Internet durften dann nicht mehr rein. Gibt es eine einfache Implementation, die unter FreeBSD erstmal leistet, was Shorewall unter Gentoo für mich gemacht hat? Wie gesagt, von jedem x-beliebigen Internet-PC soll ich nicht mal sichtbar sein, es sei denn ich oder ein Netzwerk-PC initiiert die Verbindung.

Schönen Dank schon mal im voraus

miguel · 24 März 2005

Da kann ich nur auf folgende Seite verweisen. http://www.bsdbox.de/firewall.html

Da steht alles drin, um das umzusetzen, was Du vorhast. Inbesondere wegen NATD

Gruß, Miguel

docvalde · 24 März 2005

stagger schrieb:
"Die Rechner aus dem Heimnetz dürfen was sie wollen, aber von außen ist alles dicht"

Schau mal hier: http://m.bsdhackers.org/howto/index_html_ipfw#firewall

Gruß,

-doc

stagger · 24 März 2005

Schande über mich, dass ich das nicht gefunden hab! Aber danke

[EDIT]
Läuft so nicht! Es tritt genau das Problem auf, das ich vorher auch hatte: Der Server trennt alle Verbindungen zum Netzwerk, SSH geht also nicht mehr und ich darf in den Keller rennen, um das alte Skript zu laden. Ich hab die Konfiguration nicht zu 100% übernommen, sondern etwas angepasst. Hier ist sie:

Code:

#!/bin/sh

# Standardvariablen setzen
outside="tun0"          # out interface
modem="rl0"             # DSL-Modem
inside="re0"            # Lokales Netzwerk
cmd="/sbin/ipfw -q"     # Befehlspräfix
trusted="192.168.1.1/24"        # Das lokale Netz

# Alte Regeln verwerfen
$cmd flush

# Transparenter Squid Proxy
$cmd add allow tcp from me to any
$cmd add fwd 127.0.0.1,3128 tcp from $trusted to any 80

# NAT
$cmd add divert natd all from any to any via $modem

# Das Loopback Gerät nicht behindern
$cmd add allow ip from any to any via lo0

# Alles rauslassen
$cmd add allow all from any to any via $outside keep-state

# Aber nicht alles rein
$cmd add allow tcp from any to me 80  via $outside keep-state    # HTTP
$cmd add allow tcp from any to me 443 via $outside keep-state    # HTTPS
$cmd add allow tcp from any to me 21  via $outside keep-state    # FTP-Ctrl
$cmd add allow tcp from any to me 22  via $outside keep-state    # ssh


# Den Rest verbieten
$cmd add deny all from any to any

miguel · 25 März 2005

Zunächst scheinst Du in folgender Zeile einen Fehler zu haben:

# NAT
$cmd add divert natd all from any to any via $modem

$modem steht bei Dir für rl0. Es sollte aber für das Interface tun0 stehen.

Ansonsten:

1. Läuft der NATD überhaupt?!
2. Steht in der /etc/rc.config: gateway_enable="YES" ?
3. Wurde der Kernel mit options IPDIVERT kompiliert?

Björn König · 25 März 2005

Du solltest auf jeden Fall eine check-state-Regel verwenden, wenn du schon keep-state benutzt, also z.B. ipfw add check-state. Sonst bringt das ja keine Pluspunkte.

Das funktioniert etwa folgendemaßen, Beispiel:

ipfw add allow tcp from $internes_netz to any setup keep-state
ipfw add allow udp from $internes_netz to any keep-state
ipfw add check-state
ipfw deny all from any to any

Die erste Regel erlaubt ausgehende Pakete, die eine Verbindung aufbauen wollen und merkt sich das. Die zweite macht etwa gleiche für UDP-Pakete. Die dritte sorgt dafür, dass die Antwortpakete der zuvor hergestellten Verbindungen auch wieder reinkommen. Die vierte verwirft alles andere.

Die Regel für natd kannst du weglassen, denn soweit ich deine Absichten verstanden habe brauchst du das nicht.

gateway_enable="YES" muss in die /etc/rc.conf; das macht das gleiche wie ein manuelles sysctl net.inet.ip.forwarding=1.

Das sollte es auch schon gewesen sein. Router leicht gebaut. ;-)

Gruß Björn

h0sch1 · 25 März 2005

Hi

Kannst dir ja mal meine angucken:

Code:

#!/bin/sh
###
### FreeBSD Firewall Script V1.2
###
### Author: Manuel Strauch ( ma.strauch@gmx.de )
###
###############################################################################
###
### Changes:
###
### 02.01.05 Firewall erstellt V1.0
### 12.01.05 Portredirection hinzugefuegt V1.1
### 19.01.05 Code optimiert
### 25.01.05 Debug Option hinzugefuegt "./firewall -debug"
### 01.02.05 Ausgaben erweitert
### 14.02.05 kleinere Bugs behoben
### 28.02.05 Sysctl-Einstellungen hinzugefuegt, die richtig gesetzt werden
###          sollten
###          net.inet.ip.fw.enable=1
###          net.link.ether.ipfw=1
###          net.inet.ip.forwarding=1
### 10.03.05 Kommentare gesetzt
### 17.03.05 Dokumentation ( weiter unten ) erweitert 
###
###############################################################################
###
###  Benoetigte Optionen fuer den Kernel
###  
###  options IPFIREWALL
###  options IPFIREWALL_VERBOSE
###  options IPFIREWALL_VERBOSE_LIMIT=100
###  options IPDIVERT                        ## Masquerading
###
###############################################################################
###  
###  Benoetigte Optionen fuer DSL Support im Kernel
###
###  options NETGRAPH
###  options NETGRAPH_ETHER
###  options NETGRAPH_SOCKET
###  options NETGRAPH_PPPOE
###
###############################################################################
###
###  Benoetigte Optionen in der Datei /etc/make.conf
###
###  IPFW2=YES
###  NO_PF=YES
###
###############################################################################
###
###  Firewall aktivieren:
###
###  Datei /etc/rc.conf editieren:
###
###  firewall_enable="YES"
###  firewall_script="/opt/bin/firewall"
###
###
###  NAT ( Network Address Translation ) aktivieren:
###
###  natd_programm="/sbin/natd"
###  natd_enable="YES"
###  natd_interface="tun0"
###
###  natd_flags="-dynamic -f /etc/firewall/natd.conf"
###  ## Nur wenn PortRedirection nicht ueber dieses Firewall Script
###  ## verwendet wird
###
###
###  Gateway aktivieren:
###
###  gateway_enable="YES"
###
###############################################################################
###
### Variablen evtl. anpassen!
loopback="lo0"
lan="fxp0 tap0 "
wan="tun0"
masq_lan="192.168.31.0/24 "
open_tcp_ports=" "
open_udp_ports=" "
dns_server1="127.0.0.1"
dns_server2="192.168.31.22"

### Port Forwarding
portforwarding="no"
portforwarding_activ="0"

tcp_port_forwarding_0="8000 8001 8002 8003"
udp_port_forwarding_0="9000 9001 9002 9003"
forwarding_ip_0="192.168.31.20"

tcp_port_forwarding_1=" "
udp_port_forwarding_1=" "
forwarding_ip_1=" "

tcp_port_forwarding_2=" "
udp_port_forwarding_2=" "
forwarding_ip_2=" "

tcp_port_forwarding_3="3000 "
udp_port_forwarding_3=" "
forwarding_ip_3=" "

tcp_port_forwarding_4=" "
udp_port_forwarding_4=" "
forwarding_ip_4=" "

tcp_port_forwarding_5=" "
udp_port_forwarding_5=" "
forwarding_ip_5=" "

tcp_port_forwarding_6=" "
udp_port_forwarding_6=" "
forwarding_ip_6=" "

tcp_port_forwarding_7=" "
udp_port_forwarding_7="6000"
forwarding_ip_7="192.168.31.50 "

tcp_port_forwarding_8=" "
udp_port_forwarding_8=" "
forwarding_ip_8=" "

tcp_port_forwarding_9=" "
udp_port_forwarding_9=" "
forwarding_ip_9=" "

### Port Redirection
portredirection="no"
portredirection_activ="0"

tcp_port_from_0="1900 1901 33000"
udp_port_from_0="4000 4001 4002 4003 "
tcp_port_redirection_0="2000 2200 5000"
udp_port_redirection_0="6000 6001 6002 6003 "
redirection_ip_0="192.168.31.20"

tcp_port_from_1=" "
udp_port_from_1=" "
tcp_port_redirection_1=" "
udp_port_redirection_1=" "
redirection_ip_1=" "

tcp_port_from_2=" "
udp_port_from_2=" "
tcp_port_redirection_2=" "
udp_port_redirection_2=" "
redirection_ip_2=" "

tcp_port_from_3=" "
udp_port_from_3=" "
tcp_port_redirection_3="3000 "
udp_port_redirection_3=" "
redirection_ip_3=" "

tcp_port_from_4=" "
udp_port_from_4=" "
tcp_port_redirection_4=" "
udp_port_redirection_4=" "
redirection_ip_4=" "

tcp_port_from_5=" "
udp_port_from_5=" "
tcp_port_redirection_5=" "
udp_port_redirection_5=" "
redirection_ip_5=" "

tcp_port_from_6=" "
udp_port_from_6=" "
tcp_port_redirection_6=" "
udp_port_redirection_6=" "
redirection_ip_6=" "

tcp_port_from_7=" "
udp_port_from_7=" "
tcp_port_redirection_7=" "
udp_port_redirection_7="6000"
redirection_ip_7="192.168.31.50 "

tcp_port_from_8=" "
udp_port_from_8=" "
tcp_port_redirection_8=" "
udp_port_redirection_8=" "
redirection_ip_8=" "

tcp_port_from_9=" "
udp_port_from_9=" "
tcp_port_redirection_9=" "
udp_port_redirection_9=" "
redirection_ip_9=" "


###############################################################################
# AB HIER FINGER WEG AB HIER FINGER WEG AB HIER FINGER WEG AB HIER FINGER WEG #
###############################################################################

# ESC Parameter
rc_failed="\033[80C\033[10D\033[1;31m-= shit =-\033[m"
rc_done="\033[80C\033[10D\033[1;34m -= OK =-\033[m"
rot="\033[1;31m"
lila="\033[1;35m"
normal="\033[m"
blau="\033[1;34m"
gruen="\033[1;32m"
braun="\033[1;33m"
cyan="\033[1;36m"
version="V1.2"
echo_flag="-n"
ipfw_flag="-q"

### Programm ab hier!
if [ "$1" = "-debug" ]; then
  debug=" log"
else
  debug=" "
fi

echo "starting FreeBSD firewall ${version}"

if [ -e /sbin/ipfw ]; then
  ipfw="/sbin/ipfw ${ipfw_flag}"
else
  echo ${echo_flag} "can't find ipfw"
  echo -e "${rc_failed}"
  exit 1
fi
return="${rc_done}"
## Firewall aktivieren
/sbin/sysctl net.inet.ip.fw.enable=1 >/dev/null
/sbin/sysctl net.link.ether.ipfw=1 >/dev/null
## Forwarding aktivieren
/sbin/sysctl net.inet.ip.forwarding=1 >/dev/null

# Erstmal alles loeschen was da ist
echo ${echo_flag} "remove all rules"
${ipfw} -f flush || return="${rc_failed}"
echo -e "${return}"
return="${rc_done}"

# Loopback darf alles
if [ "${loopback}" != " " ]; then
  echo ${echo_flag} "actived loopback"
  ${ipfw} add 00100 allow ${debug} all from any to any \
    via ${loopback} || return="${rc_failed}"
  echo -e "${return}"
fi
return="${rc_done}"

# Internet für alle
if [ "${wan}" != " " ]; then
  if [ "${masq_lan}" != " " ]; then
    echo ${echo_flag} "actived internet ( masquerade ) for: ${masq_lan}"
    number="150"
    for i in ${masq_lan}; do
      for w in ${wan}; do
        ${ipfw} add 00${number} divert natd ${debug} all from ${i} to any \
          via ${w} || return="${rc_failed}"
        number=`expr ${number} + 1`
      done
    done
    echo -e "${return}"
  fi
fi
return="${rc_done}"

# Stateful Packet Inspection
echo ${echo_flag} "actived inspection for all packets"
${ipfw} add 00200 check-state || return="${rc_failed}"
echo -e "${return}"
return="${rc_done}"

# Intern ist alles offen
if [ "${lan}" != " " ]; then
  echo ${echo_flag} "actived lan device(s)"
  number=210
  for i in ${lan}; do
    ${ipfw} add 00${number} allow ${debug} all from any to any \
      via ${i} keep-state || return="${rc_failed}"
    number=`expr ${number} + 1`
  done
  echo -e "${return}"
fi
return="${rc_done}"

# Anti-Spoofing
if [ "${wan}" != " " ]; then
  echo ${echo_flag} "actived anti-spoofing rules"
  number=220
  for i in ${wan}; do
    ${ipfw} add 00${number} deny log ip from 10.0.0.0/8 to any \
      via ${i} || return="${rc_failed}"
    ${ipfw} add 00`expr ${number} + 1` deny log ip from 172.16.0.0/12 to any \
      via ${i} || return="${rc_failed}"
    ${ipfw} add 00`expr ${number} + 2` deny log ip from 192.168.0.0/16 to any \
      via ${i} || return="${rc_failed}"
    number=`expr ${number} + 3`
  done
  echo -e "${return}"
fi
return="${rc_done}"

# Fragmentierte Packete werden verworfen
if [ "${wan}" != " " ]; then
  echo ${echo_flag} "actived anti-ddos rules"
  number=250
  for i in ${wan}; do
    ${ipfw} add 00${number} deny ${debug} all from any to any frag in \
      via ${i} || return="${rc_failed}"
    number=`expr ${number} + 1`
  done

# ACK Packete ohne vorherige REQ werden geblockt
  number=260
  for i in ${wan}; do
    ${ipfw} add 00${number} deny ${debug} tcp from any to any established in \
      via ${i} || return="${rc_failed}"
    number=`expr ${number} + 1`
  done
  echo -e "${return}"
fi
return="${rc_done}"

# Erlaubt alle Verbindungen welche vom LAN initiiert wurden
if [ "${wan}" != " " ]; then
  echo ${echo_flag} "allow beginn traffic from lan"
  number=300
  for i in ${wan}; do
    ${ipfw} add 00${number} allow ${debug} tcp from any to any out \
      via ${i} setup keep-state || return="${rc_failed}"
    ${ipfw} add 00`expr ${number} + 1` allow ${debug} udp from any to any out \
      via ${i} keep-state || return="${rc_failed}"
    number=`expr ${number} + 2`
  done
  echo -e "${return}"
fi
return="${rc_done}"

# Verbindungen die bereits existieren dürfen offen bleiben
if [ "${wan}" != " " ]; then
  echo ${echo_flag} "allow services, they have activity in the moment"
  number="320"
  for i in ${wan}; do
    ${ipfw} add 00${number} allow ${debug} tcp from any to any \
      via ${i} established || return="${rc_failed}"
    number=`expr ${number} + 1`
  done
  echo -e "${return}"
fi
return="${rc_done}"

# Offene TCP Ports
if [ "${open_tcp_ports}" != " " ]; then
  echo ${echo_flag} "open tcp ports: ${open_tcp_ports}"
  number="400"
  for i in ${open_tcp_ports}; do
    ${ipfw} add 00${number} allow ${debug} tcp from any to any ${i} \
      setup keep-state || return="${rc_failed}"
    number=`expr ${number} + 1`
  done
  echo -e "${return}"
fi
return="${rc_done}"

# Offene UDP Ports
if [ "${open_udp_ports}" != " " ]; then
  echo ${echo_flag} "open udp ports: ${open_udp_ports}"
  number="500"
  for i in ${open_udp_ports}; do
    ${ipfw} add 00${number} allow ${debug} udp from any to any ${i} \
      keep-state || return="${rc_failed}"
    number=`expr ${number} + 1`
  done
  echo -e "${return}"
fi

return="${rc_done}"

if [ "${portforwarding}" = "YES" ] || [ "${portforwarding}" = "yes" ]; then
  echo "starting portforwarding"
  for i in ${portforwarding_activ}; do
    case "${i}" in
      0)
        tcp_port_forwarding="${tcp_port_forwarding_0}"
        udp_port_forwarding="${udp_port_forwarding_0}"
        forwarding_ip="${forwarding_ip_0}"
	tcp_number="2000"
	udp_number="2100"
      ;;
      1)
        tcp_port_forwarding="${tcp_port_forwarding_1}"
        udp_port_forwarding="${udp_port_forwarding_1}"
        forwarding_ip="${forwarding_ip_1}"
	tcp_number="2200"
	udp_number="2300"
      ;;
      2)
        tcp_port_forwarding="${tcp_port_forwarding_2}"
        udp_port_forwarding="${udp_port_forwarding_2}"
        forwarding_ip="${forwarding_ip_2}"
	tcp_number="2400"
	udp_number="2500"
      ;;
      3)
        tcp_port_forwarding="${tcp_port_forwarding_3}"
        udp_port_forwarding="${udp_port_forwarding_3}"
        forwarding_ip="${forwarding_ip_3}"
	tcp_number="2600"
	udp_number="2700"
      ;;
      4)
        tcp_port_forwarding="${tcp_port_forwarding_4}"
        udp_port_forwarding="${udp_port_forwarding_4}"
        forwarding_ip="${forwarding_ip_4}"
	tcp_number="2800"
	udp_number="2900"
      ;;
      5)
        tcp_port_forwarding="${tcp_port_forwarding_5}"
        udp_port_forwarding="${udp_port_forwarding_5}"
        forwarding_ip="${forwarding_ip_5}"
	tcp_number="3000"
	udp_number="3100"
      ;;
      6)
        tcp_port_forwarding="${tcp_port_forwarding_6}"
        udp_port_forwarding="${udp_port_forwarding_6}"
        forwarding_ip="${forwarding_ip_6}"
	tcp_number="3200"
	udp_number="3300"
      ;;
      7)
        tcp_port_forwarding="${tcp_port_forwarding_7}"
        udp_port_forwarding="${udp_port_forwarding_7}"
        forwarding_ip="${forwarding_ip_7}"
	tcp_number="3400"
	udp_number="3500"
      ;;
      8)
        tcp_port_forwarding="${tcp_port_forwarding_8}"
        udp_port_forwarding="${udp_port_forwarding_8}"
        forwarding_ip="${forwarding_ip_8}"
	tcp_number="3600"
	udp_number="3700"
      ;;
      9)
        tcp_port_forwarding="${tcp_port_forwarding_9}"
        udp_port_forwarding="${udp_port_forwarding_9}"
        forwarding_ip="${forwarding_ip_9}"
	tcp_number="3800"
	udp_number="3900"
      ;;
    esac
    
    # TCP Port Forwarding
    echo "- starting action -= ${i} =-"
    if [ "${tcp_port_forwarding}" != " " ]; then
      echo " | actived tcp port forwarding: "
      if [ "${forwarding_ip}" != " " ]; then
        echo ${echo_flag} \
	  " |- port(s): ${tcp_port_forwarding} to: ${forwarding_ip}"
        for t in ${tcp_port_forwarding}; do
          ${ipfw} add 00${tcp_number} allow ${debug} tcp from any to ${forwarding_ip} \
            ${t} setup keep-state || return="${rc_failed}"
          tcp_number=`expr ${tcp_number} + 1`
        done
      else
        return="${rc_failed}"
	echo ${echo_flag} "  forwarding_ip is not set"
      fi
      echo -e "${return}"
    fi
    return="${rc_done}"

    # UDP Port Forwarding
    if [ "${udp_port_forwarding}" != " " ]; then
      echo " | actived udp port forwarding"
      if [ "${forwarding_ip}" != " " ]; then
        echo ${echo_flag} \
	  " |- port(s): ${udp_port_forwarding} to: ${forwarding_ip}"
        for u in ${udp_port_forwarding}; do
          ${ipfw} add 00${udp_number} allow ${debug} udp from any to ${forwarding_ip} \
            ${u} keep-state || return="${rc_failed}"
          udp_number=`expr ${udp_number} + 1`
        done
      else
        return="${rc_failed}"
	echo ${echo_flag} "  forwarding_ip is not set"
      fi
      echo -e "${return}"
    fi
    return="${rc_done}"
  done
fi

return="${rc_done}"
if [ "${portredirection}" = "YES" ] || [ "${portredirection}" = "yes" ]; then
  echo "starting portredirection"
  for i in ${portredirection_activ}; do
    case "${i}" in
      0)
        tcp_port_from="${tcp_port_from_0}"
	udp_port_from="${udp_port_from_0}"
        tcp_port_redirection="${tcp_port_redirection_0}"
        udp_port_redirection="${udp_port_redirection_0}"
        redirection_ip="${redirection_ip_0}"
	tcp_number="4000"
	udp_number="4100"
      ;;
      1)
        tcp_port_from="${tcp_port_from_1}"
	udp_port_from="${udp_port_from_1}"
        tcp_port_redirection="${tcp_port_redirection_1}"
        udp_port_redirection="${udp_port_redirection_1}"
        redirection_ip="${redirection_ip_1}"
	tcp_number="4200"
	udp_number="4300"
      ;;
      2)
        tcp_port_from="${tcp_port_from_2}"
	udp_port_from="${udp_port_from_2}"
        tcp_port_redirection="${tcp_port_redirection_2}"
        udp_port_redirection="${udp_port_redirection_2}"
        redirection_ip="${redirection_ip_2}"
	tcp_number="4400"
	udp_number="4500"
      ;;
      3)
        tcp_port_from="${tcp_port_from_3}"
	udp_port_from="${udp_port_from_3}"
        tcp_port_redirection="${tcp_port_redirection_3}"
        udp_port_redirection="${udp_port_redirection_3}"
        redirection_ip="${redirection_ip_3}"
	tcp_number="4600"
	udp_number="4700"
      ;;
      4)
        tcp_port_from="${tcp_port_from_4}"
	udp_port_from="${udp_port_from_4}"
        tcp_port_redirection="${tcp_port_redirection_4}"
        udp_port_redirection="${udp_port_redirection_4}"
        redirection_ip="${redirection_ip_4}"
	tcp_number="4800"
	udp_number="4900"
      ;;
      5)
        tcp_port_from="${tcp_port_from_5}"
	udp_port_from="${udp_port_from_5}"
        tcp_port_redirection="${tcp_port_redirection_5}"
        udp_port_redirection="${udp_port_redirection_5}"
        redirection_ip="${redirection_ip_5}"
	tcp_number="5000"
	udp_number="5100"
      ;;
      6)
        tcp_port_from="${tcp_port_from_6}"
	udp_port_from="${udp_port_from_6}"
        tcp_port_redirection="${tcp_port_redirection_6}"
        udp_port_redirection="${udp_port_redirection_6}"
        redirection_ip="${redirection_ip_6}"
	tcp_number="5200"
	udp_number="5300"
      ;;
      7)
        tcp_port_from="${tcp_port_from_7}"
	udp_port_from="${udp_port_from_7}"
        tcp_port_redirection="${tcp_port_redirection_7}"
        udp_port_redirection="${udp_port_redirection_7}"
        redirection_ip="${redirection_ip_7}"
	tcp_number="5400"
	udp_number="5500"
      ;;
      8)
        tcp_port_from="${tcp_port_from_8}"
	udp_port_from="${udp_port_from_8}"
        tcp_port_redirection="${tcp_port_redirection_8}"
        udp_port_redirection="${udp_port_redirection_8}"
        redirection_ip="${redirection_ip_8}"
	tcp_number="5600"
	udp_number="5700"
      ;;
      9)
        tcp_port_from="${tcp_port_from_9}"
	udp_port_from="${udp_port_from_9}"
        tcp_port_redirection="${tcp_port_redirection_9}"
        udp_port_redirection="${udp_port_redirection_9}"
        redirection_ip="${redirection_ip_9}"
	tcp_number="5800"
	udp_number="5900"
      ;;
    esac
    t_dummy=" "
    t_dummy2=" "
    all_ok="shit"
    all_ok2="shit"
    # TCP Port redirection
    echo "- starting action -= ${i} =-"
    if [ "${tcp_port_redirection}" != " " ]; then
      echo " | actived tcp port redirection: "
      if [ "${redirection_ip}" != " " ]; then
        if [ "${tcp_port_from}" != " " ]; then
          echo " |- from: any:${tcp_port_from} "
          echo ${echo_flag} " |- to: ${redirection_ip}:${tcp_port_redirection}"
	  for t in ${tcp_port_redirection}; do
	    echo "${t_dummy}" | grep "${t}" >/dev/null || all_ok="ok"
	    for t2 in ${tcp_port_from}; do
	      echo "${t_dummy2}" | grep "${t2}" >/dev/null || all_ok2="ok"
	      t_dummy2="${t_dummy2} ${t2}"
	      if [ "${all_ok}" = "ok" ]; then
	        if [ "${all_ok2}" = "ok" ]; then
	          ${ipfw} add 00${tcp_number} allow ${debug} tcp from any ${t2}\
		    to ${redirection_ip} ${t} setup keep-state \
		    || return="${rc_failed}"
                  tcp_number=`expr ${tcp_number} + 1`
		  all_ok="shit"
		  t2_double="${t2_double} ${t2}"
		fi
	      fi
	      all_ok2="shit"
	    done
	    t_dummy="${t_dummy} ${t}"
	    t_dummy2="${t2_double}"
          done
        else
	  return="${rc_failed}"
	  echo ${echo_flag} "  tcp_port_from is not set"
	fi
      else
        return="${rc_failed}"
	echo ${echo_flag} "  redirection_ip is not set"
      fi
      echo -e "${return}"
    fi
    return="${rc_done}"

    # UDP Port redirection
    u_dummy=" "
    u_dummy2=" "
    all_ok="shit"
    all_ok2="shit"
    if [ "${udp_port_redirection}" != " " ]; then
      echo " | actived udp port redirection"
      if [ "${redirection_ip}" != " " ]; then
        if [ "${udp_port_from}" != " " ]; then
          echo " |- from: any:${udp_port_from}" 
          echo ${echo_flag} " |- to: ${redirection_ip}:${udp_port_redirection}"
          for u in ${udp_port_redirection}; do
	    echo "${u_dummy}" | grep "${u}" >/dev/null || all_ok="ok"
  	    for u2 in ${udp_port_from}; do
	      echo "${u_dummy2}" | grep "${u2}" >/dev/null || all_ok2="ok"
	      u_dummy2="${u_dummy2} ${u2}"
	      if [ "${all_ok}" = "ok" ]; then
	        if [ "${all_ok2}" = "ok" ]; then
                  ${ipfw} add 00${udp_number} allow ${debug} udp from any ${u2}\
		  to ${redirection_ip} ${u} keep-state || return="${rc_failed}"
                  udp_number=`expr ${udp_number} + 1`
		  all_ok="shit"
		  u2_double="${u2_double} ${u2}"
		fi
	      fi
	      all_ok2="shit"
	    done
	    u_dummy="${u_dummy} ${u}"
	    u_dummy2="${u2_double}"
          done
	else
	  return="${rc_failed}"
	  echo ${echo_flag} "  udp_port_from is not set"
	fi
      else
        return="${rc_failed}"
	echo ${echo_flag} "  redirection_ip is not set"
      fi
      echo -e "${return}"
    fi
    return="${rc_done}"
  done
fi

return="${rc_done}"

# Sendet RESET an alle Ident Pakete, welche auf Port 113 tcp eingehen
if [ "${wan}" != " " ]; then
  echo ${echo_flag} "reset all ident services"
  number="6000"
  for i in ${wan}; do
    ${ipfw} add 00${number} reset log tcp from any to me 113 in \
      via ${i} || return="${rc_failed}"
    number=`expr ${number} + 1`
  done
  echo -e "${return}"
fi
return="${rc_done}"

# Erlaubt ausgehende DNS Queries Nur auf angegebene DNS-Server
if [ "${wan}" != " " ]; then
  first="0"
  if [ "${dns_server1}" != " " ]; then
    if [ ${first} -eq 0 ]; then
      echo ${echo_flag} "allow dns querie(s) to: ${dns_server1}"
      first="1"
    fi
    number="6100"
    for i in ${wan}; do
      for d in ${dns_server1}; do
        ${ipfw} add 00${number} allow ${debug} udp from any to ${d} 53 out via \
          ${i} keep-state || return="${rc_failed}"
        ${ipfw} add 00`expr ${number} + 1` allow ${debug} tcp from any to ${d} 53 \
	  out via ${i} setup keep-state || return="${rc_failed}"
        number=`expr ${number} + 1`
      done
    done
    echo -e "${return}"
  fi
  return="${rc_done}"
  first="0"
  if [ "${dns_server2}" != " " ]; then
    if [ ${first} -eq 0 ]; then
      echo ${echo_flag} "allow dns querie(s) to: ${dns_server2}"
      first="1"
    fi
    number="6150"
    for i in ${wan}; do
      for d in ${dns_server2}; do
        ${ipfw} add 00${number} allow ${debug} udp from any to ${d} 53 \
	out via ${i} keep-state || return="${rc_failed}"
        ${ipfw} add 00`expr ${number} + 1` allow ${debug} tcp from any \
	to ${d} 53 out via ${i} setup keep-state || return="${rc_failed}"
        number=`expr ${number} + 1`
      done
    done
    echo -e "${return}"
  fi
fi
return="${rc_done}"

# Loggt ICMP Anfragen (echo und dest. unreachable) == script kiddies
if [ "${wan}" != " " ]; then
  echo ${echo_flag} "logging icmp scanners"
  number="7000"
  for i in ${wan}; do
    ${ipfw} add 0${number} allow log icmp from any to any in \
      recv ${i} icmptype 3 || return="${rc_failed}"
    ${ipfw} add 0`expr ${number} + 1` allow log icmp from any to any in \
      recv ${i} icmptype 8 || return="${rc_failed}"
    number=`expr ${number} + 2`
  done
  echo -e "${return}"
fi
return="${rc_done}"

# ICMP von innen nach aussen zulassen
echo ${echo_flag} "allow icmp from lan to wan"
${ipfw} add 07100 allow ${debug} icmp from me to any \
  icmptypes 8 keep-state || return="${rc_failed}"
${ipfw} add 07110 allow ${debug} icmp from any to me \
  icmptypes 3,4,11 || return="${rc_failed}"
echo -e "${return}"
return="${rc_done}"

# Alles andere machen wir dicht und wird nicht geloggt
echo ${echo_flag} "drop all others"
${ipfw} add 65000 deny ${debug} ip from any to any || return="${rc_failed}"
echo -e "${return}"

exit 0

stagger · 25 März 2005

Das ist der neueste Stand der Dinge:

Code:

#!/bin/sh

# Standardvariablen setzen
outside="tun0"          # out interface
inside="re0"            # Lokales Netzwerk
cmd="/sbin/ipfw -q"     # Befehlspräfix
trusted="192.168.1.1/24"        # Das lokale Netz

# Alte Regeln verwerfen
$cmd flush

# Transparenter Squid Proxy
$cmd add allow tcp from me to any
$cmd add fwd 127.0.0.1,3128 tcp from $trusted to any 80

# Das Loopback Gerät nicht behindern
$cmd add allow ip from any to any via lo0

# Verbindungen aus dem Netzwerk zulassen
$cmd add allow tcp from $trusted to any keep-state
$cmd add allow udp from $trusted to any keep-state
$cmd add check-state

# Den Rest verbieten
$cmd add deny all from any to any

Benutze ich setup in der Regel, die TCP-Verkehr aus dem Netzwerk immer erlauben soll, geht gar nichts mehr. Jedenfalls wird die SSH-Verbindung auf der Stelle unterbrochen.
Die NAT-Regel konnte ich weglassen. Wofür braucht man die denn überhaupt? Muss ich natd dann noch laufen lassen?
So wie das Skript hier steht, bleibt die SSH-Verbindung erhalten, aber ins Internet komme ich nicht. Da scheitert schon die Namensauflösung. Das ändert sich auch mit NAT-Regel nicht, sonst hätte ich sie ja nicht weglassen können.

Kannst dir ja mal meine angucken

Danke, ist nett gemeint, aber da ich keine Ahnung von Shell-Skripten habe, die mehr machen als nur nacheinander Programme auszuführen, versteh ich da leider nur Bahnhof. Ich werd mir das sicher noch aneignen, nur im Moment gehts nicht. Man kann ja auch nicht alles auf einmal machen...

Björn König · 25 März 2005

Vielleicht wären noch solche Regeln vorneweg hilfreich:

Code:

add allow all from $trusted to me in via $inside
add allow all from me to $trusted out via $inside

Damit stellst du erstmal sicher, dass der interne Verkehr auf jeden Fall funktioniert.

Ansonsten kann ich dir nur zu meiner Fehlersuchemethode raten:

das log-Schlüsselwort verwenden
Paketzähler von `ipfw show` genau beobachten
fünfminütigen Cronjob einrichten, der eine SSH-Verbindung ermöglicht

Es ist u.U. auch hilfreich bei den Regeln mit einer höheren Regel-Nummer zu beginnen, beispielsweise 1000. Dann kann man vorher zu Testzwecken andere Dinge wie z.B. Zählerregeln einfügen:

Code:

   flush

   add 10 allow all from $trusted to me 22 in via $inside
   add 11 allow all from me 22 to $trusted out via $inside

   # Beispiel zählt den Verkehr eingehend und ausgehend über interne Schnittstelle
   add 20 count all from any to any in via $inside
   add 21 count all from any to any out via $inside

   # weitere Regeln
   add 1000 allow ...
   add allow ...
   add deny ...

Gruß Björn

Björn König · 25 März 2005

noch etwas zu natd vergessen:

Bei mir hat das früher ppp gemacht, deswegen verwende ich natd nicht. Heute macht der Paketfilter pf für mich. NAT ist dafür da, die Adressen in den IP-Paketen umzuschreiben, stark vereinfachtes Beispiel:

Client A schickt mit seiner Adresse [X] ein Paket über einen Router [Y] an [bsdforen]. Der Router schreibt die Absenderadresse so um, dass [bsdforen] glaubt das Paket käme von [Y], und [bsdforen] schickt die Antwort zurück an [Y]. Der Router schreibt die Empfängeradresse wieder um, so dass das Paket von [bsdforen] direkt an [X] adressiert erscheint. So verläuft die Kommunikation problemlos zwischen [X] und [bsdforen] ohne, dass [bsdforen] direkt mit [X] kommunizieren können muss.

natd könnte man jetzt zusätzlich einsetzen, um verschiedene Dienste auf Clients von außen erreichbar zu machen, also z.B. ein Web-Server auf Client A oder ein Esel auf Client B. Das kann ppp übrigens auch; wesentlich einfacher, aber dafür kann man nur NAT-Regeln ändern, wenn man die Verbindung trennt und wiederherstellt. Aber das alles würde ich erst angehen, wenn der einfache Betrieb läuft. Zu natd siehe auch mein NATd-Poster.

Du hast tun0 als externe Schnittstelle, daher nehme ich einfach mal an, dass du ppp verwendest. Guck in dem Fall mal nach ob die NAT-Funktion von ppp aktiviert ist: `ps aux | grep ppp`, entweder steht da '-nat' in der Befehlszeile oder es ist in /etc/ppp/ppp.conf mit nat enable yes im Profil festgelegt.

Gruß Björn

stagger · 25 März 2005

Der interne Verkehr funktioniert doch, wenn ich "setup" weglasse! Was nicht funktioniert, ist der Verkehr nach draußen.

[IPFW] Netzwerk darf alles, "Internet" nichts?

stagger

LogWing

miguel

FreeBSD Frischling

docvalde

Well-Known Member

stagger

LogWing

miguel

FreeBSD Frischling

Björn König

Well-Known Member

h0sch1

Well-Known Member

stagger

LogWing

Björn König

Well-Known Member

Björn König

Well-Known Member

stagger

LogWing

Wir schützen deine Privatsphäre