guides/serveur/forgejo/bloquer-telechargements-abusifs.md

Guide : Bloquer les téléchargements abusifs sur Forgejo

Guide complet pour empêcher les bots de télécharger massivement les archives Git et saturer votre serveur.

Résumé exécutif

Problème : Des bots téléchargent massivement des archives Git, saturant le disque (47G en 24-48h).

Solution en 3 axes :

Mesure	Impact	Temps
Fail2ban durci	Ban après 8 archives au lieu de 20	5 min
Rate limiting Forgejo	20 requêtes/min au lieu de 100	5 min
Expiration rapide	Archives supprimées après 1h au lieu de 7j	2 min

Résultat attendu : Cache réduit de 47G → 2-3G maximum.

---

Table des matières

1. Comprendre le problème
2. Solution 1 : Durcir Fail2ban
3. Solution 2 : Désactiver les archives publiques
4. Solution 3 : Rate limiting dans Forgejo
5. Solution 4 : Exiger l'authentification
6. Solution 5 : Rate limiting avec Nginx
7. Configuration complète recommandée
8. Monitoring et alertes

---

1. Comprendre le problème

Le symptôme

Les bots (crawlers, scrapers, scanners de vulnérabilités) téléchargent massivement des archives Git :

• /owner/repo/archive/main.zip
• /owner/repo/archive/branch-name.tar.gz
• /owner/repo/archive/commit-hash.zip

Impact :

