INTRO

=====
Esta intro esta basada en el OpenBSD 3.8.
De estar configurado para que arranque con el SO, por defecto, en el archivo /et
c/pf.conf estan las reglas que aplica.
Con el comando pfctl se maneja el PF, y se pueden cambiar/ver parametros.
El PF tiene basicamente 7 partes.
SIEMPRE se tiene que respetar ese orden en la declaracion en el archivo de confi
guracion. Estas son:
A diferencia del iptables, el Packet Filter toma la configuracion de un
archivo y esa es la unica forma de cambiar/agregar/borrar las reglas del
Firewall. Obviamente para todo esto hay que ser root.
En las Analogias con iptables se mostraran las lineas en el archivo de
configuracion equivalentes a las reglas escritas con iptables desde command
line.
La diferencia escencial con iptables, es que con Packet Filter las relgas son
mucho mas intuitivas. Ademas el PF permite realizar Traffic Shaping muy
facilmente, ademas de diversas funcionalidades que permiten elevar el nivel de
seguridad de una red.
NOTA: este es un breve resumen. Para mas info remitirse a
"man pfctl", "man pf.conf" o "http://www.openbsd.org"
Utilidades
---------la forma de habilitar/deshabilitarlo:
# pfctl -e
# pfctl -d
para tomar las opciones
# pfctl -f pf.conf
para evaluar la sintaxis
# pfctl -nf pf.conf
para auto-optimizar las reglas (duplicados, conjunciones, inecesarias,...)
# pfctl -of pf.conf
Tambien sirve como el iptables para hacer flushes:
pfctl -F <(nat,queue,rules,state,Sources,info,Tables,osfp,all)>
Se pueden terminar conecciones determinadas
(todas entre los 2 hosts)
# pfctl -k 192.168.0.5 -k 192.168.0.1
(todas las de un host)

# pfctl -k 192.168.0.5
Listando
# pfctl -s <all,nat,queue,rules,Tables,...>
Por ultimo, con el "-z" se limpian las estadisitcas de cada regla.

1. macros
=========
Es la declaracion de variables
var="valor"
y se invoca como $var
Para indicar un conjunto de valores se puede usar
{ $var1 $var2 }
Esto sirve para opciones, puertos, IPs, etc.
2. tablas
=========
Conjunto de rangos para cuando se manejan cosas muy pesadas o para manejarlas co
modamente.
Estas tablas se pueden consultar/modificar desde linea de comando con pfctl.
Se pueden tener tablas inmutables para que no puedan ser modificadas con
pfctl.
El uso de tablas hacen que la performance aumente en comparacion a definir
varias IPs separadas en el pf.conf.
Esta es la sintaxis basica para el manejo de tablas:
pfctl -t <TABLA> -T<INSTRUCCION>
La instruccion puede ser: kill, add, show, flush, delete, replace, test, zero, l
oad
(en algunos casos hay que especificar el archivo de config)

3. opciones
===========
respuestas, timeout, performance, ...
las opciones no son obligatorias pero es recomendable setear algunas
Algunas sirven para ofuscamiento, otras para performance.
para loguear:
set loginterface $ext
si no queremos loguear nada

set loginterface none

se pueden setear limites de memoria, indicando la cantidad max de entradas
set limit states 20000
es importante la politica de bloqueo (drop o return)
set block-policy drop
Si queremos dejar una interface sin filtrar:
set skip on <if_ipsec>

4. normalizacion
================
scrub con sus opciones
generalmente se usa un "scrub in all" con alguna que otra opcion.
Esto hace que se filtren todos los paquetes invalidos.
La analogia con iptables podria ser el estado invalido
se puede agregar, por ej. "random-id"
pf
-"scrub in all random id"
netfilter para "scrub in all"
------------------------------"iptables -p tcp -m state --state INVALID -j DROP"
Se puede usar una funcion de PF para ofuscar timestamp, ttl y prevenir ciertos
ataques:
scrub in all random id reassemble tcp
Esta ultima opcion habria que testearla un poco con NAT para ver el
rendimiento
5. colas
========
Hay 3 tipos.
Son probabilisticas con bandwidth y/o prioridades.
Todas las colas tienen que tener una subcola por defecto.
Cuando se matchean paquetes, en la parte de Filtering, se mandan de terminados p
aquetes a una cola definida en esta parte.
Se pueden definir subcolas en cada cola. Una subcola es a su vez una cola, la di
ferencia es que la cola maestra define el ancho de banda, el tipo y sus subcolas
no pueden salirse de esos parametros. No hay colas mixtas.

