X-Git-Url: https://git.distorted.org.uk/~mdw/firewall/blobdiff_plain/44f9582788168b13a9163138f5e55bba889712e7..HEAD:/classify.m4

diff --git a/classify.m4 b/classify.m4
index 59ac3d9..98b9795 100644
--- a/classify.m4
+++ b/classify.m4
@@ -45,8 +45,9 @@ m4_divert(40)m4_dnl
 ###
 ### The mangle chains are arranged as follows.
 ###
-### The PREROUTING hook simply invokes in-classify and out-classify chains as
-### subroutines.  These will tail-call appropriate classification chains.
+### The INPUT and FORWARD hooks simply invoke in-classify and out-classify
+### chains as subroutines.  These will tail-call appropriate classification
+### chains.
 ###
 ### The in-classify chain is responsible for both source address
 ### classification and verifying that the packet arrived from the correct
@@ -56,11 +57,12 @@ m4_divert(40)m4_dnl
 ### goes to bad-source-address, which logs a message and drops the packet.
 ### The default interface is special.  If no explicit matches are found, it
 ### dispatches to in-default which forbids a few obviously evil things and
-### finally dispatches to mark-from-untrusted.
+### finally dispatches to mark-from-DEFAULT (usually `untrusted').
 ###
 ### The out-classify is simpler because it doesn't care about the interface.
 ### It simply checks each network range in turn, dispatching to mark-to-CLASS
-### on a match or mark-to-DEFAULT (probably untrusted) if there is no match.
+### on a match or mark-to-DEFAULT (probably `untrusted') if there is no
+### match.
 
 clearchain mangle:in-classify mangle:in-default mangle:out-classify
 clearchain mangle:local-source
@@ -70,10 +72,11 @@ clearchain mangle:local-source
 ## filter table.
 clearchain mangle:bad-destination-address
 BAD_DEST=0xf6f377d2
-ip46tables -t mangle -A bad-destination-address -j MARK --set-mark $BAD_DEST
-ip46tables -t mangle -A bad-destination-address -j ACCEPT
+run ip46tables -t mangle -A bad-destination-address \
+  -j MARK --set-mark $BAD_DEST
+run ip46tables -t mangle -A bad-destination-address -j ACCEPT
 for i in $inchains; do
-  ip46tables -A $i -m mark --mark $BAD_DEST -g bad-destination-address
+  run ip46tables -A $i -m mark --mark $BAD_DEST -g bad-destination-address
 done
 
 ## Packets over the loopback interface are automatically trusted.  All manner
@@ -93,7 +96,7 @@ run iptables -t mangle -A in-classify -j RETURN \
 ## over the loopback interface, I shouldn't see a packet from me over any
 ## other interface.  Except that I will if I sent a broadcast or multicast.
 ## Allow the broadcasts, and remember not to trust them.  There are no
-## broadcast addresses in IPv6 (only link-local multicast)m so we don't have
+## broadcast addresses in IPv6 (only link-local multicast) so we don't have
 ## to worry about that.
 run iptables -t mangle -A local-source -j RETURN \
 	-m addrtype --dst-type BROADCAST
@@ -128,7 +131,7 @@ run iptables -t mangle -A in-classify -g bad-source-address \
 run iptables -t mangle -A in-classify -g bad-source-address \
 	-m addrtype --src-type BROADCAST \
 
-## Special IPv6 addresses.  Format multicast sources, and mark zero and
+## Special IPv6 addresses.  Forbid multicast sources, and mark zero and
 ## link local addresses.
 for i in :: fe80::/10; do
   run ip6tables -t mangle -A in-classify -g mark-from-link -s $i
@@ -143,6 +146,7 @@ for i in 0.0.0.0 240.0.0.0/4; do
   run iptables -t mangle -A out-classify -g bad-destination-address -d $i
 done
 run iptables -t mangle -A out-classify -g mark-to-link -d 169.254.0.0/16
+run iptables -t mangle -A out-classify -g mark-to-link -d 255.255.255.255
 run iptables -t mangle -A out-classify -g mark-to-link \
 	-m addrtype --dst-type BROADCAST
 
@@ -170,155 +174,186 @@ run ip6tables -t mangle -A out-classify -g out-classify-mcast \
 ## Build the input classification chains.  There's one chain `in-IFACE' for
 ## each local interface.  This chain does a further dispatch on the source
 ## address to the appropriate `mark-from-CLASS' chain for the source network
-## class.
+## class.  We also build a table mapping interface names to numbers (since
+## the names are so unhelpful).
 seen=:
+ifq=0
+ifmap=""
 for iface in $host_ifaces_<::>FWHOST; do
   ifname=${iface%=*}
   case $seen in *:$ifname:*) continue ;; esac
   seen=$seen$ifname:
+  addword ifmap $ifname=$ifq
+  ifq=$(( $ifq + 1 ))
   clearchain mangle:in-$ifname
   run ip46tables -t mangle -A in-classify -i $ifname -g in-$ifname
 done
 