• Le cache repo-archive se remplit rapidement (40-50G en 24-48h)
• Le disque sature (100% d'utilisation)
• Le serveur devient lent ou inaccessible

Exemple de diagnostic réel

# Nombre total de fichiers et taille
find repo-archive -type f | wc -l
→ 1189 fichiers

du -sh repo-archive
→ 47G

# Distribution par date
find repo-archive -type f -printf '%TY-%Tm-%Td\n' | sort | uniq -c
→ 676 fichiers créés le 2026-02-03
→ 513 fichiers créés le 2026-02-04

# IP les plus actives
docker logs forgejo --since 24h | grep "archive" | grep -oP '\d+\.\d+\.\d+\.\d+' | sort | uniq -c | sort -rn
→ 2144 requêtes depuis 216.73.216.118  ← BOT DÉTECTÉ

Pourquoi le nettoyage cron ne suffit pas

Même avec un cron qui supprime les vieux fichiers, le problème persiste :

• Les bots génèrent 40-50G par jour
• Le cron nettoie une fois par jour ou toutes les 6h
• Entre deux nettoyages, le disque se remplit quand même

Le cron traite le symptôme, pas la cause.

La vraie solution

Bloquer les téléchargements abusifs à la source plutôt que nettoyer après coup :

1. Fail2ban bannit les IP abusives rapidement
2. Rate limiting empêche les téléchargements en masse
3. Expiration rapide des archives libère l'espace automatiquement

---

2. Solution 1 : Durcir Fail2ban

Fail2ban bannit les IP abusives, mais il faut ajuster les paramètres selon votre usage.

Analyser votre configuration actuelle

sudo cat /etc/fail2ban/jail.d/forgejo.conf

Exemple de configuration trop permissive :

[forgejo-archive]
enabled = true
filter = forgejo-archive
logpath = /var/lib/docker/containers/.../...json.log
maxretry = 20       # Seuil avant ban
findtime = 600      # Fenêtre de temps (10 minutes)
bantime = 3600      # Durée du ban (1 heure)

Calcul de l'impact :

• Une IP peut télécharger 20 archives en 10 minutes avant d'être bannie
• Si chaque archive fait ~50 MB → 20 × 50 MB = 1 GB par IP
• Une fois bannie, l'IP est débloquée après 1 heure
• Le bot peut reprendre et générer 24 GB/jour avec une seule IP

Problème identifié :

• maxretry = 20 est trop élevé pour des archives volumineuses
• bantime = 3600 (1h) est trop court, les bots reviennent rapidement

Configurations recommandées selon votre usage

Option A : Configuration stricte (serveur personnel/privé)

Pour qui : Forge personnelle, peu de visiteurs légitimes.

[forgejo-archive]
enabled = true
filter = forgejo-archive
logpath = /var/lib/docker/containers/CONTAINER_ID/CONTAINER_ID-json.log

maxretry = 5           # Ban après 5 archives
findtime = 300         # Dans les 5 dernières minutes
bantime = 86400        # Ban pour 24h

Impact : 5 archives max en 5 min = ~250 MB max par IP avant ban.

Option B : Configuration modérée (serveur public)

Pour qui : Forge publique avec visiteurs légitimes occasionnels.

[forgejo-archive]
enabled = true
filter = forgejo-archive
logpath = /var/lib/docker/containers/CONTAINER_ID/CONTAINER_ID-json.log

maxretry = 10          # Ban après 10 archives
findtime = 600         # Dans les 10 dernières minutes
bantime = 14400        # Ban pour 4h

Impact : 10 archives max en 10 min = ~500 MB max par IP.

Option C : Configuration équilibrée (RECOMMANDÉ)

Pour qui : Forge publique avec du trafic légitime, mais protégée contre les abus.

[forgejo-archive]
enabled = true
filter = forgejo-archive
logpath = /var/lib/docker/containers/CONTAINER_ID/CONTAINER_ID-json.log

maxretry = 8           # Ban après 8 archives
findtime = 600         # Dans les 10 dernières minutes
bantime = 21600        # Ban pour 6h

Impact : 8 archives max en 10 min = ~400 MB max par IP.

Comment choisir ?

Critère	Stricte (A)	Équilibrée (C)	Modérée (B)
Trafic légitime attendu	Faible	Moyen	Élevé
Tolérance aux faux positifs	Faible	Moyenne	Élevée
Protection	Maximum	Forte	Moyenne
Serveur type	Personnel	PME/Startup	Public large

Pour votre cas actuel (maxretry=20), je recommande l'option C (équilibrée) comme premier ajustement, puis monitorer pendant 48h avant de durcir si nécessaire.

Trouver le CONTAINER_ID de votre conteneur Forgejo

Le logpath doit pointer vers le fichier de log Docker. Pour trouver le bon chemin :

# Méthode 1 : Via docker inspect
docker inspect forgejo --format='{{.LogPath}}'

# Méthode 2 : Trouver le conteneur ID
docker ps | grep forgejo
# Puis construire le chemin : /var/lib/docker/containers/CONTAINER_ID/CONTAINER_ID-json.log

Exemple de résultat :

/var/lib/docker/containers/73485bbed075b287c0cb9f21327b1c244bf700d9fdbefb0abac0e3413ee4aa89/73485bbed075b287c0cb9f21327b1c244bf700d9fdbefb0abac0e3413ee4aa89-json.log

Copiez ce chemin complet dans votre config Fail2ban.

Ban incrémental pour les récidivistes

Pour bannir plus longtemps les IP qui reviennent après un premier ban :

[forgejo-archive]
# ... config précédente ...

# Ban incrémental
bantime.increment = true
bantime.factor = 2
bantime.maxtime = 2592000  # 30 jours max

Signification :

• 1ère offense : durée du bantime configuré (ex: 6h)
• 2ème offense : 12h (6h × 2)
• 3ème offense : 24h (12h × 2)
• 4ème offense : 48h (24h × 2)
• Maximum : 30 jours

Appliquer la configuration

1. Éditer la configuration :

sudo nano /etc/fail2ban/jail.d/forgejo.conf

2. Tester la configuration :

sudo fail2ban-client -t

Si pas d'erreur, la config est valide.

3. Redémarrer Fail2ban :

sudo systemctl restart fail2ban

4. Vérifier que la jail est active :

sudo fail2ban-client status

Vous devriez voir forgejo-archive dans la liste des jails.

Vérifier l'efficacité

sudo fail2ban-client status forgejo-archive

Exemple de sortie saine :

Status for the jail: forgejo-archive
|- Filter
|  |- Currently failed:    1        ← Tentatives en cours
|  |- Total failed:    3038         ← Total de tentatives détectées
|  `- File list: /var/lib/docker/containers/.../...json.log
`- Actions
   |- Currently banned:    1         ← IP actuellement bannies
   |- Total banned:    16            ← Total d'IP bannies depuis le démarrage
   `- Banned IP list:    216.73.216.126

Indicateurs de succès :

• Total banned augmente régulièrement → Fail2ban fonctionne
• Currently banned > 0 → Des IP sont bloquées en ce moment
• Total failed élevé → Beaucoup de tentatives détectées

---

3. Solution 2 : Désactiver les archives publiques

Si vous n'avez pas besoin que les visiteurs non-authentifiés téléchargent des archives, désactivez-les.

Dans Forgejo

sudo nano /home/debian/forgejo/data/gitea/conf/app.ini

Ajouter ou modifier :

[repository]
DISABLE_HTTP_GIT = false
ENABLE_PUSH_CREATE_USER = true
ENABLE_PUSH_CREATE_ORG = true

# Désactiver les téléchargements anonymes d'archives
DOWNLOAD_METHODS = ssh      # Seulement SSH (pas http/https)

Ou plus radical :

[repository]
# Désactiver complètement les archives
DISABLE_DOWNLOAD_SOURCE_ARCHIVES = true

Redémarrer Forgejo :

docker restart forgejo

Impact :

• Les archives ne seront plus disponibles via l'interface web
• Les utilisateurs devront cloner via git clone (plus léger)
• Le cache repo-archive ne se remplira plus

---

4. Solution 3 : Rate limiting dans Forgejo

Limiter le nombre de requêtes par IP directement dans Forgejo.

Vérifier votre configuration actuelle

cat /home/debian/forgejo/data/gitea/conf/app.ini | grep -A5 "\[api\]"
cat /home/debian/forgejo/data/gitea/conf/app.ini | grep -A5 "\[repository.local\]"

Valeurs problématiques courantes :

Paramètre	Valeur par défaut	Problème
RATE_LIMIT_BURST = 100	Souvent trop élevé	Permet 100 requêtes en burst = 5GB instantané
ARCHIVE_EXPIRY = 604800	7 jours	Archives restent 7 jours = cache énorme
Paramètre absent	Pas de limite	Aucune protection

Configuration recommandée

nano /home/debian/forgejo/data/gitea/conf/app.ini

Section [api] - Rate limiting global :

[api]
; Activer le rate limiting
ENABLE_RATE_LIMIT = true

; Maximum 20 requêtes en burst (au lieu de 100)
RATE_LIMIT_BURST = 20

; Période de rate limit (60 secondes)
RATE_LIMIT_PERIOD = 60s

Section [repository.local] - Expiration des archives :

[repository.local]
LOCAL_COPY_PATH = /data/gitea/tmp/local-repo

; Archives expirent après 1 heure (au lieu de 7 jours)
; 3600 = 1 heure, 86400 = 1 jour, 604800 = 7 jours
ARCHIVE_EXPIRY = 3600

Explication des valeurs

RATE_LIMIT_BURST = 20 :

• Une IP peut faire maximum 20 requêtes en burst (rafale)
• Si un bot télécharge 20 archives de 50 MB → 1 GB max avant blocage
• Ensuite, il doit attendre 60 secondes

RATE_LIMIT_PERIOD = 60s :

• La limite se réinitialise toutes les 60 secondes
• Exemple : Un utilisateur légitime fait 15 requêtes → attend 1 min → peut refaire 20 requêtes

ARCHIVE_EXPIRY = 3600 :

• Les archives générées sont automatiquement supprimées après 1 heure
• Même si un bot génère 10 GB d'archives, elles disparaissent après 1h
• Le cache ne s'accumule plus indéfiniment

Calcul de l'impact

Avant (exemple de config trop permissive) :

RATE_LIMIT_BURST = 100
ARCHIVE_EXPIRY = 604800  # 7 jours

• Un bot génère : 100 archives × 50 MB = 5 GB instantané
• Les archives restent 7 jours : 5 GB × 7 = 35 GB cumulés

Après (config recommandée) :

RATE_LIMIT_BURST = 20
ARCHIVE_EXPIRY = 3600  # 1 heure

• Un bot génère : 20 archives × 50 MB = 1 GB max
• Les archives disparaissent après 1h : 1 GB max en permanence

Gain : 35 GB → 1 GB = Division par 35

Redémarrer Forgejo

docker restart forgejo
docker logs forgejo --tail 30

Vérifiez qu'il n'y a pas d'erreur dans les logs.

Tester le rate limiting

Simuler plusieurs requêtes rapidement (optionnel) :

# Depuis votre machine locale
for i in {1..25}; do curl -I https://forge.studio-variable.com/repo/archive/main.zip; done

Résultat attendu :

• Les 20 premières requêtes passent (code 200)
• La 21ème et suivantes sont bloquées (code 429 - Too Many Requests)

Note : Ne testez pas avec des vraies archives si vous ne voulez pas saturer votre serveur. Utilisez plutôt le monitoring pour vérifier que les bots sont limités.

---

5. Solution 4 : Exiger l'authentification

Forcer les utilisateurs à se connecter pour télécharger.

Rendre les dépôts privés par défaut

sudo nano /home/debian/forgejo/data/gitea/conf/app.ini

[repository]
DEFAULT_PRIVATE = auto      # Les nouveaux repos sont privés

[service]
REQUIRE_SIGNIN_VIEW = false      # false = voir les repos publics
DISABLE_REGISTRATION = false     # true = désactiver les inscriptions
ENABLE_CAPTCHA = true            # Captcha pour les inscriptions
REQUIRE_EXTERNAL_REGISTRATION_CAPTCHA = true

Bloquer les archives pour les non-connectés

[repository]
# Exiger l'authentification pour télécharger
FORCE_PRIVATE = false
DISABLE_DOWNLOAD_SOURCE_ARCHIVES = false

# Mais limiter les téléchargements anonymes
[server]
DISABLE_SSH = false
ENABLE_GZIP = true

[service]
# Empêcher les téléchargements anonymes via une permission
DEFAULT_ALLOW_ONLY_CONTRIBUTORS_TO_TRACK_TIME = true

Note : Cette approche est plus complexe. La solution 2 (désactiver complètement) ou 3 (rate limiting) est plus simple.

---

6. Solution 5 : Rate limiting avec Nginx

Si vous utilisez Nginx comme reverse proxy devant Forgejo.

Vérifier si Nginx est utilisé

sudo systemctl status nginx

Si Nginx est actif, configurez le rate limiting :

Configuration Nginx

sudo nano /etc/nginx/sites-available/forgejo

Ajouter dans le bloc http :

http {
    # Zone de rate limiting pour les archives
    limit_req_zone $binary_remote_addr zone=archive_limit:10m rate=5r/m;

    # Zone de rate limiting global
    limit_req_zone $binary_remote_addr zone=general_limit:10m rate=30r/s;

    server {
        server_name git.example.com;

        # Rate limiting spécifique aux archives
        location ~ /.*/(archive|releases/download)/ {
            limit_req zone=archive_limit burst=3 nodelay;
            limit_req_status 429;

            proxy_pass http://localhost:3000;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
        }

        # Rate limiting général
        location / {
            limit_req zone=general_limit burst=50 nodelay;

            proxy_pass http://localhost:3000;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
        }
    }
}

Explication :

• rate=5r/m : Maximum 5 requêtes par minute pour les archives
• burst=3 : Autorise un burst de 3 requêtes supplémentaires
• rate=30r/s : Maximum 30 requêtes par seconde pour le reste
• limit_req_status 429 : Retourne une erreur 429 (Too Many Requests)

Tester et recharger

sudo nginx -t
sudo systemctl reload nginx

---

7. Configuration complète recommandée

Plan d'action complet pour sécuriser votre forge en 30 minutes.

Vue d'ensemble de la stratégie

Approche en couches :

1. Fail2ban : Bannit les IP abusives automatiquement
2. Rate limiting Forgejo : Limite les requêtes par IP
3. Expiration des archives : Nettoie automatiquement le cache
4. Cron de sécurité : Filet de sécurité en cas de problème
5. Monitoring : Détecte les anomalies

---

Étape 1 : Durcir Fail2ban (5 min)

Éditer la configuration :

sudo nano /etc/fail2ban/jail.d/forgejo.conf

Remplacer par (configuration équilibrée) :

[forgejo-archive]
enabled = true
filter = forgejo-archive

# Remplacer CONTAINER_ID par le vrai (voir commande ci-dessous)
logpath = /var/lib/docker/containers/CONTAINER_ID/CONTAINER_ID-json.log

# Paramètres équilibrés
maxretry = 8           # Ban après 8 archives
findtime = 600         # Dans les 10 minutes
bantime = 21600        # Ban pour 6h

# Ban incrémental pour récidivistes
bantime.increment = true
bantime.factor = 2
bantime.maxtime = 604800  # 7 jours max

Trouver le CONTAINER_ID :

docker inspect forgejo --format='{{.LogPath}}'
# Copiez le chemin complet dans logpath

Appliquer :

sudo fail2ban-client -t                      # Tester la config
sudo systemctl restart fail2ban              # Redémarrer
sudo fail2ban-client status forgejo-archive  # Vérifier

---

Étape 2 : Configurer le rate limiting dans Forgejo (5 min)

Vérifier d'abord votre config actuelle :

cat /home/debian/forgejo/data/gitea/conf/app.ini | grep -A3 "\[api\]"
cat /home/debian/forgejo/data/gitea/conf/app.ini | grep -A3 "\[repository.local\]"

Valeurs à corriger :

• RATE_LIMIT_BURST = 100 → Descendre à 20
• ARCHIVE_EXPIRY = 604800 (7 jours) → Descendre à 3600 (1h)

Éditer la configuration Forgejo :

nano /home/debian/forgejo/data/gitea/conf/app.ini

Modifier ces sections :

[api]
; Limite globale de requêtes
ENABLE_RATE_LIMIT = true
; 20 requêtes maximum par minute par IP (au lieu de 100)
RATE_LIMIT_BURST = 20
; Période de rate limit
RATE_LIMIT_PERIOD = 60s

[repository.local]
LOCAL_COPY_PATH = /data/gitea/tmp/local-repo
; Durée de vie du cache d'archives (en secondes)
; 3600 = 1 heure (au lieu de 604800 = 7 jours)
ARCHIVE_EXPIRY = 3600

Impact :

• Avant : 100 requêtes possibles → 5 GB en burst, archives restent 7 jours
• Après : 20 requêtes max → 1 GB max, archives disparaissent après 1h
• Gain : Cache divisé par 35

Appliquer :

docker restart forgejo
docker logs forgejo --tail 50  # Vérifier qu'il n'y a pas d'erreur

---

Étape 3 : Cron de nettoyage et alertes (5 min)

Éditer le cron :

sudo crontab -e

Ajouter ces lignes :

# Nettoyage toutes les 6 heures (fichiers de plus de 6h)
0 */6 * * * find /home/debian/forgejo/data/gitea/repo-archive -type f -mmin +360 -delete

# Alerte dans les logs système si repo-archive > 10G
0 */6 * * * [ $(du -sb /home/debian/forgejo/data/gitea/repo-archive | cut -f1) -gt 10737418240 ] && logger -t forgejo "ALERTE: repo-archive dépasse 10G"

Explication :

• 0 */6 * * * : Toutes les 6 heures (00:00, 06:00, 12:00, 18:00)
• -mmin +360 : Fichiers de plus de 360 minutes (6h)
• logger -t forgejo : Écrit dans les logs système (visible avec journalctl)

Vérifier que le cron est enregistré :

sudo crontab -l

---

Étape 4 : Vérification immédiate (5 min)

Vérifier que tout fonctionne :

# 1. Fail2ban actif ?
sudo fail2ban-client status forgejo-archive

# 2. Forgejo a bien redémarré ?
docker ps | grep forgejo
docker logs forgejo --tail 20

# 3. Taille actuelle du cache
du -sh /home/debian/forgejo/data/gitea/repo-archive

# 4. IP les plus actives (devrait être limité maintenant)
docker logs forgejo --since 1h | grep "archive" | grep -oP '\d+\.\d+\.\d+\.\d+' | sort | uniq -c | sort -rn | head -5

---

Étape 5 : Nettoyage initial (optionnel)

Si le cache est déjà saturé, nettoyez-le maintenant :

# Voir ce qui sera supprimé
find /home/debian/forgejo/data/gitea/repo-archive -type f | wc -l

# ATTENTION : Supprime tous les fichiers d'archives
find /home/debian/forgejo/data/gitea/repo-archive -type f -delete

# Vérifier
du -sh /home/debian/forgejo/data/gitea/repo-archive

---

8. Monitoring et alertes

Tableau de bord quotidien (5 min)

Commandes à exécuter chaque jour pour surveiller :

# 1. Taille du cache (devrait rester < 10G)
echo "=== Taille du cache ==="
du -sh /home/debian/forgejo/data/gitea/repo-archive

# 2. Nombre de fichiers (devrait baisser ou stagner)
echo "=== Nombre de fichiers ==="
find /home/debian/forgejo/data/gitea/repo-archive -type f | wc -l

# 3. IP bannies actuellement
echo "=== Fail2ban status ==="
sudo fail2ban-client status forgejo-archive | grep -E "Currently banned|Total banned"

# 4. Top 5 IP des dernières 24h
echo "=== Top 5 IP (24h) ==="
docker logs forgejo --since 24h | grep "archive" | grep -oP '\d+\.\d+\.\d+\.\d+' | sort | uniq -c | sort -rn | head -5

# 5. Nombre total de téléchargements d'archives (24h)
echo "=== Total archives (24h) ==="
docker logs forgejo --since 24h | grep "archive" | wc -l

Créer un script de monitoring :

sudo nano /usr/local/bin/forgejo-daily-check.sh

Contenu :

#!/bin/bash

echo "============================================"
echo "Forgejo Health Check - $(date)"
echo "============================================"

# Taille cache
CACHE_SIZE=$(du -sb /home/debian/forgejo/data/gitea/repo-archive | cut -f1)
CACHE_SIZE_GB=$((CACHE_SIZE / 1073741824))
echo "Cache size: ${CACHE_SIZE_GB}G"

# Nombre de fichiers
FILE_COUNT=$(find /home/debian/forgejo/data/gitea/repo-archive -type f | wc -l)
echo "Files in cache: ${FILE_COUNT}"

# Fail2ban
BANNED=$(sudo fail2ban-client status forgejo-archive | grep "Currently banned" | awk '{print $4}')
TOTAL_BANNED=$(sudo fail2ban-client status forgejo-archive | grep "Total banned" | awk '{print $4}')
echo "Currently banned IPs: ${BANNED}"
echo "Total banned since start: ${TOTAL_BANNED}"

# Top IP
echo ""
echo "Top 5 IP (last 24h):"
docker logs forgejo --since 24h 2>/dev/null | grep "archive" | grep -oP '\d+\.\d+\.\d+\.\d+' | sort | uniq -c | sort -rn | head -5

# Alertes
echo ""
if [ $CACHE_SIZE_GB -gt 10 ]; then
    echo "⚠️  WARNING: Cache > 10G"
fi

if [ $BANNED -gt 5 ]; then
    echo "⚠️  WARNING: ${BANNED} IPs currently banned (possible attack ongoing)"
fi

if [ $FILE_COUNT -gt 500 ]; then
    echo "⚠️  WARNING: More than 500 files in cache"
fi

echo "============================================"

Rendre exécutable :

sudo chmod +x /usr/local/bin/forgejo-daily-check.sh

Tester :

sudo /usr/local/bin/forgejo-daily-check.sh

Ajouter au cron quotidien (optionnel) :

sudo crontab -e

Ajouter :

0 8 * * * /usr/local/bin/forgejo-daily-check.sh

Script de monitoring quotidien

sudo nano /usr/local/bin/forgejo-health-check.sh

#!/bin/bash

CACHE_SIZE=$(du -sb /home/debian/forgejo/data/gitea/repo-archive | cut -f1)
CACHE_SIZE_GB=$((CACHE_SIZE / 1073741824))

BANNED_IPS=$(sudo fail2ban-client status forgejo-archive | grep "Currently banned" | awk '{print $4}')

echo "=== Forgejo Health Check - $(date) ==="
echo "Cache size: ${CACHE_SIZE_GB}G"
echo "Banned IPs: ${BANNED_IPS}"

if [ $CACHE_SIZE_GB -gt 10 ]; then
    echo "⚠️  WARNING: Cache > 10G"
fi

if [ $BANNED_IPS -gt 5 ]; then
    echo "⚠️  WARNING: ${BANNED_IPS} IPs banned (possible attack)"
fi

Rendre exécutable :

sudo chmod +x /usr/local/bin/forgejo-health-check.sh

Ajouter au cron (tous les jours à 8h) :

sudo crontab -e

0 8 * * * /usr/local/bin/forgejo-health-check.sh | mail -s "Forgejo Health" admin@example.com

---

9. Cas pratiques

Cas 1 : Serveur personnel (peu de trafic)

Configuration recommandée :

• Fail2ban strict (maxretry=10, bantime=86400)
• Rate limiting Forgejo activé
• Cron de nettoyage toutes les 6h

Cas 2 : Serveur public (beaucoup de trafic légitime)

Configuration recommandée :

• Fail2ban modéré (maxretry=30, bantime=3600)
• Rate limiting Nginx (permet plus de flexibilité)
• Monitoring actif

Cas 3 : Serveur privé (équipe restreinte)

Configuration recommandée :

• Désactiver les archives publiques complètement
• Exiger l'authentification pour tout
• Fail2ban très strict

---

10. Diagnostic en cas de problème persistant

Si le disque se remplit encore :

# 1. Identifier les IP actives
docker logs forgejo --since 6h | grep "archive" | grep -oP '\d+\.\d+\.\d+\.\d+' | sort | uniq -c | sort -rn | head -5

# 2. Vérifier si Fail2ban a banni
sudo fail2ban-client status forgejo-archive

# 3. Vérifier l'âge des fichiers
find /home/debian/forgejo/data/gitea/repo-archive -type f -printf '%TY-%Tm-%Td %TH:%TM\n' | sort | tail -20

# 4. Bannir manuellement si nécessaire
sudo fail2ban-client set forgejo-archive banip IP_SUSPECTE

# 5. Nettoyage d'urgence
find /home/debian/forgejo/data/gitea/repo-archive -type f -delete

---

Ressources complémentaires

Documentation officielle :

• Forgejo Configuration: https://forgejo.org/docs/latest/admin/config-cheat-sheet/
• Fail2ban Manual: https://www.fail2ban.org/wiki/index.php/Main_Page
• Nginx Rate Limiting: https://www.nginx.com/blog/rate-limiting-nginx/

Outils utiles :

• goaccess : Analyseur de logs web en temps réel
• iptables : Firewall Linux
• htop : Monitoring des ressources

---

11. Guide de démarrage rapide (15 min chrono)

Pour ceux qui veulent appliquer la solution immédiatement sans lire tout le guide.

Étape 1 : Durcir Fail2ban (3 min)

# Éditer la config
sudo nano /etc/fail2ban/jail.d/forgejo.conf

Remplacer maxretry = 20 par maxretry = 8 et bantime = 3600 par bantime = 21600 :

[forgejo-archive]
enabled = true
filter = forgejo-archive
logpath = /var/lib/docker/containers/73485bb.../73485bb...-json.log
maxretry = 8
findtime = 600
bantime = 21600
bantime.increment = true
bantime.factor = 2
bantime.maxtime = 604800

# Redémarrer
sudo systemctl restart fail2ban
sudo fail2ban-client status forgejo-archive

Étape 2 : Configurer Forgejo (3 min)

nano /home/debian/forgejo/data/gitea/conf/app.ini

Modifier ces valeurs :

• RATE_LIMIT_BURST = 100 → RATE_LIMIT_BURST = 20
• ARCHIVE_EXPIRY = 604800 → ARCHIVE_EXPIRY = 3600

# Redémarrer
docker restart forgejo

Étape 3 : Améliorer le cron (2 min)

sudo crontab -e

Remplacer la ligne existante par :

0 */6 * * * find /home/debian/forgejo/data/gitea/repo-archive -type f -mmin +360 -delete

Étape 4 : Nettoyage initial (2 min)

# Voir la taille actuelle
du -sh /home/debian/forgejo/data/gitea/repo-archive

# Nettoyer
find /home/debian/forgejo/data/gitea/repo-archive -type f -delete

# Vérifier
du -sh /home/debian/forgejo/data/gitea/repo-archive

Étape 5 : Vérification (5 min)

# Check Fail2ban
sudo fail2ban-client status forgejo-archive

# Check cache (devrait être vide ou petit)
du -sh /home/debian/forgejo/data/gitea/repo-archive

# Check IP actives
docker logs forgejo --since 1h | grep "archive" | grep -oP '\d+\.\d+\.\d+\.\d+' | sort | uniq -c | sort -rn | head -5

Monitoring quotidien

Script de vérification quotidienne :

sudo nano /usr/local/bin/forgejo-check.sh

#!/bin/bash
echo "Cache: $(du -sh /home/debian/forgejo/data/gitea/repo-archive | cut -f1)"
echo "Banned: $(sudo fail2ban-client status forgejo-archive | grep "Currently banned" | awk '{print $4}')"
docker logs forgejo --since 24h | grep "archive" | wc -l | xargs echo "Archives (24h):"

sudo chmod +x /usr/local/bin/forgejo-check.sh
/usr/local/bin/forgejo-check.sh