Servere eksponert på internett mottar typisk 500–2000 brute-force-forsøk mot SSH hver dag. Uten automatisk beskyttelse er det bare et spørsmål om tid før en angriper gjetter riktig passord. Fail2ban er det mest brukte verktøyet på Linux for å stoppe slike angrep: det overvåker loggfiler i sanntid, gjenkjenner mislykkede innloggingsforsøk med regulære uttrykk, og blokkerer angriperen i brannmuren automatisk.

Denne guiden viser deg nøyaktig hvordan du installerer og konfigurerer Fail2ban på Ubuntu 22.04 og 24.04, beskytter SSH, Nginx og Apache, lager egne filtre, og verifiserer at alt virker, fra start til ferdig konfigurasjon på under 30 minutter.

Hva er Fail2ban og hvordan fungerer det?

Fail2ban er et Python-basert rammeverk for inntrengningsforebygging (IPS) som ble lansert i 2004 og er nå i versjon 1.1.0 (utgitt april 2024). Det kjører som en systemtjeneste og følger en enkel, men effektiv pipeline:

  1. Logglesing: Fail2ban leser utvalgte loggfiler kontinuerlig, for eksempel /var/log/auth.log for SSH og /var/log/nginx/error.log for Nginx.
  2. Regeksmatch: Hvert filter inneholder et eller flere regulære uttrykk (failregex) som matcher feilmeldinger i loggene. Angriperens IP-adresse identifiseres med plassholderen <ADDR> eller <HOST>.
  3. Terskelsjekk: Hvis en IP-adresse overskrider maxretry feil innenfor findtime sekunder, utløses en handling.
  4. Brannmurhandling: Fail2ban legger til en blokkregel i iptables, nftables eller UFW, slik at all trafikk fra angripende IP stoppes i bantime sekunder.

Fail2ban sitter ikke inline med trafikk og analyserer ikke pakker direkte. Det er en reaktiv løsning basert på logger, noe som betyr at ett eller flere innloggingsforsøk kan passere før blokkering. Dette er likevel tilstrekkelig for å stoppe automatiserte brute-force-angrep som vanligvis trenger hundrevis av forsøk.

Sentrale begreper og konfigurasjonsfiler

Fail2ban er organisert rundt tre kjernekonsepter: filtre, jails og handlinger. Et filter definerer hva som utgjør et mislykket forsøk via regulære uttrykk. En jail kobler et filter til en tjeneste, loggfil og handling. En handling definerer hva som skjer når en IP utestenges, typisk en brannmurregel.

ParameterStandardBeskrivelse
bantime10mHvor lenge en IP forblir blokkert. Bruk tidssuffiks: 10m, 1h, 1d.
findtime10mTidsvindu der feil telles. Feil utenfor dette vinduet ignoreres.
maxretry5Maks antall feil innenfor findtime før blokkering.
ignoreip127.0.0.1/8 ::1IP-adresser som aldri blokkeres. Legg til din egen IP her.
banactioniptables-multiportBrannmurhandling: iptables, nftables-multiport, ufw.
backendautoLogglesingsmekanisme: systemd, auto, pyinotify, polling.

Forutsetninger og systemkrav

Før du starter, kontroller at systemet oppfyller følgende krav:

  • Operativsystem: Ubuntu 22.04 LTS eller Ubuntu 24.04 LTS (også kompatibel med Debian 11 og Debian 12)
  • Tilgang: Root-bruker eller bruker med sudo-rettigheter
  • Python: Python 3.6 eller nyere (installeres automatisk som avhengighet)
  • Brannmur: iptables (standard på Ubuntu 22.04), nftables (standard på Ubuntu 24.04) eller UFW
  • Tjenester å beskytte: SSH (openssh-server), Nginx eller Apache (valgfritt)
  • Internettforbindelse: For å laste ned pakker via apt

Kontroller brannmurbakend med sudo iptables -V for iptables eller sudo nft --version for nftables. Ubuntu 24.04 bruker som standard nftables, mens 22.04 bruker iptables. Dette påvirker hvilken banaction du velger i konfigurasjonsfilen.

