Vous avez un routeur qui vous relie au réseau de l'établissement et un client qui représente un segment de réseau privé. L'ensemble doit fonctionner (accès à internet, résolution de nom, masquage d'adresse.

iptables -t nat -A POSTROUTING -s 192.168.0.0/24 -j MASQUERADE 
# si 192.168.0.0 est le réseau privé

Vérifier que le routeur fonctionne. Faites un test à partir du client. Supprimez au besoin toutes les règles iptables et activez l'ipmasquerade.

Mettez une règle qui interdise toute requête à destination d'une application HTTP (port 80). Vérifier que les clients ne peuvent plus sortir.

# Ici on bloque tout, c'est brutal, mais on va faire avec.
iptables -P FORWARD DROP

Faites une sauvegarde de votre fichier de configuration original (/etc/squid.conf). Modifiez le fichier de configuration de squid en vous appuyant sur celui donné ci-dessous.

http_port 3128
#We recommend you to use the following two lines.
acl QUERY urlpath_regex cgi-bin \?
no_cache deny QUERY
cache_mem 8 MBM

maximum_object_size_in_memory 8 KB

cache_dir ufs /var/spool/squid 100 16 256

cache_access_log /var/log/squid/access.log
cache_log /var/log/squid/cache.log
cache_store_log /var/log/squid/store.log

# Put your FQDN here
visible_hostname freeduc-sup.foo.org

pid_filename /var/run/squid.pid

#Recommended minimum configuration:
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

#Recommended minimum configuration:
http_access allow manager localhost
http_access allow all

Initialisez l'espace disque pour le cache.

# Vérifiez que le FQDN de votre serveur est renseigné
# et que la résolution de nom locale fonctionne (fichier hosts ou DNS).
# initialisation de la zone de cache
squid -z
# Lancement de squid
/etc/init.d/squid start | restart

Démarrer et vérifier le bon fonctionnement de Squid. Consultez également les journaux.

$>ps aux |  grep squid
root      2984  0.0  0.4  4048 1124 ?  S  15:22   0:00 \
                                               /usr/sbin/squid -D -sYC
proxy     2987  2.1  1.6  6148 4068 ?  S  15:22   0:00 (squid) -D -sYC

Vérifier que le port d'écoute est correct.

mlx@uranus:~$ netstat -atup | grep LISTEN
(Tous les processus ne peuvent être identifiés, les infos sur 
les processus non possédés ne seront pas affichées, vous devez 
être root pour les voir toutes.)

tcp        0      0 *:3128          *:*                LISTEN      -                   

Identifiez l'endroit de stockage du cache sur le disque.

Configurer le client pour qu'il utilise le service proxy sur les requêtes HTTP, vérifier le bon fonctionnement.

Figure 41.1. Configuration du client

Identifiez les traces dans les journaux.

root@uranus:/home/mlx# more /var/log/squid/access.log
1053864320.437   1741 192.168.0.2 TCP_MISS/200 5552 \
   GET http://www.cru.fr/documents/ - DIRECT/195.220.94.166 text/html
1053864320.837   1096 192.168.0.2 TCP_MISS/304 331 \
   GET http://www.cru.fr/styles/default.css - DIRECT/195.220.94.166 -
1053864321.257    420 192.168.0.2 TCP_MISS/304 331 \
   GET http://www.cru.fr/logos/logo-cru-150x53.gif - DIRECT/195.220.94
1053864321.587    696 192.168.0.2 TCP_MISS/304 331 \
   GET http://www.cru.fr/icons-cru/mailto.gif - DIRECT/195.220.94.166
1053864550.537   1461 192.168.0.2 TCP_MISS/200 5552 \
   GET http://www.cru.fr/documents/ - DIRECT/195.220.94.166 text/htm

Interdisez tous les accès avec la règle :

http_access deny all

Vérifiez le fonctionnement.

Interdisez l'accès à un serveur (google.fr) par exemple. Vérifiez le fonctionnement.

acl google dstdomain .google.fr
http_access deny google

Construisez deux fichiers, l'un qui permettra de stocker des adresses IP, l'autre des mots clés. Construisez une ACL qui interdit l'accès en sortie aux machines qui ont les adresses IP déterminées dans le premier fichier, et une ACL qui empêche l'accès aux URL qui contiennent les mots clés stockés dans le second fichier.

# Exemple de ce que le fichier "adresse_ip" contient :
# Mettez dans la liste des adresses celle de votre client pour tester
192.168.0.2
192.168.0.10

# Exemple de ce que le fichier "mot_cle" contient :
jeu
game

# Exemple d'ACL
acl porn url_regex "/etc/squid/mot_cle"
acl salleTP_PAS_OK src "/etc/squid/adresse_ip"
http_access deny porn
http_access deny salleTP_PAS_OK

Tester le fonctionnement de ces deux ACL. (Utiliser comme url de destination par exemple http://games.yahoo.com/)

Configurez Squid pour qu'il affiche des pages (messages d'erreur) en Français. Vérifiez le fonctionnement.

error_directory /usr/share/squid/errors/French

Identifiez la page qui est retournée lors d'un refus d'accès. Modifiez la page et le message retourné, puis vérifiez le fonctionnement.

Créez un fichier .pac pour la configuration des clients Mozilla. Vous en avez un complet dans la FAQ de squid. Celui-ci fait le minimum.

 function FindProxyForURL(url, host)
   {
    return "PROXY 192.168.0.1:3128; DIRECT";
   }

Mettez le fichier sur votre routeur dans /var/www/mozilla.pac et vérifiez que le serveur apache est bien démarré. Si la résolution de nom fonctionne, vous pouvez mettre le nom du serveur de configuration plutôt que l'adresse IP.

Configurez le client :

Figure 41.2. Configuration du client

Testez le bon fonctionnement du client.

Remettez la configuration du client dans sa situation initiale.

Modifier la configuration du client et du serveur, afin que la configuration globale devienne celle d'un proxy tranparent.

Vous allez modifier le fichier de configuration de squid et configurer votre routeur avec les règles suivantes si le service proxy est sur le routeur :

# A mettre dans le fichier de configuration de suid
# Relancer le service après
httpd_accel_host virtual
httpd_accel_port 80
httpd_accel_with_proxy  on
httpd_accel_uses_host_header on

# Les règles iptables
# On nettoie la table nat
# On utilise le port 3128, par utilisé par défaut sous Squid.
iptables -t nat -F PREROUTING

# ou toutes les tables nat si besoin
iptables -t nat -F

# On laisse passer (masque) les requêtes autres que sur le port 80
 iptables -t nat -A POSTROUTING -j MASQUERADE

# On redirige les requêtes sur le port 80
iptables -t nat -A PREROUTING -j DNAT -i eth1 -p TCP --dport 80 \
                                    --to-destination 192.168.0.1:3128

Supprimer toute configuration de proxy sur le client. Vérifier le bon fonctionnement du client.

Arrêtez les service proxy, vérifiez que les requêtes HTTP des clients ne sortent plus.

Il est possible de séparer les services du routage et proxy sur 2 machines différentes. Le principe est identique, seules les règles sur le routeur changent un peu. Vous trouverez la description d'une telle configuration dans :

# Transparent proxy with Linux and Squid mini HOWTO
http://www.tldp.org/HOWTO/mini/TransparentProxy.html

# Lire aussi sur netfilter 
http://www.netfilter.org/documentation/HOWTO/fr/NAT-HOWTO.txt
http://www.cgsecurity.org/Articles/netfilter.html

Mettez en place une ACL pour déclarer l'authentification des personnes.

# Ici on utilise le module ncsa_auth
auth_param basic program /usr/lib/squid/ncsa_auth /etc/squid/users
auth_param basic realm Squid proxy-caching web serve
auth_param basic children 5
acl foo proxy_auth REQUIRED
http_access allow foo

Créez les fichiers de compte et de mots de passe avec un compte utilisateur.

 htpasswd -c /etc/squid/users unUTILISATEUR
# mettez ensuite son mot de passe.

# Testez le fonctionnement du fichier et du module
# Vous passez en paramètre le nom du fichier de comptes
# Vous mettez le compte et le mot de passe, le module retourne OK
# En cas d'erreur il retourne ERR
root@uranus:/etc# /usr/lib/squid/ncsa_auth /etc/squid/users 
mlx password
OK
mlx mauvais
ERR

Figure 41.3. Authentification SQUID

Il y a pas mal de différences entre les paramètres des versions de Squid 1, squid 2 et Squid 2.5. Il est important de consulter les fichiers de documentation fournis avec le produit.

L'authentification ne fonctionne pas avec la configuration d'un proxy transparent.