Aca entramos a la parte de reglas

=================================

7. Filtering
============
NOTA: puse la parte 7 antes que la 6 para explicar bien el armado de reglas.
Cabe aclarar que las reglas de NAT van antes que las de FILTERING.
Aca declaramos paquetes que entran, salen y forwarding. Algo similar a INPUT,
OUTPUT y FORWARD del iptables. Tambien se declaran aca los paquetes que van a
alguna cola (que tuvo que haber sido definida definida en el punto 5).
Diferencias con iptables
------------------------ No hay politicas, solo reglas
- La politica por defecto es aceptar todo. Hagamos de cuenta que al final hay un
"pass all"
- se evalua la ultima regla que matchea salvo que pongamos la opcion "quick" en
la regla
- No se diferencian FORWARD y OUTPUT. Solo tenemos "in" y "out"
- No hay mas que 2 acciones: "pass" o "block"
- si queremos loguear lo especificamos en la misma regla (tiene que estar
habilitada la interface de logueo en las opciones)
- En PF tenemos la palabra reservada "any" para matchear un parametro
- Tambien tenemos la palabra reservada "all" para indicar "from any to any"
- No hay nada asociado layer7
- Hay cosas muy locas como "os fingerprinting", "probabilistic dropping" y "syn
proxy"
- En lugar de tener una tabla MANGLE se pueden marcar paquetes y matchear con
esa marca.
- Existe la posibilidad de hacer balancing de enlaces de diferentes formas
- Aparte del archivo de config pcpal se pueden cargar otros con ANCHOR
La forma es la siguiente
-----------------------<pass|block> <in|out> [quick] [log] on <INTERFACE> af <inet|inet6> proto <PROTOC
OLO> \
from <HOST_SRC> port <SRC_PORT> os <OS_SRC> to <HOST_DST> port <PORT_DST> \
flags <FLAGS> [keep state] [queue COLA]
Los parametros "pass o block" , "in o out" son obligatorios.
El resto son todos opcionales.
El parametro "flags" indica los flags del TCP.
El parametro "keep state" es para realizar el tracking de las conecciones (state
ESTABLISHED, RELATED del iptables).
Opciones Utiles
--------------Si queremos generalizar un poco las reglas, podemos evitar poner IPs.

Nos podemos referir a la/s ip/s de una interface de la sgte forma:

($ext_if) nos da las IP de la interface.
($ext_if:0) nos da la IP sin los alias.
($ext_if:broadcast) nos da el broadcast de la interface.
Negativos y matching de parametros
---------------------------------Esta marte es mas comoda que el iptables.
=
!=
<
<=
>
>=
:
><
<>

(equal)
(unequal)
(less than)
(less than or equal)
(greater than)
(greater than or equal)
(range including boundaries)
(range excluding boundaries)
(except range)

se pueden especificar puertos por rangos, conjuntos o variables:

port 2000:2004
port {21,80,443}
port $allow_ports
TCP Flags
--------Lo mas comun es setear el parametro "flags" para aceptar conecciones:
pass in on $ext_if proto tcp from 200.123.156.99 to ($ext_if) \
port 22 flags S/SA keep state

Ejemplo de reglas
----------------block in all
pass in on $int inet proto tcp from 172.0.0.0/8 os Linux to ($int) port 22 flags
S/SA keep state queue ssh
pass out on $int all keep state queue std
pass log all
Con esto solo permito conecciones al ssh, desde el rango 172.0.0.0/8, desde sist
emas operativos Linux, trackeando la coneccion y permitiendo paquetes de inicio
de coneccion y de conecciones ya establecidas. Ademas, envio esos paquetes a la
cola ssh, definida en la seccion de colas.
Mando todo el trafico saliente a la cola std. Logueamos todo lo demas.
Analogias con iptables
---------------------block in all
iptables -P INPUT DROP

block out all

