Monthly Archives: marzo 2010

AMARRAR IP Y MAC

-Opcion 1:
-Amarrando con iptables:

 iptables -A FORWARD -s 192.0.2.100 -m mac --mac-source ! 
00:21:B7:F4:77:73 -j DROP

-Opcion 2:
-Amarrando con arp estatico:
-Creamos el archivo “/etc/ethers” y agregamos los ip y mac de los clientes, y para las demas ip’s se anula la direccion mac:


192.0.2.100 00:21:B7:F4:77:73
192.0.2.200 00:1F:1F:A3:33:D3
192.0.2.185 00:21:22:AD:7B:82
192.0.2.2 00:00:00:00:00:00
192.0.2.3 00:00:00:00:00:00
192.0.2.4 00:00:00:00:00:00

-Aqui por ejemplo los clientes son solamente los 3 primeros en la lista.
-Luego en “/etc/network/interface” agregamos al final “post-up /usr/sbin/arp -f”, esto carga automaticamente el archivo “/etc/ethers” a las tabla arp.

-La opcion 1 es la más lenta.

DELAY POOLS PARA CONTROL DE ANCHO DE BANDA

Una breve introducción :

delay_pools n

esto quiere decir que vamos hacer n reglas, de acceso limitado

delay_class r m

Estamos configurando la r-ésima regla de las n’s que hemos definido al principio, dénse cuenta que sólo hay n delay pools definidos al inicio, asi r <= n.
El “m” quiere decir el tipo de clase que tendrá la regla r-ésima. Hay 3 tres tipos de clases, la 1,2 y 3:
si m=1: Esto quiere decir que se aplicara una regla de acceso limitado a todos lo que esten detrás del proxy sin importar como esten estructurados dentro de la lan.
si m=2: Esto quiere decir que vamos a aplicar una regla de acceso limitado a todos los que esten detrás del proxy (o 256 usuarios), y a la ves vamos a limitar a una misma velocidad a cada uno de estos usuarios, que estén detrás del proxy.
si m=3: Esto es hacer un delay pools de clase 1 con 256 delay pools de clase 2 que son subordinados de este.

delay_parameters r [p1/q1 p2/q2 … (r filtros)]

Con esto estamos limitando el ancho de banda según la clase que presenta el delay pools “r”, el p1/q1 quiere decir que vamos a descargar todo el ancho de banda (sí asi es) hasta que superemos los q1 bytes; luego nos limitara con la velocidad de p1 bytes por segundo.
por ejemplo para r=1:

delay_parameters 1 p1/q1

para un r=2:

delay_parameters 2 p1/q1 p2/q2

el primer “p1/q1” es para el total de usuarios dentro de la lan, y el “p2/q2” es para cada usuario conectado detras del proxy en este caso.

Tener presente que los valores p1, q1, p2, q2..etc deben ser dados en bytes.

delay_access r [allow, deny] [parm1, parm2, etc]
delay_access r [allow, deny] [parm1, parm2, etc]

delay_access r2 [allow, deny] [parm1, parm2, etc]
delay_access r2 [allow, deny] [parm1, parm2, etc]

Aqui vamos a decir que condiciones deben de cumplir los usuarios (como: La hora, ip fuente, ip destino, la pagina que visitan,que extenciones quieren descargar, path’s..etc ), para que se les aplique una de las r-esimas reglas ya definidas anteriormente, (en delay parameters).
Las condiciones estan dadas por los parámetros parm1, parm2 …, definidos en los acl’s del squid mismo. (vea los ejemplos al final)
Para hacer las condiciones hay que tener presente 2 cosas:
1: De las lineas:
delay_acces r [allow deny] [parm1 parm2 parm3]
delay_acces r [allow deny] [parm4 parm5 ]
nos quiere decir que a un usuario se les aplicará la regla “r”, si y sólo sí es cierto la proposicion lógica:
( parm1 & parm2 & parm3 ) | (parm4 & parm5),

A manera de nota: “&” denota “y” y el “|” denota el “o”.
2: Otra cosa que tenemos que tener presente es que si un usuario ya se le asigna una regla, entonces ya no ba a ser remplazadla por otra, esto es que si entra en una regla ya no pasa por las demás delay access.
ahora veamos unos ejemplos de como usar delay pools en squid:
e.g 1:

acl tiempo time 18:00-22:30
acl internet src 0/0
delay_pools 1

delay_class 1 2

delay_access 1 allow tiempo
delay_access 1 deny !tiempo
delay_access 1 allow internet