-## Now populate the `in-IFACE' and `out-classify' chains.  We iterate over
-## the available networks and add addresses to the appropriate chains.  Also,
-## build up a map of which interfaces receive from which address ranged so
-## that we can finish the chains off properly later.  This contains entries
-## of the form IFACE=:ADDR:ADDR:...:
-ifnets=""
+## We do a first pass over nets first, and then the interfaces which those
+## networks reach.  During this pass, we populate the `out-classify' chains,
+## and we also build some lists so that we can do later passes over
+## interfaces first and then reaching networks.  This is complicated by
+## interface names being unhelpful.
+##
+## Here are the variables we maintain.
+##
+## ifmap		A list of entries IFACE=N mapping interface names to
+##			numbers.
+##
+## ifnets_N		A space-separated list of networks reaching interface
+##			number N.  This is used for building the matching
+##			chains.
+##
+## ifaddrs_N		A bang-separated list of address ranges reaching
+##			interface number N.  This is used for filtering out
+##			known networks if the default network reaches the
+##			interface.
 for net in $allnets; do
 
-  ## Determine the addresses and class for this network, and populate the
-  ## `out-classify' chains.
-  eval addr=\$net_inet_$net addr6=\$net_inet6_$net class=\$net_class_$net
-  case $class in virtual) continue ;; esac
-  trace "$net : $class"
-  for a in $addr; do
-    run iptables -t mangle -A out-classify -g mark-to-$class -d $a
+  ## Work through the interfaces that this network reaches.
+  for iface in $(net_interfaces FWHOST $net); do
+    case $iface in -) break ;; esac
+
+    ## Find a sequence number for this interface.
+    q=nil
+    for i in $ifmap; do
+      case "$i" in "$iface"=*) q=${i##*=}; break ;; esac
+    done
+    case $q in
+      nil)
+	echo >&2 "$0 INTERNAL ERROR: missing interface \`$iface'!"
+	exit 1
+	;;
+    esac
+
+    ## Remember the reachability information.
+    addword ifnets_$q $net
   done
-  for a in $addr6; do
-    run ip6tables -t mangle -A out-classify -g mark-to-$class -d $a
+done
+
+## Build the `ifaddr_N' map and an `all-addresses' list.
+alladdrs=!
+trace "ifmap = $ifmap"
+for entry in $ifmap; do
+  iface=${entry%=*} q=${entry##*=}
+  eval nets=\$ifnets_$q
+  aa=!
+  for n in $nets; do
+    eval "addrs=\"\$net_inet_$n \$net_inet6_$n\""
+    trace "$iface $n addrs = $addrs"
+    for a in $addrs; do
+      case $aa in *!$a!*) ;; *) aa=$aa$a! ;; esac
+      case $alladdrs in *!$a!*) ;; *) alladdrs=$alladdrs$a! ;; esac
+    done
   done
+  eval ifaddrs_$q=\$aa
+  trace "iface $q = $iface; nets = $nets; addrs = $aa"
+done
+trace "alladdrs = $alladdrs"
 
-  ## Now work through the interfaces.
-  for iface in $(net_interfaces FWHOST $net); do
-    nets=""
-    case $iface in
+## Populate the `out-classify' chain, matching networks.
+prepare_to () { mode=goto fail=mark-to-$net_class_default; }
+matchnets -d mark-to : prepare_to out-classify "" 0 $allnets
 
-      -)
-	## A special `no interface' marker: we should not receive packets
-	## from this network at all.
-	continue
-	;;
+## A `finish' hook for rejecting known address ranges arriving on a
+## default-reachable interface.
+finish_from_default () {
+  q=$1 chain=$2
+  eval addrs=\$ifaddrs_$q
+
+  for n in $allnets; do
+    eval addr=\$net_inet_$n addr6=\$net_inet6_$n
+    for a in $addr; do
+      case $a in !*) continue ;; esac
+      case $addrs in *"!$a!"*) continue ;; esac
+      run iptables -t mangle -A $chain -s $a -g bad-source-address
+    done
+    for a in $addr6; do
+      case $a in !*) continue ;; esac
+      case $addrs in *"!$a!"*) continue ;; esac
+      run ip6tables -t mangle -A $chain -s $a -g bad-source-address
+    done
+  done
+  run ip46tables -t mangle -A $chain -g in-default
+}
+
+## A `prepare' hook for input classification.  If the interface is
+## default-reachable, then we need to reject known address ranges before
+## dispatching to the default chain; otherwise just reject the packet.
+prepare_from () {
+  q=$1 flags=$2
+  case $flags in
+    *:default:*) mode=call finish="finish_from_default $q" ;;
+    *) mode=goto fail=bad-source-address ;;
+  esac
+}
 
