Proxy transparente con Squid

+ DHCP en Ubuntu 13.04 32

bits
Publicado el por Javier Carrasco

Bueno, este mes de julio he dispuesto de más tiempo

para poder instalar y configurar en una de las aulas de informática el
ordenador del profesor como PROXY TRANSPARENTE y
servidor DHCP en Ubuntu 13.04 32 bits.
Para este caso dispongo de un servidor con dos tarjetas de red, una
de ellas será la que esté conectada al router que nos da acceso a
Internet (eth0) y la otra estará de cara al aula, la red interna (eth1).
En primer lugar debemos configurar nuestras interfaces de red, la
primera, eth0 se configurará por DHCP desde el router, y la
segunda, eth1, tendrá una IP estática a nuestra elección, para mi
caso 192.168.0.1, como puerta de enlace la misma y DNS para
navegar.

DHCP
Una vez configuradas las tarjetas de red, empezamos con el DHCP.
Para instalar ejecutamos desde una consola el siguiente comando.
$ sudo apt-get install isc-dhcp-server

En algunos casos puede ser que funcione dhcp3-server (obsoleto) en

vez de isc-dhcp-server.
Seguidamente debemos especificar la interfaz por la que serviremos
las direcciones IP a nuestros clientes, recordar, la interfaz interna.
Editamos el fichero /etc/default/isc-dhcp-server con nuestro
editor favorito y buscamos la opción INTERFACES para indicar cual
será la nuestra.
$ sudo gedit /etc/default/isc-dhcp-server

Dejándolo como se muestra a continuación.

# Defaults for isc-dhcp-server initscript
# sourced by /etc/init.d/isc-dhcp-server
# installed at /etc/default/isc-dhcp-server by the
maintainer scripts
#
# This is a POSIX shell fragment
#
# Path to dhcpd's config file (default:
/etc/dhcp/dhcpd.conf).
#DHCPD_CONF=/etc/dhcp/dhcpd.conf
# Path to dhcpd's PID file (default: /var/run/dhcpd.pid).
#DHCPD_PID=/var/run/dhcpd.pid
# Additional options to start dhcpd with.
# Don't use options -cf or -pf here; use DHCPD_CONF/
DHCPD_PID instead
#OPTIONS=""
# On what interfaces should the DHCP server (dhcpd) serve
DHCP requests?
# Separate multiple interfaces with spaces, e.g.
"eth0 eth1".
INTERFACES="eth1"

Ahora debemos configurar los parámetros del servicio DHCP, para eso
vamos a /etc/dhcp y antes de nada hacemos
un backup de dhcpd.conf.
$ sudo cp dhcpd.conf dhcpd.conf.original

Y editamos el fichero.
$ sudo gedit dhcpd.conf

Lo podemos borrar por completo y añadir únicamente nuestra

configuración, aquí dejo la que he utilizado yo para el aula.
option domain-name "server-inf01.public";
option domain-name-servers ns1.server-inf01.public,
ns2.server-inf01.public;
default-lease-time 600;
max-lease-time 7200;
# AulaInformatica
subnet 192.168.0.0 netmask 255.255.255.0 {
range 192.168.0.10 192.168.0.40;
option domain-name-servers tu_DNS1, tu_DNS2;
option domain-name "inf01.server.public";
option routers 192.168.0.1;
option broadcast-address 192.168.0.255;
default-lease-time 600;
max-lease-time 7200;
}

Guardamos y ya podemos reiniciar el servicio y comprobar.

$ sudo service isc-dhcp-server restart

En ocasiones, puede ser que necesitemos hacer reservas de

direcciones IP, asignar la misma IP siempre al mismo equipo. En el
mismo fichero de configuración, /etc/squid/dhcpd.conf, podemos
añadir las siguientes líneas.
#Reservas
host inf01-13 {
hardware ethernet 00:1d:60:96:53:85;
fixed-address 192.168.0.13;
option routers 192.168.0.1;
option domain-name "inf01.server.public";
}

Deberemos tener este conjunto de líneas por cada una de las reservas
que queramos tener.
Ya tenemos el segundo paso terminado.