delay_parameters 1 20240/20240 20240/20240

Aqui Restringimos el acceso a internet con 19kB/s la descarga, a cada uno de los usuarios, en el horario “tiempo”

Otro ejemplo de uso un poco más compleja:

Aqui queremos hacer que nuestra lan (192.0.2.x) tenga una velocidad de descarga de 150KB/s SOLO sobre los archivos de extenciones .exe, .mp3, .avi, etc. en las HORAS de la noche (6:00 pm a 11:55 pm), ademas por si fuera poco, queremos que los usuarios descargen desde el proxy(192.0.2.1) a toda velocidad, esto puede servir si estamos haciendo cache de los videos (como por ejemplo thundercache o videocache), asi poder servir los videos cacheados sin restriccion como deberia de ser.

#192.0.2.1 es nuestra ip que tiene el proxy dentro de la lan.
acl intranet url_regex 192.0.2.1 
acl tiempo time 18:00-22:30
acl internet src 0/0
acl extensiones_descargas url_regex -i 	
.flv$ .exe$ .mp3$  .zip$ .rar$ .avi$ .mpeg$  .mpg$  .iso$ .raw$ .wav$ .mov$  .wmv$ .dvd$ .mpg$ .mpeg$ .7z$

#delay pools
delay_pools 2
delay_class 1 2
delay_class 2 2

#descargar a toda velocidad solo si se conectan al proxy
delay_parameters 1  -1/-1 -1/-1
delay_access 1 allow intranet
#descarga restringida a 150KB/s sobre algunas extenciones cuando accedan a internet, y estemos 
#sobre la hora "tiempo".
delay_parameters 2 150240/150240 150240/150240
delay_access 2 allow extensiones_descargas tiempo

Saludos.

BLOQUEO DE P2P CON IPTABLES

Con esto estamos diciendo que en nuestro proxy transparente sólo tendra salida ciertos puertos, como el 80(http), 53(dns), 443(https)..etc, y los demás van a estar bloqueados, como el p2p, que usan los puertos del 1025 a 65535.
Tengamos en cuenta que estamos haciendo uso de un squid transparente, para mas info vea la instalación y configuración de squid en ubuntu
Las siguientes lineas, se guardan en un archivo “proxy_rules.sh” en “/etc/init.d/” :

la LAN es: 192.0.2.0/24 y su puerta de enlace es 192.0.2.1(en la interfaz eth1 del proxy) y su salida a internet es atraves del ip: 192.168.1.191(de la interfaz eth0 del proxy).


LAN="192.0.2.0/24"
PROXY_IP="192.168.1.191"
WAN="eth0"
LAN_I="eth1"

iptables -t nat -A PREROUTING -i $LAN_I -p tcp --dport 80 -j DNAT --to $PROXY_IP:3128
iptables -t nat -A PREROUTING -i $WAN -p tcp --dport 80 -j REDIRECT --to-port 3128
#HTTP
iptables -t nat -A POSTROUTING -o $WAN -s $LAN -p tcp --dport 80 -j SNAT --to $PROXY_IP
iptables -t nat -A POSTROUTING -o $WAN -s $LAN -p udp --dport 80 -j SNAT --to $PROXY_IP
#DNS
iptables -t nat -A POSTROUTING -o $WAN -s $LAN -p udp --dport 53 -j SNAT --to $PROXY_IP
iptables -t nat -A POSTROUTING -o $WAN -s $LAN -p tcp --dport 53 -j SNAT --to $PROXY_IP
#SSH
#ICMP
iptables -t nat -A POSTROUTING -o $WAN -s $LAN -p icmp -j SNAT --to $PROXY_IP
#HTTPS
iptables -t nat -A POSTROUTING -o $WAN -s $LAN -p tcp --dport 443 -j SNAT --to $PROXY_IP
#POP3
iptables -t nat -A POSTROUTING -o $WAN -s $LAN -p tcp --dport 995 -j SNAT --to $PROXY_IP
#MSN
iptables -t nat -A POSTROUTING -o $WAN -s $LAN -p tcp --dport 1863 -j SNAT --to $PROXY_IP
#ATAQUES DDOS
iptables -t nat -N SYN-FLOOD
iptables -t nat -A SYN-FLOOD -m limit --limit 12/s --limit-burst 24 -j RETURN
iptables -t nat -A SYN-FLOOD -j DROP
#
iptables -t nat -A PREROUTING -i $WAN -d $PROXY_IP -p tcp --syn -j SYN-FLOOD 
echo 1 > /proc/sys/net/ipv4/ip_forward

