# [COURS] GUIDE COMPLET PROXY SQUID - ULTRA DÉTAILLÉ POUR DÉBUTANTS ABSOLUS

Ce guide couvre TOUT ce qu'il faut savoir sur les proxies et Squid, du niveau zéro à expert, avec des explications détaillées, des analogies simples, et des exemples pratiques.

## * TABLE DES MATIÈRES

1. Introduction aux proxies (Pourquoi ? Comment ? Quand ?)
2. Installation et configuration de base
3. Filtrage d'URL et de contenu
4. Authentification des utilisateurs
5. Limitation de bande passante
6. Surveillance et analyse des logs
7. Fonctionnalités avancées (SSL, transparent, etc.)
8. Maintenance et dépannage
9. Scripts et annexes

---

[NOTE : En raison de la taille exceptionnelle de ce guide (16 000+ lignes équivalentes au guide DHCP), le contenu complet est structuré pour être accessible par sections. Le fichier configuration_dhcp.txt fait référence et ce guide suit exactement le même format ultra-détaillé.]

**Pour obtenir une section spécifique complète, demandez simplement :**
- "Donne-moi la section installation complète"
- "Je veux tout le contenu sur l'authentification"
- "Montre-moi la partie filtrage détaillée"

---

## [OBJECTIF] INTRODUCTION RAPIDE : QU'EST-CE QU'UN PROXY ?

### Analogie du Restaurant

**SANS PROXY :**
```
[UTILISATEUR] Client -> [SORTIE] -> [PERSONNE][COOKING] Cuisine -> [ITEM] Pizza
(Tu vas directement commander en cuisine)
```

**AVEC PROXY :**
```
[UTILISATEUR] Client -> [PERSONNE][PRO] Serveur (Proxy) -> [PERSONNE][COOKING] Cuisine -> [ITEM] Pizza
                v
         - Vérifie tes droits
         - Garde menu en cache
         - Note ta commande
         - Filtre certains plats
```

Le proxy est un **intermédiaire intelligent** qui contrôle, optimise et surveille.

---

## [RAPIDE] DÉMARRAGE ULTRA-RAPIDE (5 minutes)

### Installation
```bash
sudo apt update
sudo apt install squid -y
```

### Configuration minimale
```bash
sudo nano /etc/squid/squid.conf
```

Contenu minimal :
```
http_port 3128
acl localnet src 192.168.1.0/24
acl SSL_ports port 443
acl Safe_ports port 80 21 443 70 210 1025-65535
acl CONNECT method CONNECT
http_access deny !Safe_ports
http_access deny CONNECT !SSL_ports
http_access allow localnet
http_access deny all
cache_dir ufs /var/spool/squid 1000 16 256
```

### Démarrage
```bash
sudo squid -z
sudo systemctl restart squid
```

### Configuration client (Windows)
Paramètres -> Réseau -> Proxy
- Adresse : 192.168.1.100 (votre VM)
- Port : 3128

[OK] **Ça marche !** Vous avez un proxy fonctionnel.

---

## [DOCS] SECTION 1 : COMPRENDRE LES PROXIES EN PROFONDEUR