PROXY TRANSPARENTE SQUID

En primer lugar debemos instalar Squid en nuestra máquina, desde un
terminal ejecutamos el siguiente comando.
$ sudo apt-get install squid3

El siguiente paso será configurar nuestro Squid, editamos el

fichero squid.conf que encontraremos en /etc/squid3.
$ sudo gedit /etc/squid3/squid.conf

Deberemos modificar las siguientes opciones.

http_port 3128

por esta otra

http_port 192.168.0.1:3128 transparent

3128 es el puerto de Squid y debemos indicar la dirección IP del

servidor, la que se encuentre en la parte interna.
Si nuestra máquina tiene suficiente memoria, le quitamos la
almohadilla a la opción cache_men, y utilizamos un valor coherente a
nuestra máquina, en mi caso la he dejado como se muestra.
cache_mem 512 MB

Buscamos la opción cache_dir y la ajustamos como en la siguiente

línea, aunque aquí los valores de caché dependerán de nuestras
preferencias y máquina.
cache_dir ufs /var/spool/squid3 2048 16 256

Y activamos las siguientes opciones, para asegurar que ningún

usuario pueda acceder a los recursos gestionados por Squid.
cache_effective_user proxy
cache_effective_group proxy
Descomentamos la opción half_closed_clients y la dejamos
en off, esto permitirá a Squid cerrar las peticiones de los clientes que
se queden a medias cuando cierran la conexión TCP.
half_closed_clients off

Ahora limitamos el tamaño máximo de los objetos que se guardarán

en memoria, esto puede ahorrarnos problemas con el tamaño de la
caché. Descomentamos la siguiente línea y la dejamos en 1024 KB.
maximum_object_size 1024 KB

También vamos a indicar cuando debe Squid vaciar la caché, esto nos
permitirá un mejor mantenimiento. Descomentamos las siguientes
líneas.
cache_swap_low 90
cache_swap_high 95

En mi caso dejo los valores que nos dan por defecto. Como última
modificación en las opciones de configuración de Squid, buscamos la
opción memory_pools, la descomentamos y la ponemos en off.
memory_pools off

Esta opción, hará que Squid libere la memoria RAM que no esté
utilizando.
Por último, tras la siguiente línea,
#
# INSERT YOUR OWN RULE(S) HERE TO ALLOW ACCESS FROM YOUR
CLIENTS
#

Añadiremos la regla para permitir el acceso a Internet de nuestra red

interna.
acl mi_red src 192.168.0.0/24
http_access allow mi_red

Y con esto ya podemos reiniciar Squid.

$ sudo service squid3 restart

IPTABLES
Ya sólo nos faltan las IPTABLES, estas son muy duras de entender y no
es que las domine, pero podemos encontrar
varios scripts por internet que hacen lo que necesitamos.
Yo me he quedado con el siguiente que se adapta bastante a lo que
necesito.
#!/bin/sh
# IP del servidor SQUID
SQUID_SERVER="192.168.0.1"
# Interface conectada a Internet
INTERNET="eth0"
# Interface interna
LAN_IN="eth1"
# Puerto Squid
SQUID_PORT="3128"
# Limpia las reglas anteriores
iptables -F
iptables -X
iptables -t nat -F
iptables -t nat -X
iptables -t mangle -F
iptables -t mangle -X
# Carga los modulos IPTABLES para NAT e IP con soporte
conntrack
modprobe ip_conntrack
modprobe ip_conntrack_ftp
echo 1 > /proc/sys/net/ipv4/ip_forward
# Politica de filtro por defecto
iptables -P INPUT DROP
iptables -P OUTPUT ACCEPT
# Acceso ilimitado a loop back
iptables -A INPUT -i lo -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
# Permite UDP, DNS y FTP pasivo
iptables -A INPUT -i $INTERNET -m state --state
ESTABLISHED,RELATED -j ACCEPT
# Establece el servidor como router para la red
iptables --table nat --append POSTROUTING --out-interface
$INTERNET -j MASQUERADE
iptables --append FORWARD --in-interface $LAN_IN -j ACCEPT
# acceso ilimiato a la LAN
iptables -A INPUT -i $LAN_IN -j ACCEPT
iptables -A OUTPUT -o $LAN_IN -j ACCEPT
# Redirige las peticiones de la red interna hacia el proxy
iptables -t nat -A PREROUTING -i $LAN_IN -p tcp --dport 80
-j DNAT --to $SQUID_SERVER:$SQUID_PORT
# Redirige la entrada al proxy
iptables -t nat -A PREROUTING -i $INTERNET -p tcp --dport
80 -j REDIRECT --to-port $SQUID_PORT
# Registrar todo
iptables -A INPUT -j LOG
iptables -A INPUT -j DROP