iptables -P OUTPUT DROP
iptables -P FORWARD DROP
tambien podemos setear todo en drop (lo que seria equivalente a los 3 policy
drop en iptables):
block all
Reglas de paquetes entrantes
pass in on $ext_if inet proto icmp from any to ($ext_if) icmp-type 8 code 0
keep state
iptables -A INPUT -i $ext_if -p icmp --icmp-type 8 -j ACCEPT
pass in quick on $ext_if inet proto tcp from any to ($ext_if) port {21,80,4
43} flags S/SA keep state
iptables -A INPUT -i $ext_if -p tcp --dport 80 -m state --state NEW -j ACCE
PT
iptables -A INPUT -i $ext_if -p tcp --dport 21 -m state --state NEW -j ACCE
PT
iptables -A INPUT -i $ext_if -p tcp --dport 443 -m state --state NEW -j ACC
EPT
iptables -A INPUT -i $ext_if -m state --state ESTABLISHED,RELATED -j ACCEPT
Reglas de paquetes generados localmente
pass in from ($ext_if) to any keep state
iptables -A OUTPUT -j ACCEPT
table <servers> const { 10.0.0.2, 10.0.0.5 }
pass in from $mi_ip to <servers> keep state
iptables -A OUTPUT -d 10.0.0.2 -j ACCEPT
iptables -A OUTPUT -d 10.0.0.5 -j ACCEPT
Reglas de Forwarding
pass in on $ext_if proto tcp from 10.0.0.5 to 10.0.0.10 port 80 keep
state
iptables -A FORWARD -i $ext_if -p tcp --dport 80 -s 10.0.0.5 -d 10.0.0.1
0:80 -j ACCEPT
iptables -A FORWARD -i $ext_if -p tcp --dport 80 -s 10.0.0.5 -d 10.0.0.1
0:80 -j ACCEPT

6. NAT
======
NOTA: en la parte 7 se explica el funcionamiento general de las reglas.
tenemos 3 palabras reservadas: nat, binat y rdr
6.1 - nat: para multiplexacion de IPs de una LAN hacia INET
nat on sis0 from host1 -> $host2

6.2 - binat: cuando el nat es bidireccional

6.3 - rdr: cuando se quiere cambiar el src/dst/ host/port de algun paquete en pa
rticular. Similar al PRE/POSTROUTING del iptables.
NOTA: En PF no existen reglas/parametros especificos para redirecciones hacia
puertos locales como REDIR en iptables. Las reglas son mas genericas. Por ej.
para un proxy transparente:
ej:

rdr on sis0 proto tcp from any to any port 80 -> 127.0.0.1 port 8080

Analogia con iptables

--------------------iptables
-------iptables -t nat -o $ext -A POSTROUTING -s 192.168.100.20 -d 200.56.68.77 -j MASQ
UERADE
iptables -t nat -A PREROUTING -i $ext -p tcp -s 200.123.56.11 --dport 2222 -j
DNAT --to-destination 192.168.0.5:22
PF
-nat on $ext from 192.168.100.20 -> 200.56.68.77
rdr on $ext proto tcp from 200.123.56.11 to any port 2222 -> 192.168.0.5 port 22

EJEMPLO FINAL
=============
-------------------------- archivo pf.conf -----------------------------#
# MACROS
#
ext="xl0"
int="sis0"
#
# TABLES
#
table <lan> const { 10/8, 172.16/12, 192.168/16 }
#
# OPTIONS
#
# logueamos trafico de la ext
set loginterface $ext
set fingerprints "/etc/pf.os"

# seteamos el tipo de red que tenemos

set optimization normal
# seteamos las politicas por defecto
# tipo de resp. que le damos al block
set block-policy drop
#
# TRAFFIC NORMALIZATION
#
# normalizamos el trafico y randomizamos el id de los paquetes
scrub in all random-id
#
# QUEUEING
#
altq on $ext cbq bandwidth 10Mb queue {std, ssh, web}
queue std bandwidth 10% priority 2 cbq(default)
queue ssh bandwidth 50% priority 1 cbq(borrow)
queue web bandwidth 40% priority 0 cbq(borrow)
#
# NAT
#
nat on $ext from !($ext) -> ($ext:0)
rdr on $ext proto tcp from any to any port 80 -> 127.0.0.1 port 8080
#
# Filtering
#
block in all
pass quick on lo0 all
pass in on $int inet proto tcp from <lan> os Linux to ($int) port 22 \
flags S/SA keep state queue ssh
pass in on $int inet proto tcp from <lan> os Linux to ($int) port 80 \
flags S/SA keep state queue web
pass out on $int all keep state queue std
pass log all
-------------------------------------------------------------------------