Steg 1: Installer Fail2ban

Fail2ban er tilgjengelig i Ubuntus offisielle pakkearkiv. Oppdater pakkelisten og installer:

sudo apt update
sudo apt install -y fail2ban
sudo systemctl enable --now fail2ban
sudo systemctl status fail2ban

Forventet utdata fra systemctl status:

● fail2ban.service - Fail2Ban Service
     Loaded: loaded (/lib/systemd/system/fail2ban.service; enabled)
     Active: active (running) since Sat 2026-06-21 10:00:00 UTC; 5s ago
    Process: ExecStartPre=/bin/mkdir -p /run/fail2ban
   Main PID: 12345 (fail2ban-server)
      Tasks: 5 (limit: 4608)
     Memory: 12.3M

Verifiser versjonen med fail2ban-client --version. Du skal se Fail2Ban v1.1.0 eller nyere. Fail2ban installerer automatisk fail2ban-client (kommandolinjeverktøy) og fail2ban-server (bakgrunnstjenesten).

Vanlig feil nr. 1: Fail2ban starter ikke hvis iptables ikke er tilgjengelig på Ubuntu 24.04 med kun nftables. Løsning: installer iptables-legacy med sudo apt install -y iptables, eller endre banaction til nftables-multiport i konfigurasjonen (se Steg 2).

Steg 2: Opprett jail.local

Fail2ban leveres med to primære konfigurasjonsfiler: /etc/fail2ban/jail.conf (standard, overskrives ved oppgradering) og /etc/fail2ban/jail.local (dine innstillinger, aldri overskrives). Du skal aldri redigere jail.conf direkte. Kopier den i stedet som basis:

sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local
sudo nano /etc/fail2ban/jail.local

Finn [DEFAULT]-seksjonen og tilpass følgende innstillinger:

[DEFAULT]
# Ban i 24 timer
bantime  = 24h

# Tidsvindu: tell feil innenfor 10 minutter
findtime = 10m

# Maks 5 feil før blokkering
maxretry = 5

# Ignorer lokal IP og din statiske IP (viktig for å unngå å låse deg ut)
ignoreip = 127.0.0.1/8 ::1 DIN_IP_HER

# Velg brannmurbakend (Ubuntu 22.04: iptables-multiport, Ubuntu 24.04: nftables-multiport)
banaction = iptables-multiport
# For nftables: banaction = nftables-multiport

# Backend for logglesing (auto velger beste tilgjengelig)
backend = auto

Finn din offentlige IP med curl ifconfig.me og legg den til i ignoreip. Dette er avgjørende: hvis du glemmer dette og konfigurerer aggressiv blokkering, kan du låse deg selv ute fra serveren.

Valider konfigurasjonen etter hver endring:

# Test konfigurasjon for syntaksfeil
sudo fail2ban-client -t

# Last inn ny konfigurasjon uten omstart
sudo fail2ban-client reload

Vanlig feil nr. 2: Mange administratorer setter bantime = -1 for permanent blokkering uten å tenke på konsekvensene. Én feilkonfigurert legitim tjeneste (f.eks. et skript som kjører med feil passord) kan permanent blokkere bedriftens IP-adresse. Bruk heller bantime.increment = true for automatisk eskalering: første gang 10 minutter, andre gang 1 time, tredje gang 1 dag.

Steg 3: Beskytt SSH med Fail2ban

SSH er det vanligste angrepsmålet på Linux-servere. Fail2ban inkluderer et ferdig sshd-filter, men du bør lage en dedikert jail-konfigurasjon for klarhet og enklere vedlikehold:

sudo nano /etc/fail2ban/jail.d/sshd.local

Lim inn følgende:

[sshd]
enabled  = true
port     = ssh
filter   = sshd
# På Ubuntu/Debian brukes /var/log/auth.log
logpath  = /var/log/auth.log
maxretry = 3
bantime  = 24h
findtime = 10m

Lagre og last inn på nytt:

sudo fail2ban-client -t
sudo fail2ban-client reload
sudo fail2ban-client status sshd