Podéis encontrar el original aquí.

El inconveniente está en que las IPTABLES debes ejecutarlas cada vez
que arranquemos la máquina, por eso crearemos un script y haremos
que se ejecute siempre al iniciar el equipo.
Copiamos el script en /etc/init.d/.
$ sudo cp iptables_proxy.sh /etc/init.d

Cambiamos el propietario y los permisos del script.

$ sudo chown root:root iptables_proxy.sh
$ sudo chmod 700 iptables_proxy.sh

A continuación editamos el fichero /etc/init.d/rc.local.

$ sudo gedit /etc/init.d/rc.local

Y añadimos las siguientes líneas bajo ### END INIT INFO.

### END INIT INFO
cd /etc/init.d
./iptables_proxy.sh

Ya podremos reiniciar nuestra máquina y comprobar que se ejecuta y

realiza su función correctamente, espero os sirva de ayuda.
- See more at: http://www.javiercarrasco.es/2013/08/01/proxy-transparente-con-squid-dhcp-en-
ubuntu-13-04-32-bits/#sthash.XRfC93sk.dpuf

Mi programa de instalación:

i) Sistema: Sistema CPU dual Xeon HP con 8 GB de RAM (suficiente para squid).

ii) Eth0: IP: 192.168.1.1

iii) Eth1: IP: 192.168.2.1 ( red 192.168.2.0/24 (aproximadamente 150 sistemas Windows))

iv) Sistema operativo Red Hat Enterprise Linux (Siguiendo la instrucción debería funcionar con
Debian y todas las otras distribuciones Linux)

Eth0 conectado a internet y eth1 conectado a lan es decir, actúan como sistema local router.

Configuración del servidor

•Paso # 1: configuración de Squid para que actúe como un proxy transparente

•Paso # 2: configuración Iptables

•a) Configurar Sistema como enrutador

•b) Remitir todas las peticiones HTTP a 3128 (DNAT)

•Paso # 3: ejecutar secuencias de comandos y se inicia el servicio de squid

En primer lugar, el servidor Squid instalado (squid uso up2date) y configurar agregando siguientes
directivas para presentar:

# vi /etc/squid/squid.conf

Modificar o añadir siguientes directivas de squid:

httpd_accel_host virtual

httpd_accel_port 80

httpd_accel_with_proxy on

httpd_accel_uses_host_header on

acl lan src 192.168.1.1 192.168.2.0/24

http_access allow localhost

http_access allow lan

Donde:

•httpd_accel_host virtuales: Squid como un acelerador de httpd

•httpd_accel_port 80: 80 es el puerto que desea enrutar

•httpd_accel_with_proxy on: Usar Squid tanto como un acelerador de httpd local y como un proxy.

•httpd_accel_uses_host_header on: Cabecera está encendido, que es el nombre de host de la URL.

•acl lan src 192.168.1.1 192.168.2.0/24: lista de control de acceso, sólo se permiten equipos de la
LAN para utilizar el squid

•http_access allow localhost: acceso Squid para LAN y localhost ACL sólamente
 •http_access allow lan: - ídem -

Aquí está la lista completa de squid.conf para su referencia (grep eliminará todos los comentarios y
sed eliminará todas las líneas vacías)

# grep -v "^#" /etc/squid/squid.conf | sed -e '/^$/d'

O intente con sed:

# cat /etc/squid/squid.conf | sed '/ *#/d; /^ *$/d'

Salida:

hierarchy_stoplist cgi-bin ?

acl QUERY urlpath_regex cgi-bin \?

no_cache deny QUERY

hosts_file /etc/hosts

refresh_pattern ^ftp: 1440 20% 10080

refresh_pattern ^gopher: 1440 0% 1440

refresh_pattern . 0 20% 4320

acl all src 0.0.0.0/0.0.0.0

acl manager proto cache_object

acl localhost src 127.0.0.1/255.255.255.255

acl to_localhost dst 127.0.0.0/8

acl purge method PURGE

acl CONNECT method CONNECT

cache_mem 1024 MB

http_access allow manager localhost

http_access deny manager

http_access allow purge localhost

http_access deny purge

http_access deny !Safe_ports

 http_access deny CONNECT !SSL_ports

acl lan src 192.168.1.1 192.168.2.0/24

http_access allow localhost

http_access allow lan

http_access deny all

http_reply_access allow all

icp_access allow all

visible_hostname myclient.hostname.com

httpd_accel_host virtual

httpd_accel_port 80

httpd_accel_with_proxy on

httpd_accel_uses_host_header on

coredump_dir /var/spool/squid

Configuración de iptables

A continuación, añadir las siguentes reglas para desviar todas las peticiones http (próximos al
puerto 80) al puerto del servidor Squid 3128:

iptables -t nat -A PREROUTING -i eth1 -p tcp --dport 80 -j DNAT --to

192.168.1.1:3128

iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j REDIRECT --to-port

3128

Aquí está el script completo. Primero configurar el sistema Linux como router y reenvía todas las
peticiones HTTP con el puerto 3128

#!/bin/sh

# squid server IP

SQUID_SERVER="192.168.1.1"

# Interface connected to Internet

INTERNET="eth0"
# Interface connected to LAN

LAN_IN="eth1"

# Squid port

SQUID_PORT="3128"

# DO NOT MODIFY BELOW

# Clean old firewall

iptables -F

iptables -X

iptables -t nat -F

iptables -t nat -X

iptables -t mangle -F

iptables -t mangle -X

# Load IPTABLES modules for NAT and IP conntrack support

modprobe ip_conntrack

modprobe ip_conntrack_ftp

# For win xp ftp client

#modprobe ip_nat_ftp

echo 1 > /proc/sys/net/ipv4/ip_forward

# Setting default filter policy

iptables -P INPUT DROP

iptables -P OUTPUT ACCEPT

# Unlimited access to loop back

iptables -A INPUT -i lo -j ACCEPT

iptables -A OUTPUT -o lo -j ACCEPT

# Allow UDP, DNS and Passive FTP

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

 ACCEPT

# set this system as a router for Rest of LAN

iptables --table nat --append POSTROUTING --out-interface $INTERNET -j

MASQUERADE

iptables --append FORWARD --in-interface $LAN_IN -j ACCEPT

# unlimited access to LAN

iptables -A INPUT -i $LAN_IN -j ACCEPT

iptables -A OUTPUT -o $LAN_IN -j ACCEPT

# DNAT port 80 request comming from LAN systems to squid 3128

($SQUID_PORT) aka transparent proxy

iptables -t nat -A PREROUTING -i $LAN_IN -p tcp --dport 80 -j DNAT --to

$SQUID_SERVER:$SQUID_PORT

# if it is same system

iptables -t nat -A PREROUTING -i $INTERNET -p tcp --dport 80 -j REDIRECT --to-

port $SQUID_PORT

# DROP everything and Log it

iptables -A INPUT -j LOG

iptables -A INPUT -j DROP

Guardar script de shell. Ejecutar secuencia de comandos para que el sistema actúe como un router
y redirigir los puertos:

# chmod +x /etc/fw.proxy

# /etc/fw.proxy

# service iptables save

# chkconfig iptables on

Iniciar o reiniciar el squid:

# /etc/init.d/squid restart

# chkconfig squid on

Configuración de la computadora de escritorio / cliente

Apunte todos los clientes de escritorio a su dirección IP eth1 (192.168.2.1) como Router / Gateway
(utilice DHCP para distribuir esta información). Usted no tendrá que configurar los navegadores
individuales para trabajar con el servidor proxy.