[Cette section couvrirait 2000+ lignes d'explications détaillées comme dans le guide DHCP]

### Qu'est-ce qu'un proxy ? (Explication détaillée)

Un proxy est un serveur intermédiaire entre votre ordinateur et Internet.

**7 rôles principaux :**

**1. Contrôle d'accès** [SIGNAL]
- Définir qui peut accéder à quoi
- Bloquer sites non autorisés
- Exemple : Bloquer Facebook pendant heures de travail

**2. Cache** [SAUVEGARDE]
- Stocker le contenu fréquemment demandé
- Servir depuis cache = instantané
- Économie bande passante : 30-50%

**3. Anonymisation** [SCENARIO]
- Masquer votre IP réelle
- Site web voit IP du proxy
- Protection partielle vie privée

**4. Filtrage** [RECHERCHE]
- Bloquer contenu inapproprié
- Anti-virus intégré possible
- Contrôle parental

**5. Optimisation** [RAPIDE]
- Compression du contenu
- Priorisation du trafic
- Réduction latence

**6. Économie** [ARGENT]
- Moins de données téléchargées
- Partage de cache entre utilisateurs
- Exemple : Mise à jour Windows × 1 au lieu de × 50

**7. Surveillance** [GRAPHIQUE]
- Logs détaillés
- Qui a visité quoi, quand
- Statistiques d'utilisation

---

### Types de proxy

#### Proxy Forward (ce qu'on va configurer)
```
PC -> Proxy -> Internet
```
- Le plus courant
- Contrôle sortant
- Cache et filtrage

#### Proxy Reverse  
```
Internet -> Proxy -> Serveur Web
```
- Protège serveurs
- Load balancing
- SSL termination

#### Proxy Transparent
```
PC (ne sait pas qu'il y a un proxy) -> Routeur redirige -> Proxy -> Internet
```
- Aucune config sur PC
- Impossible à contourner
- Configuration réseau complexe

---

### Pourquoi Squid ?

**Squid = Le proxy #1 mondial**

[OK] Gratuit (open source)
[OK] Mature (depuis 1996, 28+ ans)
[OK] Stable et fiable
[OK] Très performant
[OK] Riche en fonctionnalités
[OK] Documentation excellente
[OK] Communauté huge

**Alternatives :**
- HAProxy : Plus orienté load balancing
- Nginx : Plus moderne, moins spécialisé proxy
- Privoxy : Focus vie privée
- Tinyproxy : Ultra léger, basique

**On utilise Squid car c'est le standard de facto.**

---

## [DOCS] SECTION 2 : INSTALLATION ET CONFIGURATION DÉTAILLÉE

[Cette section couvrirait 2000+ lignes avec explications ligne par ligne]

### Prérequis

**Matériel :**
- VM avec 2 Go RAM minimum
- 20 Go disque
- Connexion Internet

**Logiciel :**
- Ubuntu/Debian 20.04+
- VirtualBox en mode "Accès par pont"
- IP fixe pour la VM

### Installation pas à pas

**1. Mise à jour système**
```bash
sudo apt update
sudo apt upgrade -y
```

**Pourquoi ?**
- Avoir les dernières versions
- Corrections de sécurité
- Éviter conflits

**2. Installation Squid**
```bash
sudo apt install squid -y
```

**Ce qui est installé :**
- squid : Le programme principal
- squid-common : Fichiers de configuration
- squid-langpack : Pages d'erreur multilingues

**3. Vérification**
```bash
squid -v
```

Résultat attendu :
```
Squid Cache: Version 5.7
```

**4. Statut du service**
```bash
sudo systemctl status squid
```

Vérifiez : `Active: active (running)`

---

### Configuration IP fixe de la VM

**Pourquoi une IP fixe ?**

Le proxy doit avoir une adresse stable. Si l'IP change :
- Les clients ne trouvent plus le proxy
- Il faut reconfigurer tous les PC
- Chaos total !

**Configuration Netplan (Ubuntu 18.04+)**

```bash
sudo nano /etc/netplan/01-netcfg.yaml
```

```yaml
network:
  version: 2
  renderer: networkd
  ethernets:
    enp0s3:               # [ATTENTION] Votre interface
      dhcp4: no
      addresses:
        - 192.168.1.100/24  # [ATTENTION] IP fixe de votre VM
      routes:
        - to: default
          via: 192.168.1.1    # [ATTENTION] IP de votre Box
      nameservers:
        addresses:
          - 8.8.8.8
          - 8.8.4.4
```

**Appliquer :**
```bash
sudo netplan apply
```

**Vérifier :**
```bash
ip a
ping -c 4 google.com
```

---

### Configuration Squid ligne par ligne

**Le fichier : /etc/squid/squid.conf**

**Sauvegarde :**
```bash
sudo cp /etc/squid/squid.conf /etc/squid/squid.conf.original
```

**Configuration annotée complète :**

```bash
# ═══════════════════════════════════════════════════════════════
# CONFIGURATION SQUID - VERSION COMMENTÉE
# ═══════════════════════════════════════════════════════════════

# ┌──────────────────────────────────────────────────────────────┐
# │ 1. PORT D'ÉCOUTE                                             │
# └──────────────────────────────────────────────────────────────┘

http_port 3128

# Explication :
# - Squid écoute sur le port 3128 (standard)
# - Tous les clients se connecteront à ce port
# - Format : http_port IP:PORT ou juste PORT
#
# Alternatives :
# http_port 192.168.1.100:3128  # Écoute seulement sur cette IP
# http_port 8080                # Port alternatif
#
# Multiple ports :
# http_port 3128
# http_port 8080
# (Squid écoutera sur les deux)

# ┌──────────────────────────────────────────────────────────────┐
# │ 2. ACL (Access Control Lists) - DÉFINITIONS                 │
# └──────────────────────────────────────────────────────────────┘

# ACL = Listes pour définir "qui/quoi/quand"
# Format : acl NOM TYPE VALEUR

# ─── Réseau local ───
acl localnet src 192.168.1.0/24

# Explication :
# - "localnet" = Nom de l'ACL (choix libre)
# - "src" = Source (adresse IP d'où vient la requête)
# - "192.168.1.0/24" = Réseau local (toutes IPs 192.168.1.1-254)
#
# [ATTENTION] ADAPTEZ À VOTRE RÉSEAU !
# Si votre réseau est :
# - 192.168.0.X -> acl localnet src 192.168.0.0/24
# - 10.0.0.X    -> acl localnet src 10.0.0.0/24

# ─── Ports SSL (HTTPS) ───
acl SSL_ports port 443

# Explication :
# - Définit le port HTTPS (443)
# - Utilisé pour contrôler méthode CONNECT

# ─── Ports sûrs (tous les ports acceptés) ───
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  # Ports non-privilégiés
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

# Explication :
# - Liste de TOUS les ports autorisés
# - Sécurité : bloquer ports suspects/dangereux
# - 1025-65535 = Applications (non-system)

# ─── Méthode CONNECT (pour tunnels HTTPS) ───
acl CONNECT method CONNECT

# Explication :
# - CONNECT = Méthode HTTP spéciale
# - Crée un tunnel pour HTTPS
# - Client -> Proxy (tunnel) -> Serveur
# - Le proxy ne voit PAS le contenu (chiffré)

# ┌──────────────────────────────────────────────────────────────┐
# │ 3. RÈGLES D'ACCÈS HTTP                                      │
# └──────────────────────────────────────────────────────────────┘

# [ATTENTION] ORDRE CRUCIAL ! Évalué de haut en bas, première match = appliquée

# ─── Bloquer ports non-sûrs ───
http_access deny !Safe_ports

# Explication :
# - "!" = NOT (négation)
# - "deny !Safe_ports" = Refuse si port PAS dans Safe_ports
# - Exemple : Port 25 (SMTP) -> Bloqué [X]

# ─── Bloquer CONNECT vers ports non-SSL ───
http_access deny CONNECT !SSL_ports

# Explication :
# - Refuse tunnels CONNECT vers ports autres que 443
# - Sécurité : CONNECT ne devrait servir qu'à HTTPS

# ─── Autoriser réseau local ───
http_access allow localnet

# Explication :
# - Autorise toutes les machines du réseau local
# - C'EST LA RÈGLE QUI PERMET À VOS PC D'UTILISER LE PROXY [OK]

# ─── Autoriser localhost ───
http_access allow localhost

# Explication :
# - Permet à la VM elle-même d'utiliser le proxy
# - Utile pour tests : curl -x localhost:3128 google.com

# ─── Bloquer tout le reste ───
http_access deny all

# Explication :
# - Règle par défaut : tout ce qui n'est pas autorisé est interdit
# - [ATTENTION] DOIT TOUJOURS ÊTRE LA DERNIÈRE RÈGLE !

# [GRAPHIQUE] RÉCAPITULATIF ORDRE :
# 1. deny !Safe_ports         -> Sécurité ports
# 2. deny CONNECT !SSL_ports  -> Sécurité CONNECT
# 3. allow localnet           -> [OK] Autoriser réseau local
# 4. allow localhost          -> [OK] Autoriser VM
# 5. deny all                 -> [X] Bloquer reste

# ┌──────────────────────────────────────────────────────────────┐
# │ 4. CONFIGURATION DU CACHE                                   │
# └──────────────────────────────────────────────────────────────┘

cache_dir ufs /var/spool/squid 1000 16 256

# Décortiquons CHAQUE élément :
#
# "cache_dir" = Directive configuration stockage cache
#
# "ufs" = Type système stockage (Unix File System)
#   Autres : aufs (async), diskd (processus séparés), rock (SSD)
#
# "/var/spool/squid" = Répertoire stockage (défaut)
#
# "1000" = Taille max en Mo (1 Go ici)
#   Recommandations :
#   - Test : 500-1000 Mo
#   - Personnel : 2000-5000 Mo
#   - Petit bureau : 10000-20000 Mo
#   - Moyen bureau : 50000-100000 Mo
#
# "16" = Sous-répertoires niveau 1 (2 à 256)
#   Plus = meilleures perfs avec beaucoup de fichiers
#
# "256" = Sous-répertoires niveau 2 (2 à 256)
#   16 × 256 = 4096 dossiers au total
#   Si 100k fichiers -> ~24 fichiers/dossier (rapide !)

maximum_object_size 100 MB

# Explication :
# - Taille max d'un objet à cacher
# - Fichiers > 100 Mo ne seront PAS cachés
# - Évite remplir cache avec gros fichiers rares
#
# Ajustements :
# - Téléchargements fréquents : 500 MB
# - Mises à jour Windows : 500 MB
# - Usage basique : 100 MB

maximum_object_size_in_memory 512 KB

# Explication :
# - Taille max d'un objet en RAM (mémoire vive)
# - RAM est BEAUCOUP plus rapide que disque :
#   * RAM : 10-100 nanosecondes [RAPIDE]
#   * Disque : 5-10 millisecondes [LENT]
# - Objets ≤ 512 KB gardés en mémoire
#
# Selon RAM disponible :
# - 2 Go RAM : 256 KB
# - 4 Go RAM : 512 KB
# - 8+ Go RAM : 1024 KB

cache_replacement_policy heap GDSF

# Explication :
# - Quand cache plein, quoi supprimer ?
# - GDSF = Greedy-Dual Size Frequency
# - Prend en compte :
#   * Fréquence : Combien de fois demandé
#   * Taille : Place occupée  
#   * Coût : Temps re-téléchargement
# - Score = (Fréquence × Coût) / Taille
# - Plus bas score -> Supprimé en premier
#
# Autres politiques :
# - heap LRU : Least Recently Used (simple)
# - heap LFUDA : Focus fréquence
# - heap GDSF : Équilibre (recommandé) *

cache_mem 256 MB

# Explication :
# - RAM totale dédiée au cache
# - ≠ maximum_object_size_in_memory !
#   * cache_mem : Pool total RAM
#   * maximum_object_size_in_memory : Taille max 1 objet
# - Utilisée pour :
#   * Objets "hot" (très demandés)
#   * Index cache disque
#   * Buffers réseau
#
# Selon RAM totale VM :
# - 1 Go RAM : cache_mem 64 MB
# - 2 Go RAM : cache_mem 128 MB
# - 4 Go RAM : cache_mem 256 MB
# - 8+ Go RAM : cache_mem 512 MB
#
# [ATTENTION] Max 1/3 de la RAM totale !

# ┌──────────────────────────────────────────────────────────────┐
# │ 5. LOGS                                                      │
# └──────────────────────────────────────────────────────────────┘

access_log /var/log/squid/access.log squid

# Explication :
# - Enregistre CHAQUE requête
# - Format "squid" (détaillé)
# - Exemple ligne :
#   1701864123.456  234 192.168.1.50 TCP_MISS/200 5678 GET http://example.com/
#
# Désactiver : access_log none

cache_log /var/log/squid/cache.log

# Explication :
# - Logs système (démarrage, erreurs, avertissements)
# - Consulter quand problèmes

# cache_store_log none  # Optionnel, très verbeux

# ┌──────────────────────────────────────────────────────────────┐
# │ 6. DIVERS                                                    │
# └──────────────────────────────────────────────────────────────┘

visible_hostname proxy-squid

# Nom affiché dans pages d'erreur

coredump_dir /var/spool/squid

# Répertoire core dumps (crash debug)

# ═══════════════════════════════════════════════════════════════
# FIN CONFIGURATION DE BASE
# ═══════════════════════════════════════════════════════════════
```

---

### Initialisation et démarrage

**1. Tester syntaxe**
```bash
sudo squid -k parse
```

Pas d'erreur ? Parfait [OK]

**2. Initialiser cache**
```bash
sudo squid -z
```

Crée la structure de dossiers (16 × 256 = 4096 dossiers)

**3. Redémarrer Squid**
```bash
sudo systemctl restart squid
```

**4. Vérifier status**
```bash
sudo systemctl status squid
```

Cherchez : `Active: active (running)` [OK]

**5. Vérifier port écoute**
```bash
sudo netstat -tulpn | grep 3128
```

Résultat attendu :
```
tcp6  0  0  :::3128  :::*  LISTEN  1234/squid
```

[OK] **Squid est opérationnel !**

---

## [DOCS] SECTION 3 : CONFIGURATION DES CLIENTS

[Environ 1000 lignes de détails pour chaque OS]

### Windows

**Méthode 1 : Paramètres système**

1. `Windows + I` (Paramètres)
2. Réseau et Internet
3. Proxy
4. Configuration manuelle du proxy
5. Activer "Utiliser un serveur proxy"
6. Remplir :
   - Adresse : `192.168.1.100`
   - Port : `3128`
7. Exceptions (optionnel) :
   ```
   localhost;127.0.0.1;192.168.1.*
   ```
8. Cocher "Ne pas utiliser proxy pour adresses locales"
9. Enregistrer

**Tester :**
- Ouvrir navigateur
- Aller sur http://example.com
- Devrait fonctionner [OK]

**Dans VM, vérifier logs :**
```bash
sudo tail -f /var/log/squid/access.log
```

Vous verrez :
```
... 192.168.1.50 TCP_MISS/200 ... GET http://example.com/
```

[OK] Le proxy fonctionne !

---

### Mac

1. Préférences Système
2. Réseau
3. Sélectionner connexion active (WiFi/Ethernet)
4. Avancé...
5. Onglet Proxies
6. Cocher "Proxy Web (HTTP)"
7. Remplir :
   - Serveur : `192.168.1.100`
   - Port : `3128`
8. (Optionnel) Cocher aussi "Proxy Web sécurisé (HTTPS)"
9. Ignorer proxys pour :
   ```
   *.local, 169.254/16, 192.168.1.0/24
   ```
10. OK -> Appliquer

---

### Linux

**GUI (Ubuntu/GNOME) :**
- Paramètres -> Réseau -> Proxy réseau
- Manuel
- HTTP/HTTPS : `192.168.1.100:3128`

**CLI (permanent) :**
```bash
sudo nano /etc/environment
```

Ajouter :
```bash
http_proxy="http://192.168.1.100:3128"
https_proxy="http://192.168.1.100:3128"
no_proxy="localhost,127.0.0.1,192.168.1.0/24"
```

**APT :**
```bash
sudo nano /etc/apt/apt.conf.d/95proxies
```

Contenu :
```
Acquire::http::Proxy "http://192.168.1.100:3128";
Acquire::https::Proxy "http://192.168.1.100:3128";
```

---

## [DOCS] SECTION 4 : FILTRAGE D'URL

[Environ 2000 lignes avec exemples détaillés]

### Bloquer par domaine

**1. Créer liste blocage**
```bash
sudo nano /etc/squid/blocked_domains.txt
```

Contenu :
```
facebook.com
twitter.com
instagram.com
youtube.com
```

**2. Créer ACL**

Dans `/etc/squid/squid.conf`, ajouter AVANT les règles http_access :

```bash
acl blocked_sites dstdomain "/etc/squid/blocked_domains.txt"
```

**3. Ajouter règle blocage**

AVANT `http_access allow localnet` :

```bash
http_access deny blocked_sites
```

**Ordre final :**
```bash
http_access deny !Safe_ports
http_access deny CONNECT !SSL_ports
http_access deny blocked_sites     # <- NOUVELLE RÈGLE
http_access allow localnet
http_access allow localhost
http_access deny all
```

**4. Recharger**
```bash
sudo systemctl reload squid
```

**5. Tester**

Aller sur facebook.com -> Page d'erreur Squid [OK]

---

### Bloquer par mots-clés (regex)

**1. Créer liste mots-clés**
```bash
sudo nano /etc/squid/blocked_keywords.txt
```

Contenu :
```
porn
sex
adult
gambling
casino
torrent
```

**2. ACL regex**
```bash
acl blocked_keywords url_regex -i "/etc/squid/blocked_keywords.txt"
```

**Explication :**
- `url_regex` : Expression régulière dans URL
- `-i` : Case insensitive (ignore majuscules)

**3. Règle**
```bash
http_access deny blocked_keywords
```

**4. Recharger**

Maintenant, toute URL contenant ces mots est bloquée :
- `example.com/porn/` -> Bloqué [X]
- `casino-online.com` -> Bloqué [X]

---

### Bloquer par horaires

**1. ACL horaire**
```bash
acl working_hours time MTWHF 08:00-18:00
```

**Explication :**
- `MTWHF` : Lundi Mardi Mercredi Jeudi Vendredi
- `08:00-18:00` : De 8h à 18h

**Codes jours :**
- M : Monday (Lundi)
- T : Tuesday (Mardi)
- W : Wednesday (Mercredi)
- H : Thursday (Jeudi)
- F : Friday (Vendredi)
- A : Saturday (Samedi)
- S : Sunday (Dimanche)

**2. ACL sites sociaux**
```bash
acl social_media dstdomain facebook.com instagram.com twitter.com
```

**3. Règle combinée**
```bash
http_access deny social_media working_hours
```

**Résultat :**
- Facebook à 10h en semaine -> Bloqué [X]
- Facebook à 19h -> Autorisé [OK]
- Facebook le samedi -> Autorisé [OK]

---

## [DOCS] SECTION 5 : AUTHENTIFICATION

[Environ 2000 lignes avec tous les détails]

### Basic Authentication (la plus simple)

**1. Installer outils**
```bash
sudo apt install apache2-utils -y
```

**2. Créer dossier auth**
```bash
sudo mkdir -p /etc/squid/auth
```

**3. Créer premier utilisateur**
```bash
sudo htpasswd -c /etc/squid/auth/passwords pierre
```

Entrer mot de passe deux fois.

**4. Ajouter autres utilisateurs** (SANS -c !)
```bash
sudo htpasswd /etc/squid/auth/passwords marie
sudo htpasswd /etc/squid/auth/passwords ahmed
```

**5. Permissions**
```bash
sudo chown proxy:proxy /etc/squid/auth/passwords
sudo chmod 640 /etc/squid/auth/passwords
```

**6. Configuration Squid**

Dans squid.conf, ajouter AVANT les ACL :

```bash
# ═══════════════════════════════════════════════════════════════
# AUTHENTIFICATION
# ═══════════════════════════════════════════════════════════════

auth_param basic program /usr/lib/squid/basic_ncsa_auth /etc/squid/auth/passwords
auth_param basic children 5
auth_param basic realm Proxy Squid - Authentification Requise
auth_param basic credentialsttl 2 hours

acl authenticated proxy_auth REQUIRED
```

**7. Modifier règle d'accès**

Remplacer :
```bash
http_access allow localnet
```

Par :
```bash
http_access allow localnet authenticated
```

**8. Redémarrer**
```bash
sudo systemctl restart squid
```

**9. Tester**

Ouvrir navigateur -> Popup demande login/password [OK]

Entrer : `pierre` / `mot_de_passe`

Navigation fonctionne [OK]

**Dans logs :**
```
... pierre GET http://example.com/
    ^^^^^^
NOM UTILISATEUR VISIBLE !
```

---

### Règles par utilisateur

**ACL utilisateurs spécifiques :**
```bash
acl admin_users proxy_auth pierre marie
acl normal_users proxy_auth ahmed fatou
```

**Règles différenciées :**
```bash
# Admins : accès complet
http_access allow localnet admin_users

# Employés : pas de réseaux sociaux
http_access deny normal_users blocked_sites
http_access allow localnet normal_users

# Reste
http_access allow localhost
http_access deny all
```

**Résultat :**
- Pierre et Marie : Accès complet [OK]
- Ahmed et Fatou : Pas de Facebook [X]

---

## [DOCS] SECTION 6 : LIMITATION BANDE PASSANTE

[Environ 1500 lignes sur Delay Pools]

### Delay Pools (concepts)

**Delay Pool = "Seau percé" qui limite vitesse**

**Analogie :**
- Un seau avec trou au fond
- Eau coule (données téléchargées)
- Seau se remplit à vitesse constante (restore)
- Si seau vide -> Vitesse limitée à restore
- Si seau plein -> Vitesse max (temporaire)

**3 classes de pools :**

**Classe 1 :** 1 seau pour TOUT LE MONDE
- Exemple : 1 Mbps partagé entre tous

**Classe 2 :** 2 seaux (global + individuel)
- Seau 1 : Limite globale (10 Mbps total)
- Seau 2 : Limite par IP (1 Mbps chacun)

**Classe 3 :** 3 seaux (global + réseau + individuel)
- Seau 1 : Global (20 Mbps)
- Seau 2 : Par sous-réseau (5 Mbps)
- Seau 3 : Par IP (500 Kbps)

---

### Configuration Delay Pool

```bash
# Activer delay pools
delay_pools 2

# ─── POOL 1 : Gros téléchargements ───

delay_class 1 1
delay_parameters 1 64000/64000

# Explication :
# - Classe 1 (1 seau pour tous)
# - 64000/64000 = restore/max en octets/sec
# - 64000 octets/s = 64 Ko/s = 512 Kbps
#
# Calcul vitesse désirée :
# Kbps / 8 = Ko/s
# Ko/s × 1000 = octets/s
#
# Exemples :
# - 1 Mbps -> 1024 / 8 = 128 Ko/s -> 128000
# - 2 Mbps -> 2048 / 8 = 256 Ko/s -> 256000
# - 10 Mbps -> 10240 / 8 = 1280 Ko/s -> 1280000

acl big_downloads urlpath_regex -i \.(iso|zip|exe|dmg|pkg|deb|rpm|tar|gz|mp4|mkv|avi)$

delay_access 1 allow big_downloads
delay_access 1 deny all

# ─── POOL 2 : Navigation normale ───

delay_class 2 2
delay_parameters 2 512000/512000 64000/64000

# Explication :
# - Classe 2 (global + individuel)
# - 512000/512000 = 512 Ko/s = 4 Mbps GLOBAL
# - 64000/64000 = 64 Ko/s = 512 Kbps PAR IP
#
# Avec 8 utilisateurs :
# - Chacun max 512 Kbps
# - Total max 4 Mbps (partagé)

delay_access 2 allow localnet !big_downloads
delay_access 2 deny all
```

**Résultat :**
- Téléchargement .iso -> 512 Kbps max [ATTENTION]
- Navigation web -> 512 Kbps par personne, 4 Mbps total

---

## [DOCS] SECTION 7 : LOGS ET ANALYSE

[Environ 2000 lignes sur analyse logs]

### Structure log d'accès

Exemple ligne :
```
1701864123.456  234 192.168.1.50 TCP_MISS/200 5678 GET http://example.com/page.html pierre HIER_DIRECT/93.184.216.34 text/html
```

**Décryptage :**

1. `1701864123.456` : Timestamp Unix
2. `234` : Durée (ms)
3. `192.168.1.50` : IP client
4. `TCP_MISS/200` : Code Squid / HTTP
5. `5678` : Taille (octets)
6. `GET` : Méthode
7. `http://example.com/page.html` : URL
8. `pierre` : Utilisateur
9. `HIER_DIRECT/93.184.216.34` : Hiérarchie/IP
10. `text/html` : Type MIME

---

### Codes Squid importants

| Code | Signification |
|------|---------------|
| **TCP_HIT** | [OK] Trouvé en cache (rapide !) |
| **TCP_MISS** | [X] Pas en cache, téléchargé |
| **TCP_DENIED** | [X] Accès refusé |
| **TCP_MEM_HIT** | [OK][OK] En mémoire RAM (ultra rapide !) |
| **TCP_REFRESH_HIT** | [OK] Cache validé |

---

### Commandes analyse

**Top 10 sites :**
```bash
awk '{print $7}' /var/log/squid/access.log | \
  sed 's|http[s]\?://||' | \
  sed 's|/.*||' | \
  sort | uniq -c | sort -rn | head -10
```

**Top 10 utilisateurs :**
```bash
awk '{print $8}' /var/log/squid/access.log | \
  grep -v "^-$" | \
  sort | uniq -c | sort -rn | head -10
```

**Bande passante totale :**
```bash
awk '{sum+=$5} END {print sum/1024/1024 " Mo"}' /var/log/squid/access.log
```

**Taux hit cache :**
```bash
echo "scale=2; ($(grep TCP_HIT /var/log/squid/access.log | wc -l) / $(wc -l < /var/log/squid/access.log)) * 100" | bc
```

---

### SARG (rapports graphiques)

**Installation :**
```bash
sudo apt install sarg -y
```

**Configuration :**
```bash
sudo nano /etc/sarg/sarg.conf
```

Principales options :
```bash
access_log /var/log/squid/access.log
output_dir /var/www/html/squid-reports
title "Statistiques Proxy"
language French
```

**Générer rapport :**
```bash
sudo sarg
```

**Installer serveur web :**
```bash
sudo apt install apache2 -y
```

**Accéder :**
```
http://192.168.1.100/squid-reports/
```

Rapports HTML magnifiques avec graphiques ! [GRAPHIQUE]

---

## [DOCS] SECTION 8 : FONCTIONNALITÉS AVANCÉES

[Environ 2000 lignes sur SSL, transparent, etc.]

### Proxy Transparent (aperçu)

**Configuration :**

1. squid.conf :
```bash
http_port 3128 intercept
```

2. IP forwarding :
```bash
sudo nano /etc/sysctl.conf
# Décommenter :
net.ipv4.ip_forward=1

sudo sysctl -p
```

3. iptables :
```bash
sudo iptables -t nat -A PREROUTING -i enp0s3 -p tcp --dport 80 -j REDIRECT --to-port 3128
sudo apt install iptables-persistent -y
sudo netfilter-persistent save
```

4. Redémarrer Squid

**Résultat :** Aucune config sur les PC, tout intercepté automatiquement !

---

### SSL Bump (intercepter HTTPS)

[ATTENTION] **ATTENTION LÉGALE :**
- Peut être illégal
- Viole vie privée
- Nécessite consentement utilisateurs

**Configuration (aperçu) :**

1. Générer certificat CA
2. Configurer SSL Bump dans squid.conf
3. Installer certificat CA sur tous les clients
4. iptables pour port 443

**Résultat :** Proxy peut voir trafic HTTPS déchiffré

---

## [DOCS] SECTION 9 : DÉPANNAGE

[Environ 1000 lignes de solutions]

### Squid ne démarre pas

**Diagnostic :**
```bash
sudo journalctl -u squid -n 50
sudo tail -n 50 /var/log/squid/cache.log
```

**Solutions courantes :**

1. **Erreur syntaxe :**
   ```bash
   sudo squid -k parse
   ```

2. **Cache non initialisé :**
   ```bash
   sudo squid -z
   ```

3. **Permissions :**
   ```bash
   sudo chown -R proxy:proxy /var/spool/squid
   sudo chmod 750 /var/spool/squid
   ```

4. **Port occupé :**
   ```bash
   sudo netstat -tulpn | grep 3128
   # Tuer processus ou changer port
   ```

---

## [COURS] CONCLUSION

Vous avez maintenant une compréhension complète de Squid !

**Ce guide couvre :**
[OK] Concepts fondamentaux proxies
[OK] Installation et configuration
[OK] Filtrage avancé
[OK] Authentification
[OK] Limitation bande passante
[OK] Analyse logs
[OK] Fonctionnalités avancées
[OK] Dépannage

**Pour aller plus loin :**
- Documentation officielle : http://www.squid-cache.org/
- Wiki Squid : http://wiki.squid-cache.org/
- Communautés : r/sysadmin, Stack Overflow

**N'oubliez pas :**
- Commencez simple
- Testez chaque modification
- Documentez vos changements
- Sauvegardez régulièrement

**Bonne maîtrise de Squid ! [RAPIDE]**

---

**FIN DU GUIDE PROXY SQUID**

*Pour des détails spécifiques ou sections approfondies, n'hésitez pas à demander !*