Luego le damos permisos de ejecución:

chmod +x proxy_rules.sh

Luego editamos el archivo “/etc/init.d/rc.local” y le agregamos al inicio:

cd /etc/init.d
./proxy_rules.sh

Con esto las reglas iptables se cargan automáticamente cada vez que se reinicie el proxy.

saludos.

INSTALACIÓN DE IPP2P

Seguramente muchos de ustedes dueños o administradores de redes que tienen a cargo una red wiriless o una cabina de internet, les habrá fastidiado, los programas tipo p2p como el ares, limewire, bittorrent .. etc, pues para quienes tengan implemetado un proxy como squid (si no, pueden ver como se instala en ubuntu ), existe un módulo como Ipp2p, el cual permite justamente bloquear y controlar estos programas p2p, basándose en el comportamiento que tienen estos, a la hora de querer conectarce a sus nodos por medio de muchos puertos simultaneamente.
Nota:
A mí me funcionó según lo provisto, esto es que sí filtraba los p2p, pero cuando teníamos una máquina en donde ya había un ares con descargas pauseadas, osea ya estaba funcionando, en este caso cuando dicha máquina entraba en nuestra red, como parte de nuestra lan, entonces, los p2p’s en particular ares sí podían descargar, violando las reglas del ipp2p, entonces decidimos hacer un bloqueo por puertos esto lo podemos ver en bloqueo de p2p por iptables.

Ahora veamos como se instala este módulo en nuestro ubuntu 9.04:
Empecemos:

su
cd /usr/src

*Preparando al sistema

apt-get install iptables-dev
apt-get install linux-source-$(uname -r)
apt-get install build-essential kernel-package libncurses5
apt-get install linux-headers-$(uname -r)

*Descomprimimos el kernel-source

bunzip2 linux-source-$(uname -r).tar.bz2
tar -xvf linux-source-2.6.18.tar

*Creamos un enlace simbolico a linux-source-*

ln -s linux-source-2.6.18/ linux

*Descargar IPP2P y los parches para el kernel 2.8.22 y 2.8.28 (el nuestro es 2.8.28-11-generic), además de parches para iptables 1.4.0 y 1.4.1.

wget http://www.ipp2p.org/downloads/ipp2p-0.8.2.tar.gz
wget http://aur.archlinux.org/packages/ipp2p/ipp2p/ipp2p-0.8.2-kernel-2.6.22.patch
wget http://aur.archlinux.org/packages/ipp2p/ipp2p/ipp2p-0.8.2-kernel-2.6.28.patch
wget http://aur.archlinux.org/packages/ipp2p/ipp2p/ipp2p-0.8.2-iptables-1.4.0.patch
wget http://aur.archlinux.org/packages/ipp2p/ipp2p/ipp2p-0.8.2-iptables-1.4.1.patch

*Parchamos IPP2P para nuestro kernel.

tar xvzf ipp2p-0.8.2.tar.gz
  cd ipp2p-0.8.2
  patch -p1 < ../ipp2p-0.8.2-kernel-2.6.22.patch
  patch -p1 < ../ipp2p-0.8.2-kernel-2.6.28.patch
  patch -p1 < ../ipp2p-0.8.2-iptables-1.4.0.patch
  patch -p1 < ../ipp2p-0.8.2-iptables-1.4.1.patch

*Editamos el archivo “libipt_ipp2p.c”
y editamos la estructura:

struct xtables_match ipp2p=
{
.next = NULL,
.name = "ipp2p",
.family = PF_INET,
.version = XTABLES_VERSION, ##<-- Aquí hacemos el cambio
.size = XT_ALIGN(sizeof(struct ipt_p2p_info)),
.userspacesize = XT_ALIGN(sizeof(struct ipt_p2p_info)),
...
}

*Guardamos cambios
*Editamos el archivo “Makefile”
*Editamos la linea:

ld -shared -o libipt_ipp2p.so libipt_ipp2p.o

-cambiando “ld” por el compilador gcc “$(CC)”

$(CC) -shared -o libipt_ipp2p.so libipt_ipp2p.o

*Guardamos cambios
*Ejecutamos:

  make

-Hasta aqui no debe de presentarnos ningún error, en caso de error revisemos los pasos anteriores.
*Y finalmente copiamos los archivos compilados en carpetas pertenecientes a iptables y squid.

  cp libipt_ipp2p.so /lib/xtables/
  cp ipt_ipp2p.ko /lib/modules/$(uname -r)/kernel/net/netfilter/
  depmod -a