¿Cómo puedo probar si mi proxy squid está funcionando correctamente?

Ver archivo de registro de acceso /var/log/squid/access.log:

# tail -f /var/log/squid/access.log

El comando de arriba supervisará todas las peticiones entrantes y los ingresa al archivo de
registro /var/squid/access_log. Ahora bien, si alguien accede a un sitio web a través del
navegador, squid registrarán información.

Problemas y soluciones

(A) Cliente FTP de Windows

Todo cliente de Escritorio que solicite una sesión FTP terminará con un error: Comando PORT
ilegal.

Esto es por que no había cargado el módulo del kernel ip_nat_ftp. Sólo tienes que escribir el
siguiente comando y pulsar Enter y ¡voilá!

# modprobe ip_nat_ftp

Tenga en cuenta que comando modprobe ya se añade a un script de shell (arriba).

(B) Redirección del puerto 443:

Tuve a bloquear todas las solicitudes de conexión del router a excepción de nuestro servidor proxy
(192.168.1.1). Así que todos los puertos incluyendo el 443 (HTTPS / SSL). No se puede redirigir el
puerto 443, extraje a partir de la lista de correo Debian: "Respuesta larga: SSL está
específicamente diseñado para impedir el ataque "man-in-the-middle", y consecuente el uso de
squid, de tal manera que sería lo mismo que un ataque "hombre en el medio". Puede que se puede
llegar a alcanzar con éxito esto, pero no sin romper el cifrado y la certificación de que es el punto
detrás de SSL ".

Por lo tanto, yo había reabrir rápidamente el puerto 443 del (firewall router) para todos mis
equipos de la LAN y problema estaba resuelto.

(C) la autenticación Squid Proxy en un modo transparente

No se puede interceptar la autenticación de squid con un proxy transparente.

Squid en modo transparente
Posted on 11 marzo 2010 by Samuel — 17 comentarios
Hola a todos, fui un pelín mentiroso cuando dije que la práctica de Dansguardian iba a ser la
última del curso. Esta sí que va a ser la última. Hoy vamos a ver cómo configurar Squid en
modo transparente.
¿Modo transparente?
Normalmente, los proxys navegan a través del puerto 3128, y hay que configurar los clientes
para que puedan acceder a internet a través del proxy. En cambio, en un proxy transparente,
no es necesario configurar ningún cliente, todo se configura una única vez en la máquina en
la que está instalado el proxy y los clientes no saben que navegan a través de este. Se
redirige el tráfico del puerto 80 al 3128.
Empezando
Supongamos que tenemos una red local con tres equipos que deseamos conectar a internet,
pero antes queremos que pasen por un proxy, ya sea para filtrar contenidos o para almacenar
información en la caché. Para ello necesitamos una máquina con dos interfaces de red, una
para nuestra red local y otra que nos conectará a Internet. Sabiendo esto, vamos a comenzar.
Configurando las interfaces de red
En primer lugar vamos a mostrar información referente a nuestras interfaces de red. En una
consola tecleamos:

ifconfig

Como vemos en la imagen, poseemos dos interfaces de red, etc0 y eht1. eth0 será la interfaz
que nos conectará con nuestra red local y eth1 nos conectará con el ruter que a su vez no
conectará a Internet. Necesitamos configurar eth0 de forma estática, para ello abrimos un
terminal y tecleamos:

sudo gedit /etc/network/interfaces

Y dejamos el archivo de la siguiente forma:

auto lo
iface lo inet loopback

auto eth1
 iface eth1 inet dhcp

auto eth0
iface eth0 inet static
address 10.0.0.1
netmask 255.0.0.0
gateway 10.0.0.1

Bien, ya tenemos configurada eth1 como dinámica y eth0 como estática. Ahora reiniciamos el
servicio de red, desde la terminal:

sudo /etc/init.d/networking restart

Instalando el servidor DHCP

Vamos ahora a instalar el servidor DHCP en nuestra máquina, desde un terminal escribimos:

sudo aptitude install dhcp3-server