-      *-+)
-	## A special marker indicating a collection of point-to-point
-	## interfaces.  We should match an address to a particular interface.
-	## Later, we'll cap this chain off by rejecting all other traffic.
-	eval hosts=\$net_hosts_$net
+## Populate the `in-IFACE' chains.
+for entry in $ifmap; do
+  iface=${entry%=*} q=${entry##*=}
+  eval nets=\$ifnets_$q
+
+  case $iface in
+    *-+)
+      ## A special marker indicating a collection of point-to-point
+      ## interfaces.  We should match an address to a particular interface.
+      chains=""
+      for net in $nets; do
+	eval hosts=\$net_hosts_$net class=\$net_class_$net
 	for host in $hosts; do
 	  eval ha=\$host_inet_$host ha6=\$host_inet6_$host
 	  trace "$host : $class -> $iface"
 	  for a in $ha; do
 	    run iptables -t mangle -A in-$iface \
 		    -i ${iface%+}$host -s $a -g mark-from-$class
-	    nets=$nets$a:
 	  done
 	  for a in $ha6; do
 	    run ip6tables -t mangle -A in-$iface \
 		    -i ${iface%+}$host -s $a -g mark-from-$class
-	    nets=$nets$a:
 	  done
 	done
-	;;
-
-      *)
-	## A normal interface.  Classify incoming traffic according to the
-	## source address.
-	trace "$net : $class -> $iface"
-	for a in $addr; do
-	  run iptables -t mangle -A in-$iface -g mark-from-$class -s $a
-	  nets=$nets$a:
-	done
-	for a in $addr6; do
-	  run ip6tables -t mangle -A in-$iface -g mark-from-$class -s $a
-	  nets=$nets$a:
-	done
-	case $net in default) nets=${nets}default: ;; esac
-	;;
-    esac
-
-    ## Record that this interface receives traffic from this network.
-    unset nifnets
-    foundp=nil
-    for ifnet in $ifnets; do
-      case $ifnet in
-	$iface=*:$net:*) addword nifnets $ifnet; foundp=t ;;
-	$iface=*) addword nifnets $ifnet$nets; foundp=t ;;
-	*) addword nifnets $ifnet ;;
-      esac
-    done
-    case $foundp in nil) addword nifnets $iface=:$nets ;; esac
-    ifnets=$nifnets
-
-  done
-done
-
-## Wrap up all of the `in-IFACE' chains.  A chain which matches the `default'
-## net should have unmatched but known networks blocked off, and then chain
-## onto `in-default'.  Other chains should just chain onto
-## `bad-source-address'.
-trace "ifnets = $ifnets"
-for ifnet in $ifnets; do
-  iface=${ifnet%%=*} nets=${ifnet#*=}
-  case $nets in
-    *:default:*)
-      for n in $allnets; do
-	eval addr=\$net_inet_$n addr6=\$net_inet6_$n
-	for a in $addr; do
-	  case $nets in *:$a:*) continue ;; esac
-	  nets=$nets$a
-	  run iptables -t mangle -A in-$iface -s $a -g bad-source-address
-	done
-	for a in $addr6; do
-	  case $nets in *:$a:*) continue ;; esac
-	  nets=$nets$a
-	  run ip6tables -t mangle -A in-$iface -s $a -g bad-source-address
-	done
       done
-      run ip46tables -t mangle -A in-$iface -g in-default
+      run ip46tables -t mangle -A in-$iface -g bad-source-address
       ;;
     *)
-      run ip46tables -t mangle -A in-$iface -g bad-source-address
+      matchnets -s mark-from : "prepare_from $q" in-$iface "" 0 $nets
       ;;
   esac
 done
 
-## Fill in the black holes in the network.
+## Fill in the black holes in the network.  Some of these might actually be
+## known networks, so don't fill those in again.  See RFC5735 and RFC4291,
+## and their successors.
 for addr in \
 	10.0.0.0/8 172.16.0.0/12 192.168.0.0/16 \
 	127.0.0.0/8 \
 	192.0.2.0/24 198.51.100.0/24 203.0.113.0/24
 do
+  case $alladdrs in *!$addr!*) continue ;; esac
   run iptables -t mangle -A in-default -s $addr -g bad-source-address
 done
 for addr in \
-	fc00::/7 \
+	fc00::/7 fec0::/10 \
+	::0:0/96 ::ffff:0:0/96 \
 	2001:db8::/32
 do
+  case $alladdrs in *!$addr!*) continue ;; esac
   run ip6tables -t mangle -A in-default -s $addr -g bad-source-address
 done
 run ip46tables -t mangle -A in-default -g mark-from-$net_class_default
 
 m4_divert(92)m4_dnl
 ## Put the final default decision on the in-default chain, and attach the
-## classification chains to the PREROUTING hook.
+## classification chains to the INPUT and (maybe) FORWARD hooks.
 for iface in $defaultifaces; do
   run ip46tables -t mangle -A in-$iface -g in-default
 done
-run ip46tables -t mangle -A out-classify -g mark-to-$net_class_default
-run ip46tables -t mangle -A PREROUTING -j in-classify
-run ip46tables -t mangle -A PREROUTING -j out-classify
+chains="INPUT"
+case $forward in 1) chains="$chains FORWARD" ;; esac
+for c in $chains; do
+  run ip46tables -t mangle -A $c -j in-classify
+  run ip46tables -t mangle -A $c -j out-classify
+done
 
 ## Incoming stuff to or from a link-local address is OK.
 run ip46tables -t mangle -A INPUT \