* Probamos:

  iptables -m ipp2p --help

Ejemplo de uso:

iptables -A FORWARD -p udp -m ipp2p --edk --dc --kazaa --gnu --bit --apple --winmx --soul --ares -j DROP
iptables -A FORWARD -p tcp -m ipp2p --edk --dc --kazaa --gnu --bit --apple --winmx --soul --ares -j DROP

o en su forma simplificada:

iptables -I FORWARD -p tcp -m ipp2p --ipp2p -j DROP
iptables -I FORWARD -p udp -m ipp2p --ipp2p -j DROP

Saludos.

INSTALACIÓN DE PROXY TRANSPARENTE CON SQUID

Sistema proxy (dos tarjetas de red):
Notas:

eth0 : Interfaz para la entrada de internet(WAN)
eth1 : Interfaz para nuestra red local(LAN)

red internet:   eth0
ip  de salida internet:  192.168.1.2
puerta de enlace: 192.168.1.1

red  local:   eth1
ip para la entrada lan: 192.168.0.1
puerta de enlace: <vacío>

ip pc cliente:  192.168.0.x

Se prueba con la distribución ubuntu 9.04, pero esto puede aplicarse a toda distribución basada en debian, y con algunas modificaciones, también a distribuciones basadas en redhat.
Hagamos la configuración de internet, para nuestro ubuntu:

-Desactivamos las interfaces de red.

sudo ifdown eth0
sudo ifdown eth1
 

-Editamos el archivo “/etc/network/interfaces”
copiar:
Para la interfaz de salida

auto lo
iface lo inet loopback
auto eth0
iface eth0 inet static
address 192.168.1.2
netmask 255.255.255.0
network 192.168.1.0
broadcast  192.168.1.255
gateway 192.168.1.1

Para la interfaz de entrada, y seguido de lo anterior:

auto eth1
iface eth1 inet static
address  192.168.0.1
netmask 255.255.255.0
network 192.168.0.0
broadcast 192.168.0.255

Guardamos y salimos.
Editar el archivo “/etc/resolv.conf”, y agregar las dns de nuestro proveedor de internet o el que deseemos
Copiar: (caso telefónica Perú)

nameserver 200.48.225.130
nameserver  200.48.225.146

Luego reiniciamos el servicio:

sudo  /etc/init.d/networking restart

*Ahora que tenemos nuestras interfaces configuradas, procedemos a instalar squid, en este caso lo probamos con squid V2.7.STABLE3

sudo apt-get install squid

configuramos squid transparente

sudo gedit /etc/squid/squid.conf

modificamos:

http_port 3128 transparent
cache_mem 30 mb
cache_dir ufs /var/spool/squid 2000 16 256

Agregamos lo siguiente antes de donde dice:
“http_access deny !Safe_ports”

acl red_local src 192.168.0.0/24
acl localhost src  127.0.0.1/32
http_access allow localhost
http_access allow red_local

reemplazamos en “maximum_object_size_in_memory 8 KB” por “maximum_object_size_in_memory 100 KB”
Esto indica que haremos cache de a lo más 100KB, esto debe depender de cada uno.
reemplazamos en “cache_replacement_policy lru” por “cache_replacement_policy heap gdsf”
Con esto indicamos el tipo de algoritmo que se ha de seguir para poder administrar los archivos que se encuentran en cache.
para más información visitar aqui.
Luego la parte esencial de todo esto, la configuración de los patrones de refresco.

# Debian
refresh_pattern -i \.deb$   129600 100% 129600
refresh_pattern -i \.gz$   129600 100% 129600
refresh_pattern -i \.bz2$   129600 100% 129600

# Imagenes
refresh_pattern -i \.gif$ 14400 80% 43200
refresh_pattern -i \.tiff?$ 14400 80% 43200
refresh_pattern -i \.bmp$ 14400 80% 43200
refresh_pattern -i \.jpe?g$ 14400 80% 43200
refresh_pattern -i \.xbm$ 14400 80% 43200
refresh_pattern -i \.png$ 14400 80% 43200
refresh_pattern -i \.wrl$ 14400 80% 43200
refresh_pattern -i \.ico$ 14400 80% 43200
refresh_pattern -i \.pnm$ 14400 80% 43200
refresh_pattern -i \.pbm$ 14400 80% 43200
refresh_pattern -i \.pgm$ 14400 80% 43200
refresh_pattern -i \.ppm$ 14400 80% 43200
refresh_pattern -i \.rgb$ 14400 80% 43200
refresh_pattern -i \.ppm$ 14400 80% 43200
refresh_pattern -i \.rgb$ 14400 80% 43200
refresh_pattern -i \.xpm$ 14400 80% 43200
refresh_pattern -i \.xwd$ 14400 80% 43200
refresh_pattern -i \.pict?$ 14400 80% 43200

