Depois de inúmeras tentativas, buscando por documentações na Internet usando o Google, consegui através de pedaços de documentações e testes realizados em minha casa e em um dos provedores para o qual presto serviço realizar o que essa documentação se propõe. Mostrar como podemos configurar um CentOS 5.5 como bridge e ao mesmo tempo servir de Proxy totalmente transparente através do TProxy. Com esse recurso a colocação do Proxy não afeta a configuração da sua topologia de rede e ao mesmo tempo permite que os acessos dos seus usuários sejam identificados do lado da Internet porque não é mais o IP do Proxy que faz a consulta e sim o IP do usuário. Também acaba com problemas como RapidShare que não permitem downloads vindos do mesmo IP sendo contas Free, pois cada cliente sairá com o seu próprio IP. Obs.: Se depois do Proxy houver algum sistema fazendo NAT N:1 vulgo Masquerade, de nada adiantará o TProxy. Este documento visa ajudar mas não serei responsável por quaisquer danos que possam vir à acontecer.

Para montar nosso servidor precisaremos ter o mínimo exigido para que este funcione. Pré-requisitos abaixo:

- Kernel 2.6.30 ou 2.6.31, não usem o 2.6.32 porque esse está com problemas no TProxy e por isso não é aconselhado seu uso até que seja resolvido. Existem versões mais novas do kernel, mas ainda não fiz testes com elas.
- IPTables 1.4.3
- Squid 3.1.4
- libcap2-devel

Como o CentOS 5.5 não possui esses requisitos, seremos obrigados à baixá-los, compilarmos e instalarmos estes. Uma outra coisa, esse tutorial não ensinará à instalar um CentOS 5.5, pois já existem diversas documentações por aí. O que precisaremos é de um sistema preparado para compilar programas. Precisará pelo menos disso:

# yum groupinstall 'Development Tools'
# yum groupinstall 'Development Libraries'

Uma boa prática é usar sempre um sistema atualizado com o comando:

# yum update

Agora veremos como está nossa rede de testes, nossa topologia antes do Servidor Proxy em Bridge:

 

Nessa rede acima cada cliente sai com seu IP público e se colocássemos um Proxy Transparente mesmo que em Bridge, teríamos o problema do IP que sairia para navegação, que seria o do Proxy. Meu objetivo aqui é mostrar como configurar um Proxy 100% transparente e em bridge usando o TProxy no kernel, iptables, ebtables e Squid. Agora vejamos como ficará nossa nova topologia. Reparem que o gateway continua sendo o mesmo 186.193.x.1, porque o Proxy, para a rede, não existirá:

Então agora vamos por a mão na massa e fazer isso funcionar de vez. Rsrsrs
Vamos baixar nossos pré-requisitos:

# cd /usr/src
# wget -c http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.30.10.tar.bz2
# wget -c http://ftp.iitm.ac.in/pub/linux/libs/security/linux-privs/libcap2/libcap-2.19.tar.gz
# wget -c http://www.netfilter.org/projects/iptables/files/iptables-1.4.3.2.tar.bz2
# wget -c http://www.squid-cache.org/Versions/v3/3.1/squid-3.1.1.tar.gz

Vamos então descompactar nosso kernel, configurar ele com os módulos necessários, compilá-lo e instalá-lo:

# tar –xvjpf linux-2.6.30.10.tar.bz2
# ln -sf linux-2.6.30.10 linux
# cd /usr/src/linux

Agora vamos copiar uma config para o nosso kernel e depois marcar o que vamos precisar:

# cp /boot/config-2.6.18-164.15.1.el5 .config
# make menuconfig

Agora em:

Networking support
    Networking options
        Network packet filtering framework (Netfilter)
            Core Netfilter Configuration
                <M> Netfilter connection tracking support
                <M> Transparent proxying support (EXPERIMENTAL)
                        .
                        .
                       <M>   "TPROXY" target support (EXPERIMENTAL) (NEW)
                        .
                        .
                        .
                       <M>   "socket" match support (EXPERIMENTAL)

Após marcarmos esses suportes, saímos da configuração do kernel e fazemos os procedimentos para compilar e instalar o novo kernel. É bem difícil essa parte. Rsrsrsrs

# make
# make modules_install
# make install