Forventet utdata fra status sshd:

Status for the jail: sshd
|- Filter
|  |- Currently failed: 2
|  |- Total failed: 47
|  `- File list: /var/log/auth.log
`- Actions
   |- Currently banned: 1
   |- Total banned: 8
   `- Banned IP list: 185.220.101.45

Hvis du kjører SSH på en ikke-standard port (f.eks. 2222), oppdater port = 2222 i jail-konfigurasjonen. Fail2ban vil da blokkere den spesifikke porten.

Vanlig feil nr. 3: På Ubuntu 22.04 og nyere med systemd bruker SSH journald i stedet for /var/log/auth.log. Hvis logfilen er tom eller ikke finnes, sett backend = systemd og fjern logpath fra jail-konfigurasjonen. Alternativt, sørg for at rsyslog er installert: sudo apt install -y rsyslog.

Steg 4: Beskytt Nginx med Fail2ban

Nginx leveres med innebygde Fail2ban-filtre for autentiseringsfeil og rate-limiting-brudd. Opprett en dedikert Nginx jail:

sudo nano /etc/fail2ban/jail.d/nginx.local
[nginx-http-auth]
enabled  = true
port     = http,https
filter   = nginx-http-auth
logpath  = /var/log/nginx/error.log
maxretry = 5
bantime  = 1h

[nginx-limit-req]
enabled  = true
port     = http,https
filter   = nginx-limit-req
logpath  = /var/log/nginx/error.log
maxretry = 10
bantime  = 30m

[nginx-botsearch]
enabled  = true
port     = http,https
filter   = nginx-botsearch
logpath  = /var/log/nginx/access.log
maxretry = 2
bantime  = 24h

Filteret nginx-http-auth blokkerer IP-adresser som mislykkes med HTTP Basic Auth. nginx-limit-req fanger opp klienter som overskrider din Nginx rate-limit-sone (konfigurert med limit_req_zone i Nginx). nginx-botsearch blokkerer skannere som leter etter kjente sårbare stier som /wp-login.php eller /.env.

Verifiser at filterfilene eksisterer:

ls /etc/fail2ban/filter.d/nginx*

Vanlig feil nr. 4: Filterfilene nginx-limit-req.conf og nginx-botsearch.conf mangler i noen Fail2ban-installasjoner. Sjekk med ls /etc/fail2ban/filter.d/nginx*. Hvis de mangler, last dem ned fra Fail2ban GitHub-repositoriet og kopier til /etc/fail2ban/filter.d/.

Steg 5: Beskytt Apache med Fail2ban

Apache-beskyttelse ligner på Nginx, men bruker andre filterfilnavn. Fail2ban inkluderer ferdige filtre for de vanligste Apache-angrepsmønstrene:

sudo nano /etc/fail2ban/jail.d/apache.local
[apache-auth]
enabled  = true
port     = http,https
filter   = apache-auth
logpath  = /var/log/apache2/*error.log
maxretry = 5
bantime  = 1h

[apache-badbots]
enabled  = true
port     = http,https
filter   = apache-badbots
logpath  = /var/log/apache2/*access.log
maxretry = 2
bantime  = 24h

[apache-noscript]
enabled  = true
port     = http,https
filter   = apache-noscript
logpath  = /var/log/apache2/*error.log
maxretry = 6
bantime  = 2h

[apache-overflows]
enabled  = true
port     = http,https
filter   = apache-overflows
logpath  = /var/log/apache2/*error.log
maxretry = 2
bantime  = 24h

apache-badbots bruker en liste over kjente ondsinnede bot-signaturer definert i /etc/fail2ban/filter.d/apache-badbots.conf. Filen inneholder regulære uttrykk for hundrevis av kjente skannerverktøy. apache-overflows blokkerer IP-er som prøver bufferoverflytsangrep mot Apache-moduler.

Steg 6: Lag et egendefinert filter

Egendefinerte filtre er nødvendige for applikasjoner som ikke har innebygde Fail2ban-filtre. Her er et eksempel med en Node.js API som logger mislykkede autentiseringsforsøk på følgende format:

# Typisk loggformat fra en Node.js-applikasjon:
2026-06-21T10:23:45.123Z [ERROR] Authentication failed for user 'admin' from IP 192.168.1.50
2026-06-21T10:23:46.456Z [ERROR] Authentication failed for user 'root' from IP 192.168.1.50

Opprett filterdefinisjonen:

sudo nano /etc/fail2ban/filter.d/nodeapp.conf
[Definition]
# Matcher "Authentication failed ... from IP <IP>"
failregex = ^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d+Z \[ERROR\] Authentication failed .* from IP <ADDR>$

# Ingen unntak
ignoreregex =

Test filteret mot loggfilen:

# Test filter mot en loggfil
sudo fail2ban-regex /var/log/myapp/error.log /etc/fail2ban/filter.d/nodeapp.conf

# Forventet utdata:
# Lines:   245 lines, 0 ignored, 47 matched, 198 missed

Opprett deretter jail-konfigurasjonen:

sudo nano /etc/fail2ban/jail.d/nodeapp.local
[nodeapp]
enabled  = true
port     = http,https
filter   = nodeapp
logpath  = /var/log/myapp/error.log
maxretry = 5
bantime  = 2h
findtime = 10m

Vanlig feil nr. 5: Regulære uttrykk i failregex er svært sensitive for formateringsfeil. Bruk alltid fail2ban-regex til å teste filteret mot faktiske logglinjer før du aktiverer jailen. En feil i regeksen gir null treff og dermed ingen beskyttelse, uten at Fail2ban rapporterer noen feil.

Steg 7: Konfigurer e-postvarsler

Fail2ban kan sende e-postvarsler når en IP blokkeres. Dette krever at sendmail eller en SMTP-tjeneste er konfigurert på serveren.

sudo apt install -y mailutils sendmail

Legg til følgende i [DEFAULT]-seksjonen i /etc/fail2ban/jail.local:

[DEFAULT]
# ... eksisterende innstillinger ...

# E-postvarsler
destemail = [email protected]
sender    = [email protected]
mta       = sendmail

# action_mwl = ban + send e-post med whois og logglinjer
action = %(action_mwl)s

Tilgjengelige handlingstyper:

HandlingBeskrivelse
%(action_)sKun blokkering, ingen e-post
%(action_mw)sBlokkering pluss e-post med whois-info
%(action_mwl)sBlokkering pluss e-post med whois og relevante logglinjer
%(action_cf_mwl)sBlokkering pluss Cloudflare-ban pluss e-post med whois og logg

For de fleste produksjonsmiljøer anbefales %(action_mwl)s for viktige jails (SSH) og enkel %(action_)s for jails med høy volum (web-bots) for å unngå e-postflom.

Steg 8: Administrer og overvåk baner

Fail2ban-client er ditt primære administrasjonsverktøy. De viktigste kommandoene:

# Vis alle aktive jails og statistikk
sudo fail2ban-client status

# Detaljert status for en spesifikk jail
sudo fail2ban-client status sshd

# Fjern blokkering av en IP-adresse
sudo fail2ban-client set sshd unbanip 192.168.1.100

# Blokker en IP manuelt
sudo fail2ban-client set sshd banip 203.0.113.45

# Test konfigurasjonssyntaks
sudo fail2ban-client -t

# Last inn endringer uten omstart
sudo fail2ban-client reload

# Last inn kun én jail på nytt
sudo fail2ban-client reload sshd

# Vis alle blokkerte IP-er på tvers av alle jails
sudo fail2ban-client status | grep "Jail list:" | sed "s/.*Jail list:\s*//" | tr "," "\n" | xargs -I{} sudo fail2ban-client status {} | grep "Banned IP"

Fail2ban-loggen gir nyttig innsikt i hva som skjer:

# Følg Fail2ban-loggen i sanntid
sudo tail -f /var/log/fail2ban.log

# Vis kun blokkeringshendelser
sudo grep "Ban " /var/log/fail2ban.log | tail -50

Typisk loggutskrift:

2026-06-21 10:23:47,891 fail2ban.filter[12345]: INFO    [sshd] Found 185.220.101.45
2026-06-21 10:23:52,234 fail2ban.filter[12345]: INFO    [sshd] Found 185.220.101.45
2026-06-21 10:23:55,678 fail2ban.filter[12345]: INFO    [sshd] Found 185.220.101.45
2026-06-21 10:23:55,701 fail2ban.actions[12345]: NOTICE  [sshd] Ban 185.220.101.45

Steg 9: Integrasjon med UFW og nftables

Ubuntu bruker ofte UFW (Uncomplicated Firewall) som et brukervennlig grensesnitt mot iptables eller nftables. Fail2ban kan integreres med UFW ved å sette banaction = ufw.

UFW-integrasjon

Kontroller at UFW er aktivt:

sudo ufw status verbose

Konfigurer Fail2ban til å bruke UFW som bakend. Legg til i /etc/fail2ban/jail.local:

[DEFAULT]
banaction = ufw
banaction_allports = ufw

For nftables på Ubuntu 24.04:

[DEFAULT]
banaction = nftables-multiport
banaction_allports = nftables-allports

Inkrementell bantime

En svært nyttig funksjon i Fail2ban er inkrementell bantime: gjentatte overtredere blokkeres stadig lenger. Aktiver dette i jail.local:

[DEFAULT]
# Aktiver inkrementell ban
bantime.increment = true

# Grunnverdi for første ban
bantime.factor = 1

# Multiplikator: hvert nytt brudd dobler bantime (1h, 2h, 4h, 8h...)
bantime.multiplier = 2

# Maks ban: 4 uker
bantime.maxtime = 4w

# Tilgivelse: glem historikk etter 1 uke uten ny overtredelse
bantime.rndtime = 1w

Med disse innstillingene blokkeres en angriper første gang i 1 time, andre gang i 2 timer, tredje gang i 4 timer, og så videre opp til maksimalt 4 uker. Dette er langt mer effektivt enn en fast bantime og stopper hardnakkede angripere automatisk.

Steg 10: Recidive-jail for gjentatte overtredere

recidive er en spesiell jail som overvåker Fail2bans egen logg og blokkerer IP-er som utestenges igjen og igjen fra flere forskjellige jails. Det fungerer som et overordnet lag med beskyttelse mot de mest hardnakkede angriperne.

sudo nano /etc/fail2ban/jail.d/recidive.local
[recidive]
enabled   = true
filter    = recidive
logpath   = /var/log/fail2ban.log
# Blokker i 1 uke
bantime   = 1w
findtime  = 1d
# Blokker etter 3 utestengninger fra andre jails innen 1 dag
maxretry  = 3
# Blokker alle porter, ikke bare én
banaction = iptables-allports

Med denne konfigurasjonen: en angriper som utløser 3 forskjellige jails på én dag, blokkeres fullstendig fra serveren i én uke via iptables-allports. Dette er særlig effektivt mot automatiserte botnet-angrep som skanner etter mange forskjellige sårbarheter.

Vanlig feil nr. 6: Recidive-jailen krever at logpath peker på Fail2bans loggfil, ikke systemloggen. Bekreft stien med sudo fail2ban-client get logtarget. Standardstien er /var/log/fail2ban.log, men dette kan variere basert på konfigurasjon.

Steg 11: Test og verifiser konfigurasjonen

Testing av Fail2ban er kritisk for å bekrefte at filtre fungerer korrekt og at du ikke har konfigurert noe som kan blokkere legitim trafikk.

Test at SSH-jailens filter faktisk matcher feil i loggfilen:

# Test sshd-filter mot auth.log
sudo fail2ban-regex /var/log/auth.log /etc/fail2ban/filter.d/sshd.conf

# Forventet utdata (antall matcher varierer):
# Lines:   5892 lines, 0 ignored, 234 matched, 5658 missed
# Failregex: 234 total

For å simulere et SSH brute-force-angrep (fra en annen maskin for å ikke blokkere deg selv):

# Fra en annen maskin eller VM (ALDRI fra din egen IP):
for i in {1..5}; do ssh feil_bruker@SERVER_IP; done

# Sjekk deretter om IP er blokkert:
sudo fail2ban-client status sshd

Sjekk at brannmurreglene faktisk er lagt til:

# For iptables
sudo iptables -L f2b-sshd -n --line-numbers

# For nftables
sudo nft list ruleset | grep fail2ban

# For UFW
sudo ufw status numbered | grep DENY

Steg 12: Automatisert vedlikehold og loggrotasjon

Fail2ban-loggen kan vokse raskt på en server med mye angrepsaktivitet. Ubuntu bruker logrotate for å administrere dette automatisk. Kontroller at Fail2bans logrotate-konfigurasjon er på plass:

cat /etc/logrotate.d/fail2ban

Forventet innhold:

/var/log/fail2ban.log {
    weekly
    rotate 4
    compress
    delaycompress
    missingok
    postrotate
        fail2ban-client flushlogs 1>/dev/null
    endscript
    create 640 root adm
}

For å aktivere persistens av baner på tvers av omstarter, legg til disse linjene i [DEFAULT]-seksjonen i jail.local:

[DEFAULT]
# Lagre banhistorikk i SQLite-database
dbfile = /var/lib/fail2ban/fail2ban.sqlite3

# Rens baner eldre enn 7 dager fra databasen
dbpurgeage = 7d

Med denne innstillingen vil aktive baner overleve en serveromstart. Dette er viktig for produksjonsservere der angriperne bør forbli blokkert selv etter planlagte vedlikeholdsomstarter.

Overvåk topp 10 mest blokkerte IP-er:

# Vis topp 10 mest blokkerte IP-er fra loggen
sudo grep "Ban " /var/log/fail2ban.log | awk '{print $NF}' | sort | uniq -c | sort -rn | head -10

Vanlige feil og feilsøking

Her er de 10 vanligste problemene med Fail2ban og løsningene:

ProblemÅrsakLøsning
Fail2ban starter ikkeiptables ikke tilgjengelig eller Python-feilSjekk journalctl -u fail2ban -n 50. Installer iptables eller bytt til nftables-multiport.
Jail aktiveres ikkeenabled = true mangler eller konfigurasjonsfeilKjør fail2ban-client -t for å finne syntaksfeil. Sjekk at enabled = true er satt.
Filter matcher ingentingFeil loggfilsti eller feil regeks-formatBruk fail2ban-regex /sti/til/log /etc/fail2ban/filter.d/filter.conf for å debugge.
Egen IP blokkertignoreip ikke konfigurertKjør fail2ban-client set JAIL unbanip DIN_IP umiddelbart. Legg IP i ignoreip.
Loggfil for SSH er tomUbuntu bruker journald, ikke syslogSett backend = systemd i sshd-jailen og fjern logpath.
IP blokkeres ikke til tross for mange feilFeil loggfilsti eller loggen er tomBekreft at loggfilen har innhold: tail -100 /var/log/auth.log.
Fail2ban bruker for mye CPUFor mange jails med høy polling-frekvensBruk backend = systemd i stedet for polling. Deaktiver ubrukte jails.
Banregler forsvinner etter omstartPersistens ikke aktivertSett dbfile = /var/lib/fail2ban/fail2ban.sqlite3 i jail.local.
E-postvarsler sendes ikkesendmail ikke installert eller feil konfigurasjonTest med echo "test" | mail -s "test" [email protected]. Installer mailutils.
Cloudflare-IP blokkeresReverse proxy sender CDN-IP, ikke angriperens IPAktiver real_ip_module i Nginx med Cloudflares IP-rekkevidder i set_real_ip_from.

Vanlig feil nr. 7: Mange glemmer å legge til CDN-IP-adresser i ignoreip. Hvis du bruker Cloudflare, Nginx som reverse proxy eller en load balancer, vil Fail2ban se proxy-IPen og blokkere den i stedet for angriperens reelle IP. For Nginx: aktiver real_ip_module og sett set_real_ip_from til Cloudflares IP-rekkevidder i Nginx-konfigurasjonen.

Vanlig feil nr. 8: Fail2ban baner persisteres ikke som standard mellom omstarter. Etter en serveromstart forsvinner alle aktive baner. For å aktivere persistens, legg til dbfile = /var/lib/fail2ban/fail2ban.sqlite3 og dbpurgeage = 7d i [DEFAULT]-seksjonen.

Avanserte tips og optimalisering

Geografisk blokkering med ipset

Fail2ban blokkerer individuelle IP-adresser. For å blokkere hele geografiske regioner kan du kombinere Fail2ban med ipset:

sudo apt install -y ipset

# Opprett et ipset-sett
sudo ipset create blockedcountries hash:net

# Eksempel: hent IP-rekkevidder og legg til i settet
# (erstatt cn.zone med ønsket land fra ipdeny.com)
curl -s https://www.ipdeny.com/ipblocks/data/countries/cn.zone | \
  sudo xargs -I{} ipset add blockedcountries {} 2>/dev/null

# Blokker med iptables
sudo iptables -I INPUT -m set --match-set blockedcountries src -j DROP

# Gjør permanent ved å lagre ipset-regler
sudo ipset save > /etc/ipset.rules

CrowdSec som komplement til Fail2ban

CrowdSec er et samarbeidsbasert IPS-system der blokkeringsavgjørelser deles mellom tusenvis av servere globalt. En IP som angriper én server på CrowdSec-nettverket, blokkeres automatisk på alle andre servere i nettverket. Red Hat anbefaler å kombinere Fail2ban og CrowdSec for best mulig beskyttelse:

  • Fail2ban: Lokalt, reaktivt, basert på dine egne logger. Null avhengigheter til tredjeparter.
  • CrowdSec: Globalt trusselinformasjonsnettverk, blokkerer kjente ondsinnede IP-er proaktivt.
  • Kombinasjon: Fail2ban fanger lokale brute-force-mønstre. CrowdSec blokkerer kjente angripere fra globale databaser.

Ytterligere herdingstips for produksjonsmiljøer:

  • Bruk maxretry = 3 for SSH: 5 er for høyt. 3 feil er nok for en menneskelig bruker som tastet inn feil passord, men eliminerer automatiserte angrep.
  • Bytt SSH-port fra 22: Dette alene reduserer antall brute-force-forsøk med 95%. Fail2ban håndterer resten.
  • Aktiver SSH-nøkkelautentisering: Deaktiver passordinnlogging med PasswordAuthentication no i /etc/ssh/sshd_config. Fail2ban er da et ekstra forsvarslag, ikke eneste forsvar.
  • Kombiner med OWASP-sikkerhetsretningslinjer: For webapplikasjoner, bruk WAF og sikkerhetshoder i tillegg til Fail2ban.

Ytelse og overvåkning

Fail2ban er generelt svært lett på systemressurser. En typisk konfigurasjon med 10 aktive jails bruker under 30 MB RAM og under 1% CPU på en moderne server. Overvåk ressursbruken med:

# Vis fail2ban-serverens ressursbruk
ps aux | grep fail2ban

# Aggregert statistikk over alle jails
sudo fail2ban-client status | grep "Jail list:" | \
  sed "s/.*Jail list:\s*//" | tr "," "\n" | \
  while read jail; do
    banned=$(sudo fail2ban-client status "$jail" 2>/dev/null | grep "Total banned" | awk '{print $NF}')
    echo "$jail: $banned totalt blokkert"
  done
OvervåkningsmetrikkKildeVerktøy
Aktive baner per jailfail2ban-client status JAILCLI, Prometheus
Totalt antall baner (historisk)/var/log/fail2ban.loggrep, awk, Graylog
Topp angripende IP-erfail2ban.logawk, sort, uniq
Brannmurregleriptables eller nftablesiptables -L, nft list
Fail2ban ressursbruksystemd, pstop, htop, Prometheus node_exporter

Relatert dekning

Les mer

Ofte stilte spørsmål

Blokkerer Fail2ban angripere permanent?

Nei, som standard blokkerer Fail2ban for en tidsbegrenset periode definert av bantime. Du kan sette bantime = -1 for permanent blokkering, men dette anbefales ikke uten inkrementell bantime (bantime.increment = true) eller manuell gjennomgang. Recidive-jailen er en bedre tilnærming for å håndtere gjentatte overtredere over lengre tid uten risiko for å permanent blokkere legitime brukere.

Hva er forskjellen mellom Fail2ban og en WAF?

Fail2ban er en loggbasert IPS som reagerer etter at mislykkede forsøk er logget. En Web Application Firewall (WAF) som ModSecurity eller Cloudflare WAF inspiserer HTTP-trafikk inline og blokkerer ondsinnede forespørsler før de når applikasjonen. De to er komplementære: en WAF er mer proaktiv og filtrerer på lag 7, mens Fail2ban er et andrelagsforsvar som fanger mønstre over tid.

Kan Fail2ban brukes med Docker-containere?

Ja, men med forbehold. Fail2ban kjører på verts-OS-nivå og leser loggfiler fra verts-filsystemet. For Docker-containere må du enten montere containerloggene på verts-filsystemet, eller bruke Dockers log driver til å skrive til en fil som Fail2ban kan lese. Alternativt kan du kjøre Fail2ban inne i en privilegert container med tilgang til vertsnettverket, selv om dette ikke anbefales sikkerhetsmessig.

Hva er forskjellen mellom Fail2ban og CrowdSec?

Fail2ban er lokalt og reaktivt: det lærer av din servers egne logger. CrowdSec er et samarbeidsbasert IPS-system der blokkeringsavgjørelser deles mellom tusenvis av servere globalt. En IP som angriper én server på CrowdSec-nettverket, kan automatisk blokkeres av alle andre servere i nettverket. CrowdSec har en gratis community-plan, og de to verktøyene kan brukes side om side for best mulig dekning.

Kan Fail2ban hindre DDoS-angrep?

Nei, Fail2ban er ikke designet for distribuerte tjenestenektangrep. Det er effektivt mot angrep fra én eller noen få IP-adresser, men et volumetrisk DDoS-angrep fra hundretusenvis av IP-er vil overbelaste serveren lenge før Fail2ban rekker å blokkere dem. For DDoS-beskyttelse trenger du dedikerte løsninger som Cloudflare DDoS Protection eller AWS Shield.

Hva gjør jeg hvis jeg låser meg selv ute?

Hvis du blokkerer din egen IP, har du to alternativer: (1) Logg inn via serverkonsoll (KVM, IPMI eller VPS-konsoll) og kjør sudo fail2ban-client set sshd unbanip DIN_IP. (2) Vent til bantime utløper. For å unngå dette i fremtiden: legg alltid til din IP i ignoreip i jail.local og bekreft med fail2ban-client -t før du gjør aggressive konfigurasjonsendringer.

Bør jeg bruke Fail2ban alene for å sikre SSH?

Nei. Fail2ban er ett lag i en dybdebeskyttelsesstrategi. For SSH anbefales disse tiltakene i prioritert rekkefølge: (1) Bytt SSH til en ikke-standard port. (2) Aktiver SSH-nøkkelautentisering og deaktiver passordinnlogging med PasswordAuthentication no. (3) Begrens hvem som kan logge inn med AllowUsers eller AllowGroups. (4) Aktiver Fail2ban som bakgrunnsbeskyttelse. Med de tre første tiltakene på plass er brute-force-risikoen allerede dramatisk redusert, og Fail2ban er det siste sikkerhetsnettet.

Fungerer Fail2ban med IPv6?

Ja, Fail2ban støtter fullt ut IPv6. Kontroller at iptables6 (ip6tables) eller nftables er installert. For UFW-brukere håndteres IPv6 automatisk. Sørg for at ignoreip inkluderer IPv6-loopback-adressen ::1 i tillegg til 127.0.0.1/8, noe som er standard. For å se IPv6-baner: sudo ip6tables -L f2b-sshd -n.