# Movies
refresh_pattern -i \.mov$ 14400 80% 43200
refresh_pattern -i \.mpe?g?$ 14400 80% 43200
refresh_pattern -i \.avi$ 14400 80% 43200
refresh_pattern -i \.qtm?$ 14400 80% 43200
refresh_pattern -i \.viv$ 14400 80% 43200
refresh_pattern -i \.swf$ 14400 80% 43200

# Sounds
refresh_pattern -i \.wav$ 14400 80% 43200
refresh_pattern -i \.aiff?$ 14400 80% 43200
refresh_pattern -i \.au$ 14400 80% 43200
refresh_pattern -i \.ram?$ 14400 80% 43200
refresh_pattern -i \.snd$ 14400 80% 43200
refresh_pattern -i \.mid$ 14400 80% 43200
refresh_pattern -i \.mp2$ 14400 80% 43200
refresh_pattern -i \.mp3$ 14400 80% 43200

# Archives
refresh_pattern -i \.sit$ 14400 80% 43200
refresh_pattern -i \.zip$ 14400 80% 43200
refresh_pattern -i \.hqx$ 14400 80% 43200
refresh_pattern -i \.exe$ 14400 80% 43200
refresh_pattern -i \.arj$ 14400 80% 43200
refresh_pattern -i \.lzh$ 14400 80% 43200
refresh_pattern -i \.lha$ 14400 80% 43200
refresh_pattern -i \.cab$ 14400 80% 43200
refresh_pattern -i \.rar$ 14400 80% 43200
refresh_pattern -i \.tar$ 14400 80% 43200
refresh_pattern -i \.gz$ 14400 80% 43200
refresh_pattern -i \.z$ 14400 80% 43200
refresh_pattern -i \.a[0-9][0-9]$ 14400 80% 43200
refresh_pattern -i \.r[0-9][0-9]$ 14400 80% 43200

# Data files
refresh_pattern -i \.txt$ 14400 80% 43200
refresh_pattern -i \.pdf$ 14400 80% 43200
refresh_pattern -i \.doc$ 14400 80% 43200
refresh_pattern -i \.rtf$ 14400 80% 43200
refresh_pattern -i \.tex$ 14400 80% 43200
refresh_pattern -i \.latex$ 14400 80% 43200

# Java-type objects
refresh_pattern -i \.class$ 14400 80% 43200
refresh_pattern -i \.js$ 14400 80% 43200
refresh_pattern -i \.class$ 14400 80% 43200

# Web-type objects
refresh_pattern -i \.css$ 10 20% 4320
refresh_pattern -i \.html?$ 10 20% 4320
refresh_pattern \/$ 10 20% 4320


# Para evitar problemas con scripts .do
refresh_pattern -i \.do$ 0 0% 1440

# Default
refresh_pattern ^ftp:           1440    20%     10080
refresh_pattern ^gopher:        1440    0%      1440
refresh_pattern .               0       20%     4320

Finalmente:
Reiniciamos el servicio squid:

sudo /etc/init.d/squid restart

Aquí el cliente (192.168.0.x) podría egresar a internet por medio del proxy configurado desde el navegador.
Reglas de iptables

sudo iptables -t nat -A POSTROUTING -o eth0 -j SNAT  --to 192.168.1.2
sudo iptables  -t nat -A PREROUTING -i eth1 -p tcp --dport 80 -j REDIRECT --to-port  3128
#permitir conexión entre las interfaces de red
echo 1 > /proc/sys/net/ipv4/ip_forward

Las anteriores lineas, se guardan en un archivo “proxy_rules.sh” en “/etc/init.d/” luego le damos permisos de ejecución
Luego editamos el archivo “/etc/init.d/rc.local” y le agregamos al inicio

cd  /etc/init.d
./proxy_rules.sh

Con esto hacemos que desde el inicio squid funcione de manera transparente.
Reconfiguramos el servicio squid:

sudo squid -k reconfigure

Con esto el cliente (192.168.0.x) puede navegar por internet, sin necesidad de configurar el proxy en su navegador, es decir en modo transparente.