Agora vamos ativá-lo no boot. Editem o arquivo /boot/grub/menu.lst com o editor preferido de vocês e alterem a variável “default” para: default=0
Isso porque nosso novo kernel, se repararem, estará no topo da lista dos kernels existentes e “0” diz para carregar o primeiro da lista.
Vamos agora re-iniciar com o nosso novo kernel. Obs: não fiz optimizações no kernel porque não era esse o objetivo deste tutorial, ou seja, apenas habilitei o que eu iria precisar.

Antes de fazermos o reboot vamos configurar nossa bridge:

# yum install bridge-utils

Vamos criar o arquivo /etc/sysconfig/network-scripts/ifcfg-br0 com o seguinte conteúdo:

DEVICE=br0
TYPE=Bridge
BOOTPROTO=static
IPADDR=186.193.x.3
NETMASK=255.255.255.224
ONBOOT=yes
DELAY=0

No exemplo acima usei 186.193.x.3 para o IP do Proxy, nem preciso dizer que o ‘x’ é para mascarar o IP real que tenho. Rsrsrs Vocês precisam substituir pelo IP que vocês forem realmente usar nos testes.

Agora vamos editar as outras interfaces de rede que já devem existir no sistema de vocês:

/etc/sysconfig/network-scripts/ifcfg-eth0

# Silicon Integrated Systems [SiS] SiS900 PCI Fast Ethernet
DEVICE=eth0
BOOTPROTO=static
HWADDR=00:01:6C:B7:1F:50
ONBOOT=yes
BRIDGE=br0

/etc/sysconfig/network-scripts/ifcfg-eth1

# Intel Corporation 82543GC Gigabit Ethernet Controller (Copper)
DEVICE=eth1
BOOTPROTO=static
HWADDR=00:03:47:72:97:22
ONBOOT=yes
BRIDGE=br0

Mantenham os Mac-Address que já vem nas configurações de vocês porque o sistema já detecta eles e só modifiquem o restante. Pronto a bridge já está pronta e agora podemos fazer o reboot e continuarmos nossa maratona. :)

# reboot

Após o boot chequem se o novo kernel foi mesmo carregado com o comando abaixo:

# uname –a
Linux proxy.localdomain 2.6.30.10 #1 SMP Tue Apr 20 03:43:59 BRT 2010 i686 athlon i386 GNU/Linux

Agora vamos compilar e instalar o iptables que baixamos:

# cd /usr/src/
# tar –xvjpf iptables-1.4.3.2.tar.bz2
# cd iptables-1.4.3.2/
# ./configure --prefix=/

Como estamos usando um sistema 64 bits (x86_64) usaremos os seguintes comandos:

# make BINDIR=/sbin LIBDIR=/lib64 KERNEL_DIR=/usr/src/linux
# make BINDIR=/sbin LIBDIR=/lib64 KERNEL_DIR=/usr/src/linux install

Para confirmarem que estão usando o iptables que acabamos de instalar:

# iptables –v
iptables v1.4.3.2: no command specified
Try `iptables -h' or 'iptables --help' for more information.

Perfeito! Agora já temos Kernel mais recente já com o suporte ao TProxy habilitado e o iptables novo compilado e instalado. Não precisamos aplicar patches no iptables porque esta versão que instalamos já vem com suporte ao TProxy.

Agora partiremos para o squid mas antes, este precisará da libcap2 que baixamos. IMPORTANTE!!! Sem a libcap2 ou uma versão 2.09 ou superior, o TProxy não irá funcionar porque o squid não compilará com o devido suporte. Isto realmente é muito mas muito IMPORTANTE!

# cd /usr/src
# tar –xvzpf libcap-2.19.tar.gz
# cd libcap-2.19/
# make && make install

Simples assim mesmo. Agora podemos partir para o squid:

# cd /usr/src
# tar –xvzpf squid-3.1.1.tar.gz
# cd squid-3.1.1/
# ./configure --exec_prefix=/usr --bindir=/usr/sbin --libexecdir=/usr/lib64/squid --localstatedir=/var --datadir=/usr/share/squid --sysconfdir=/etc/squid --enable-arp-acl --enable-epoll --enable-snmp --enable-removal-policies="heap,lru" --enable-storeio="aufs,diskd,ufs" --enable-ssl --with-openssl=/usr/kerberos --enable-delay-pools --enable-linux-netfilter --with-pthreads --enable-ntlm-auth-helpers="fakeauth" --enable-external-acl-helpers="ip_user,ldap_group,unix_group,wbinfo_group" --enable-auth="basic,digest,ntlm,negotiate" --enable-negotiate-auth-helpers="squid_kerb_auth" --enable-digest-auth-helpers="password" --with-winbind-auth-challenge --enable-useragent-log --enable-referer-log --disable-dependency-tracking --enable-cachemgr-hostname=localhost --enable-underscores --enable-basic-auth-helpers="LDAP,MSNT,NCSA,PAM,SMB,YP,getpwnam,multi-domain-NTLM,SASL" --enable-cache-digests --enable-ident-lookups --with-large-files --enable-follow-x-forwarded-for --enable-wccpv2 --enable-fd-config --with-maxfd=16384 
# make
# make install

Dos parâmetros acima, no ./configure, o mais importante para que funcione é o --enable-linux-netfilter. Não entrarei em detalhes de cada parâmetro acima, pois sairia muito do escopo desse tutorial.

Vamos criar o user e group do squid:

# groupadd -g 23 squid
# useradd -u 23 -g 23 -d /var/spool/squid -s /sbin/nologin squid

Precisaremos acertar o squid.conf, vou usar o padrão para vocês terem uma idéia mas as optimizações vai de cada um. Vamos editar o /etc/squid.conf e deixá-lo como este abaixo:

cache_mem 100 MB
cache_effective_user squid
cache_effective_group squid
access_log /var/logs/squid/access.log squid
cache_store_log /var/logs/squid/store.log
cache_log /var/logs/squid/cache.log   
error_directory /usr/share/squid/errors/pt-br
maximum_object_size 40960 KB 
acl manager proto cache_object
acl localhost src 127.0.0.1/32
acl localhost src ::1/128
acl to_localhost dst 127.0.0.0/8 0.0.0.0/32
acl to_localhost dst ::1/128
 
# Se sua rede de teste for uma dessas abaixo, então descomente a correta ou as que for usar.
#acl localnet src 10.0.0.0/8     # RFC1918 possible internal network
#acl localnet src 172.16.0.0/12  # RFC1918 possible internal network
#acl localnet src 192.168.0.0/16 # RFC1918 possible internal network
 
# Abaixo vou colocar as redes de teste como nos meus desenhos do tuto, mas alterem para o teste de vocês
acl localnet src 186.194.x.0/24
acl localnet src 186.193.x.0/27
 
acl localnet src fc00::/7   # RFC 4193 local private network range
acl localnet src fe80::/10  # RFC 4291 link-local (directly plugged) machines

acl SSL_ports port 443
acl Safe_ports port 80          # http
acl Safe_ports port 21          # ftp
acl Safe_ports port 443         # https
acl Safe_ports port 70          # gopher
acl Safe_ports port 210         # wais
acl Safe_ports port 1025-65535  # unregistered ports
acl Safe_ports port 280         # http-mgmt
acl Safe_ports port 488         # gss-http
acl Safe_ports port 591         # filemaker
acl Safe_ports port 777         # multiling http
acl CONNECT method CONNECT
 
http_access allow manager localhost
http_access deny manager
 
http_access deny !Safe_ports
 
http_access deny CONNECT !SSL_ports
 
http_access allow localnet
http_access allow localhost
http_access deny all

http_port 3128
http_port 3129 tproxy
 
hierarchy_stoplist cgi-bin ?
 
cache_dir ufs /var/spool/squid 30000 64 256
 
coredump_dir /var/spool/squid  

# Add any of your own refresh_pattern entries above these.
refresh_pattern ^ftp:           1440    20%     10080
refresh_pattern ^gopher:        1440    0%      1440
refresh_pattern -i (/cgi-bin/|\?) 0     0%      0
refresh_pattern .    0    20%    4320

Reparem na configuração acima: a linha em vermelho (http_port 3129 tproxy) porque ela é muito importante!

Agora vamos criar uns diretórios com suas permissões:

# mkdir -p /var/spool/squid
# chown squid:squid /var/spool/squid
# mkdir -p /var/logs/squid
# chown squid:squid /var/logs/squid

Precisaremos inicializar o squid e nesse momento preste atenção para ver se ele mostrará alguma mensagem de erro:

# squid -z

Vamos precisar de um script para inicializar e parar o squid quando precisarmos. Então vamos criar um em /etc/init.d/ chamado squid com o conteúdo abaixo:

#!/bin/bash
# squid         This shell script takes care of starting and stopping
#               Squid Internet Object Cache
#
# chkconfig: - 90 25
# description: Squid - Internet Object Cache. Internet object caching is \
#       a way to store requested Internet objects (i.e., data available \
#       via the HTTP, FTP, and gopher protocols) on a system closer to the \
#       requesting site than to the source. Web browsers can then use the \
#       local Squid cache as a proxy HTTP server, reducing access time as \
#       well as bandwidth consumption.
# pidfile: /var/run/squid.pid
# config: /etc/squid/squid.conf

PATH=/usr/bin:/sbin:/bin:/usr/sbin
export PATH

# Source function library.
. /etc/rc.d/init.d/functions

# Source networking configuration.
. /etc/sysconfig/network

# don't raise an error if the config file is incomplete
# set defaults instead:
SQUID_OPTS=${SQUID_OPTS:-"-D"}
SQUID_PIDFILE_TIMEOUT=${SQUID_PIDFILE_TIMEOUT:-20}
SQUID_SHUTDOWN_TIMEOUT=${SQUID_SHUTDOWN_TIMEOUT:-100}

# determine the name of the squid binary
[ -f /usr/sbin/squid ] && SQUID=squid

prog="$SQUID"

# determine which one is the cache_swap directory
CACHE_SWAP=`sed -e 's/#.*//g' /etc/squid/squid.conf | \
        grep cache_dir |  awk '{ print $3 }'`
[ -z "$CACHE_SWAP" ] && CACHE_SWAP=/var/spool/squid

RETVAL=0

start() {

        #check if the squid conf file is present
        if [ ! -f /etc/squid/squid.conf ]; then
            echo "Configuration file /etc/squid/squid.conf missing" 1>&2
            exit 6
        fi

        # don't raise an error if the config file is incomplete.
        # set defaults instead:
        SQUID_OPTS=${SQUID_OPTS:-"-D"}
        SQUID_PIDFILE_TIMEOUT=${SQUID_PIDFILE_TIMEOUT:-20}
        SQUID_SHUTDOWN_TIMEOUT=${SQUID_SHUTDOWN_TIMEOUT:-100}

        if [ -z "$SQUID" ]; then
                echo "Insufficient privilege" 1>&2
                exit 4
        fi

        for adir in $CACHE_SWAP; do
        if [ ! -d $adir/00 ]; then
             echo -n "init_cache_dir $adir... "
             $SQUID -z -F -D >> /var/logs/squid/squid.out 2>&1
        fi
    done
    echo -n $"Starting $prog: "
    $SQUID $SQUID_OPTS >> /var/logs/squid/squid.out 2>&1
    RETVAL=$?
    if [ $RETVAL -eq 0 ]; then
       timeout=0;
       while : ; do
          [ ! -f /var/run/squid.pid ] || break
          if [ $timeout -ge $SQUID_PIDFILE_TIMEOUT ]; then
             RETVAL=1
             break
          fi
          sleep 1 && echo -n "."
          timeout=$((timeout+1))
       done
    fi
    [ $RETVAL -eq 0 ] && touch /var/lock/subsys/$SQUID
    [ $RETVAL -eq 0 ] && echo_success
    [ $RETVAL -ne 0 ] && echo_failure
    echo  
       return $RETVAL
}

stop() {

    # don't raise an error if the config file is incomplete.
    # set defaults instead:
    SQUID_SHUTDOWN_TIMEOUT=${SQUID_SHUTDOWN_TIMEOUT:-100}

    echo -n  $"Stopping $prog: "
    $SQUID -k check >> /var/logs/squid/squid.out 2>&1
    RETVAL=$?
    if [ $RETVAL -eq 0 ] ; then
        $SQUID -k shutdown &
        rm -f /var/lock/subsys/$SQUID
        timeout=0
        while : ; do
                [ -f /var/run/squid.pid ] || break
                if [ $timeout -ge $SQUID_SHUTDOWN_TIMEOUT ]; then
                    echo
                    return 1
                fi
                sleep 2 && echo -n "."
                timeout=$((timeout+2))
        done
        echo_success
        echo
    else
        echo_failure
        if [ ! -e /var/lock/subsys/$SQUID ]; then
                RETVAL=0
        fi
        echo
    fi
    return $RETVAL
}

reload() {
    # don't raise an error if the config file is incomplete.
    # set defaults instead:
    SQUID_OPTS=${SQUID_OPTS:-"-D"}

    $SQUID $SQUID_OPTS -k reconfigure
}

restart() {
    stop
    start
}

condrestart() {
    [ -e /var/lock/subsys/squid ] && restart || :
}

rhstatus() {
    status $SQUID && $SQUID -k check
}

probe() {
    return 0
}

case "$1" in
start)
    start
    ;;

stop)
    stop
    ;;

reload)
    reload
    ;;

restart)
    restart
    ;;

condrestart)
    condrestart
    ;;

status)
    rhstatus
    ;;

probe)
    exit 0
    ;;

*)
    echo $"Usage: $0 {start|stop|status|reload|restart|condrestart}"
    exit 2
esac

exit $?

Vamos colocar ele para iniciar no boot:

# chmod +x /etc/init.d/squid
# chkconfig --levels 235 squid on

Agora que temos nosso ambiente quase pronto vamos precisar fazer os devidos redirecionamentos e para isso vamos precisar do ebtables e ele não está nos repositórios do CentOS. O ebtables é muito importante para o funcionamento desse nosso servidor em modo Bridge. Se alguém estiver usando esse tutorial mas não querendo fazer uma bridge, então poderá pular essa parte do ebtables e suas regras. Para instalarmos o ebtables vamos adicionar o repositório do EPEL, da turma do Fedora para o CentOS/RHEL. Antes instalaremos o yum-priorities para delegarmos prioridade nesses repositórios e não bagunçarmos nosso ambiente.

# yum install yum-priorities  

Agora vamos nos repositórios em /etc/yum.repos.d/ editar o CentOS-Base.repo e deixá-lo parecido com o abaixo. Reparem a variável “priority=”:

[base]
name=CentOS-$releasever - Base
mirrorlist=http://mirrorlist.centos.org/?release=$releasever&arch=$basearch&repo=os
#baseurl=http://mirror.centos.org/centos/$releasever/os/$basearch/
gpgcheck=1
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-5
priority=1

#released updates
[updates]
name=CentOS-$releasever - Updates
mirrorlist=http://mirrorlist.centos.org/?release=$releasever&arch=$basearch&repo=updates
#baseurl=http://mirror.centos.org/centos/$releasever/updates/$basearch/
gpgcheck=1
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-5
priority=1

#packages used/produced in the build but not released
[addons]
name=CentOS-$releasever - Addons
mirrorlist=http://mirrorlist.centos.org/?release=$releasever&arch=$basearch&repo=addons
#baseurl=http://mirror.centos.org/centos/$releasever/addons/$basearch/
gpgcheck=1
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-5
priority=1
 
#additional packages that may be useful
[extras]
name=CentOS-$releasever - Extras
mirrorlist=http://mirrorlist.centos.org/?release=$releasever&arch=$basearch&repo=extras
#baseurl=http://mirror.centos.org/centos/$releasever/extras/$basearch/
gpgcheck=1
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-5
priority=1
 
#additional packages that extend functionality of existing packages
[centosplus]
name=CentOS-$releasever - Plus
mirrorlist=http://mirrorlist.centos.org/?release=$releasever&arch=$basearch&repo=centosplus
#baseurl=http://mirror.centos.org/centos/$releasever/centosplus/$basearch/
gpgcheck=1
enabled=1
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-5
priority=2
 
#contrib - packages by Centos Users
[contrib]
name=CentOS-$releasever - Contrib
mirrorlist=http://mirrorlist.centos.org/?release=$releasever&arch=$basearch&repo=contrib
#baseurl=http://mirror.centos.org/centos/$releasever/contrib/$basearch/
gpgcheck=1
enabled=1
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-5
priority=2

Agora vamos instalar o repositório EPEL para 64bits:

# rpm -Uvh http://download.fedora.redhat.com/pub/epel/5/x86_64/epel-release-5-3.noarch.rpm

Ainda nos repositórios vamos editar agora o epel.repo e deixá-lo como abaixo:

[epel]
name=Extra Packages for Enterprise Linux 5 - $basearch
#baseurl=http://download.fedoraproject.org/pub/epel/5/$basearch
mirrorlist=http://mirrors.fedoraproject.org/mirrorlist?repo=epel-5&arch=$basearch
failovermethod=priority
enabled=1
gpgcheck=1
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-EPEL
priority=12
 
[epel-debuginfo]
name=Extra Packages for Enterprise Linux 5 - $basearch - Debug
#baseurl=http://download.fedoraproject.org/pub/epel/5/$basearch/debug
mirrorlist=http://mirrors.fedoraproject.org/mirrorlist?repo=epel-debug-5&arch=$basearch
failovermethod=priority
enabled=0
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-EPEL
gpgcheck=1
priority=12
 
[epel-source]
name=Extra Packages for Enterprise Linux 5 - $basearch - Source
#baseurl=http://download.fedoraproject.org/pub/epel/5/SRPMS
mirrorlist=http://mirrors.fedoraproject.org/mirrorlist?repo=epel-source-5&arch=$basearch
failovermethod=priority
enabled=0
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-EPEL
gpgcheck=1
priority=12

Quanto maior o valor do priority, menor é a prioridade dos pacotes assim se tiverem 2 pacotes iguais, um no repositório do CentOS e outro no EPEL, o pacote que será instalado será o do CentOS e não do EPEL.

Agora podemos instalar o ebtables facilmente:

# yum install ebtables

Pronto!!! Agora temos tudo que precisamos no sistema. Só precisamos fazer mais uns acertos e uns scripts e pronto teremos nossa bridge funcionando com Squid + TProxy. Vamos modificar a variável net.ipv4.ip_forward do /etc/sysctl.conf e adicionar mais 2 novas. Ficaria assim:

net.ipv4.ip_forward = 1
net.netfilter.nf_conntrack_acct = 1
net.ipv4.conf.lo.rp_filter = 0

Para finalizar vamos criar 2 scripts no /root/ e colocá-los em /etc/rc.local para serem executados no boot do sistema:

/root/frw1.sh

#!/bin/bash
iptables -F -t mangle
iptables -X -t mangle
iptables -t mangle -N DIVERT
iptables -t mangle -A PREROUTING -p tcp -m socket -j DIVERT
 
iptables -t mangle -A DIVERT -j MARK --set-mark 1
iptables -t mangle -A DIVERT -j ACCEPT
 
iptables -t mangle -A PREROUTING -p tcp --dport 80 -j TPROXY --tproxy-mark 0x1/0x1 --on-port 3129

 

/root/frw2.sh

#!/bin/bash
ebtables -t broute -A BROUTING -i eth1 -p ipv4 --ip-proto tcp --ip-dport 80 -j redirect --redirect-target DROP
 
ebtables -t broute -A BROUTING -i eth0 -p ipv4 --ip-proto tcp --ip-sport 80 -j redirect --redirect-target DROP
 
cd /proc/sys/net/bridge/
for i in *
do
  echo 0 > $i
done
unset i

Atenção numa coisa, reparem as 2 interfaces de rede em vermelho acima. A primeira, eth1, é a interface da rede interna que vai para os clientes e a interface eth0 é a que está ligada pro lado da Internet. Se a sua ligação estiver diferente, altere o script.

# chmod +x /root/frw1.sh /root/frw2.sh 

Agora colocamos os scripts para serem executados no boot. Para isso editem o /etc/rc.local e adicionem as 4 linhas abaixo: 

ip rule add fwmark 1 lookup 100
ip route add local 0.0.0.0/0 dev lo table 100
/root/frw1.sh
/root/frw2.sh

Pronto, terminado. Agora só testarem.

Abaixo as referências que usei:

http://wiki.squid-cache.org/ConfigExamples/Intercept/CentOsTproxy4?action=show&redirect=ConfigExamples%2FTPROXYPatchingCentOS#TPROXY_v4_with_CentOS_5.3

http://wiki.squid-cache.org/Features/Tproxy4

http://techfree.com.br/wordpress/2009/01/18/tuning-no-squid/

Bem espero ter ajudado :)

Marcelo Gondim <gondim @ linuxinfo.com.br>