Ya tenemos instalado nuestro servidor DHCP, ahora vamos a configurarlo, así que tenemos
tecleamos lo siguiente en una consola:

sudo gedit /etc/dhcp3/dhcpd.conf

Una vez con el archivo abirto, borramos el contenido y lo dejamos aproximadamente así:

option domain-name "midominio.com";

option domain-name-servers 10.0.0.1;
option subnet-mask 255.0.0.0;
option netbios-name-servers 10.0.0.1;
option routers 10.0.0.1;
default-lease-time 600;
max-lease-time 7200;
subnet 10.0.0.0 netmask 255.0.0.0 {
range 10.0.0.2 10.0.0.100;
option domain-name-servers 10.0.0.1;
option subnet-mask 255.0.0.0;
option netbios-name-servers 10.0.0.1;
option routers 10.0.0.1;
host PC1 {
option host-name "PC1";
hardware ethernet 00:1E:24:6F:2B:5C;
fixed-address 10.0.0.11;
}
host PC2 {
option host-name "PC2";
hardware ethernet 00:1E:24:1C:53:DF;
fixed-address 10.0.0.12;
}
host PC3 {
option host-name "PC3";
hardware ethernet 00:1E:24:CC:1A:E2;
fixed-address 10.0.0.13;
}
}
 Explicación del contenido: En el fichero anterior, debemos incluir
un nombre de dominio si pertenecemos a uno, la dirección de la
máquina donde está el servidor con su máscara y diversas opciones más
como NetBios y los tiempos de asignación de direcciones.
En subnet, vamos a configurar cómo se asignarán las direcciones para
esa red (que está controlada por eth0), aparte de indicarle la misma
información que antes, le debemos de especificar el rango con el que
queremos que trabaje. En mi caso he especificado del 1 al 100.
En host, definimos la dirección que se asignará a cada máquina de
nuestra red, se especifica el nombre real, su dirección MAC y la
dirección IP que se asociará a dicha MAC. Así hasta que completemos
todos los equipos de los que dispondrá la red.
Ahora reiniciamos el servicio de DHCP con el siguiente comando:

sudo /etc/init.d/dhcp3-server restart

Creando las iptables

Vamos ahora a crear las llamadas iptables. Las iptables son un complemento
del frameworkNetfilter, usadas para el filtro de tráfico en una red. Nosotros vamos a usarlas
para redirigir el tráfico del puerto 80 al 3128, entre otras cosas.
Para crear nuestras iptables, debemos crear un archivo con ellas, para crear el archivo
tecleamos el siguiente comando en un terminal:
 sudo gedit /etc/init.d/proxy-rules.sh

Al nuestro archivo le añadimos lo siguiente:

echo "Aplicando las reglas para el direccionamiento, espere..."

iptables -t nat -F
iptables -t nat -X
iptables -t nat -Z
iptables -F
iptables -X
iptables -Z

echo 1 > /proc/sys/net/ipv4/ip_forward

iptables -t nat -A PREROUTING -s 10.0.0.0/8 -p tcp --dport 80 -j REDIRECT

--to-port 3128
iptables -t nat -A POSTROUTING -o eth1 -s 10.0.0.0/8 -j MASQUERADE

Nota: Yo he elegido el nombre de proxy-rules para el archivo, podéis

elegir el que queráis, pero obviamente que sea de carácter descriptivo.
Explicación de las iptables: Las primeras
reglas iptables eliminan cualquieriptable que se encuentre en
ejecución en ese momento. La primera cadena deiptables, direcciona el
tráfico de nuestra red desde el puerto 80 al puerto 3128. La segunda
cadena de iptables, se encarga de enmascarar nuestra red para que
pueda salir a Internet mediante la interfaz eth1.
Descargando, compilando y configurando Squid
Vamos ahora a descargar Squid desde su web oficial para después compilarlo. Las versiones
disponibles las podemos ver en http://www.squid-cache.org/Versions/, sería ideal trabajar con
la última versión estable de Squid, en este caso, la última versión estable es la 3.0. Antes de
descargar Squid, nos vamos al directorio /usr/local/src, para ello tecleamos en la consola:

cd /usr/local/src
Una vez allí, volvemos a teclear en el terminal lo siguiente:
 sudo wget http://www.squid-cache.org/Versions/v3/3.0/squid-3.0.STABLE24.tar.gz

Eso descargará la última versión de Squid al directorio en el que nos encontramos. Cuando ya
tenemos descargado el paquete de Squid, tenemos que descomprimirlo, por lo que tecleamos
en un terminal:

sudo tar xvzf squid-3.0.STABLE24.tar.gz

Muy bien, ya tenemos los archivos de Squid listos para compilar, para esto necesitaremos
tener instalado un compilador de C/C++ en nuestra máquina, por lo que en un terminal
tecleamos:

sudo aptitude install build-essential

Una vez instalado el compilador, y estando dentro de /usr/local/src, tecleamos en un terminal:

cd squid-3.0.STABLE24
Bien, ya estamos dentro de dicho directorio, ahora de nuevo en un terminal tecleamos lo
siqguiente:

sudo ./configure --prefix=/usr/local/squid --enable-linux-netfilter

--enable-follow-x-forwarded-for --enable-x-accelerator-vary
Cuando el proceso acabe (es posible que esté unos minutos) tecleamos esto ahora:

sudo make
Este proceso también tardará unos minutos posiblemente. Al finalizar este proceso, escibimos
lo siguiente en la consola:

sudo make install

Ya tenemos Squid instalado en /usr/local/squid. Vamos ahora a crear el usuario y grupo squid.
En un terminal tecleamos:

sudo useradd squid

Y después:

sudo groupadd squid

Nota: Es posible que al añadir el grupo nos diga que ya existe un grupo
llamado squid, no pasa nada, nos saltamos este paso y sin problemas.
Ahora vamos a hacer al usuario squid dueño de los directorios de Squid. Para ello nos vamos
a un terminal y tecleamos:
 cd /usr/local/squid
Una vez estamos en este directorio, tecleamos lo siguiente:

sudo chown -R squid *

Y depués:

chgrp -R squid *
Con esto, el usuario squid ya es dueño de los directorios que maneja Squid. Vamos ahora a
configurar nuestro Squid para permitir la conexión a nuestra red, nos vamos a un terminal y
tecleamos:

sudo gedit /usr/local/squid/etc/squid.conf

Una vez tenemos el archivo, con Ctrl + F, buscamos la línea http_port, la borramos y la
añadimos de esta forma:

http_port 10.0.0.1:3128 transparent

Ahora buscamos la línea cache_dir, y la dejamos de la siguiente manera:

cache_dir ufs /usr/local/squid/var/cache 1024 16 256

Volvemos a realizar otra búsqueda, esta vez de cache_effective_user, aquí añadimos dos
líneas:

cache_effective_user squid
cache_effective_group squid

Ahora vamos a añadir una ACL, nos vamos a la zona de las ACL, que está por la
línea 600 más o menos, y allí añadimos:

acl nuestra_red src 10.0.0.0/24

Vamos ahora a añadir una regla http_access, nos vamos aproximadamente a la línea 645, y
añadimos:

http_access allow nuestra_red

Ya queda poco por hacer, ahora vamos a crear los directorios para la caché de Squid, así que
desde un terminal tecleamos:

sudo /usr/local/squid/sbin/squid -z

Ahora toca configurar rc.local para que arranque Squid y proxy-rules.sh al iniciar Ubuntu,
esto es fácil, desde el terminal tecleamos:

sudo gedit /etc/rc.local

Una vez con el fichero abierto, añadimos lo siguiente:

sh /etc/init.d/proxy-rules.sh
cd /usr/local/squid/sbin/
./squid

Magnífico, ya sólo queda reiniciar nuestra máquina y comprobar que hay dos procesos
de Squidejecutándose en nuestro equipo. Una vez con la máquina reiniciada, volvemos a abrir
un terminal y tecleamos:

sudo ps ax | grep squid

Si nos apareden los dos procesos de Squid significa que todo está correcto, ya tenemos
nuestroproxy caché transparente instalado y configurado.