Skip to main content

NGINX Allow Deny: Vollständiger Leitfaden für IP-Whitelists und -Blacklists

Dieser Artikel ist eine Übersetzung des englischen Originals.


Die NGINX-Direktiven allow und deny sind unverzichtbare Werkzeuge, um den Zugriff auf Ihren Webserver nach IP-Adresse zu steuern. Ob Sie eine IP-Whitelist für Admin-Bereiche erstellen oder böswillige Akteure auf eine Blacklist setzen möchten – das Verständnis der Funktionsweise von NGINX allow deny-Regeln ist entscheidend für die Serversicherheit.

Dieser umfassende Leitfaden behandelt alles, was Sie über die NGINX allow deny-Konfiguration wissen müssen, einschließlich CIDR-Notation für Netzwerkbereiche, des leistungsstarken geo-Moduls für große IP-Listen und praxisnaher Beispiele mit getesteten Konfigurationen, die mit Gixy verifiziert wurden, dem Sicherheitsanalysator für NGINX-Konfigurationen.

Die NGINX-Direktiven allow und deny verstehen

Die Direktiven allow und deny sind Teil von NGINXs ngx_http_access_module, das standardmäßig in NGINX einkompiliert ist. Diese NGINX allow deny-Direktiven steuern, ob eine Client-IP-Adresse auf einen bestimmten Location-Block zugreifen darf.

Grundlegende Syntax

allow address | CIDR | unix: | all;
deny address | CIDR | unix: | all;

Die Direktiven akzeptieren:

  • Einzelne IP-Adresse: 192.168.1.100
  • CIDR-Notation: 192.168.1.0/24 (umfasst 192.168.1.0 bis 192.168.1.255)
  • unix:: Entspricht Verbindungen über UNIX-Domain-Sockets
  • all: Entspricht jeder IP-Adresse

Kontext

Diese Direktiven können verwendet werden in:

  • http-Block (gilt global)
  • server-Block (gilt für den virtuellen Host)
  • location-Block (gilt für bestimmte URLs)
  • limit_except-Block (gilt für bestimmte HTTP-Methoden)

Wie NGINX Allow-Deny-Regeln auswertet

Das Verständnis der Auswertungsreihenfolge ist entscheidend für eine korrekte NGINX allow deny-Konfiguration. NGINX verarbeitet allow- und deny-Regeln in der Reihenfolge ihres Auftretens, und Die erste passende Regel gewinnt.

location /admin {
    allow 192.168.1.0/24;    # Rule 1: Allow office network
    allow 10.8.0.0/24;       # Rule 2: Allow VPN range
    deny all;                # Rule 3: Deny everyone else
}

Für eine Anfrage von 192.168.1.50:

  1. Regel 1 prüfen: Entspricht 192.168.1.50 dem Bereich 192.168.1.0/24? Ja → Zugriff erlauben
  2. Regeln 2 und 3 werden nie ausgewertet

Für eine Anfrage von 203.0.113.10:

  1. Regel 1 prüfen: Entspricht 203.0.113.10 dem Bereich 192.168.1.0/24? Nein
  2. Regel 2 prüfen: Entspricht 203.0.113.10 dem Bereich 10.8.0.0/24? Nein
  3. Regel 3 prüfen: Entspricht 203.0.113.10 dem Wert all? Ja → Zugriff verweigern (HTTP 403)

Standardverhalten ohne deny all

Ein häufiger Fehler bei der Konfiguration von NGINX allow deny-Regeln ist das Vergessen der Direktive deny all am Ende einer Whitelist:

# WRONG - Missing deny all!
location /admin {
    allow 192.168.1.0/24;
    allow 10.8.0.0/24;
    # No deny all - non-matching IPs are ALLOWED!
}

Wenn keine Regel passt, gibt NGINX intern NGX_DECLINED zurück, was bedeutet, dass die Anfrage normal weiterläuft. Fügen Sie immer deny all; am Ende einer Whitelist-Konfiguration hinzu.

Der Sicherheitsanalysator Gixy meldet dies als Problem mit Der Schweregrad HOCH:

Problem: [allow_without_deny] Found allow directive(s) without deny in the same context.
Severity: HIGH
Reason: You probably want "deny all;" after all the "allow" directives

Sie können Ihre Konfigurationen mit Gixy überprüfen (verfügbar aus dem GetPageSpeed-Repository):

sudo dnf install https://extras.getpagespeed.com/release-latest.rpm
sudo dnf install gixy
gixy /etc/nginx/nginx.conf

CIDR-Notation erklärt

Die CIDR-Notation (Classless Inter-Domain Routing) gibt IP-Bereiche effizient an. Das Format ist IP/prefix_length, wobei die Präfixlänge angibt, wie viele Bits den Netzwerkanteil definieren.

Häufige CIDR-Präfixlängen

CIDR Subnetzmaske Anzahl der IPs Beispielbereich
/32 255.255.255.255 1 DNur eine einzelne IP
/24 255.255.255.0 256 192.168.1.0 – 192.168.1.255
/16 255.255.0.0 65.536 192.168.0.0 – 192.168.255.255
/8 255.0.0.0 16.777.216 10.0.0.0 – 10.255.255.255

Private Netzwerkbereiche

Diese CIDR-Blöcke werden häufig in internen Netzwerken verwendet:

# RFC 1918 private address ranges
allow 10.0.0.0/8;        # 10.0.0.0 - 10.255.255.255
allow 172.16.0.0/12;     # 172.16.0.0 - 172.31.255.255
allow 192.168.0.0/16;    # 192.168.0.0 - 192.168.255.255

# Localhost
allow 127.0.0.0/8;       # 127.0.0.0 - 127.255.255.255

CIDR-Validierungswarnung

NGINX prüft, ob Ihre CIDR-Notation sinnvoll ist. Wenn Sie Host-Bits angeben, die maskiert würden, gibt NGINX eine Warnung aus:

nginx: [warn] low address bits of 192.168.1.50/24 are meaningless

Diese Warnung bedeutet, dass Sie 192.168.1.50/24 geschrieben haben, obwohl Sie wahrscheinlich 192.168.1.0/24 meinten. Die Maske /24 setzt das letzte Oktett auf null, sodass die .50 ignoriert wird. NGINX akzeptiert die Konfiguration, aber die Warnung hilft, Fehler zu erkennen.

Erstellen einer NGINX-IP-Whitelist

Eine NGINX-IP-Whitelist erlaubt nur bestimmte Adressen und blockiert alle anderen. Dies ist der sicherste Ansatz zum Schutz von Admin-Oberflächen.

Basis-Whitelist für Admin-Bereiche

server {
    listen 80;
    server_name example.com;
    root /var/www/html;
    server_tokens off;  # Hide NGINX version

    # Protect admin area - whitelist only
    location /admin {
        # Office network
        allow 192.168.1.0/24;

        # VPN range
        allow 10.8.0.0/24;

        # Specific remote worker IP
        allow 203.0.113.50;

        # Block everyone else
        deny all;

        try_files $uri $uri/ /admin/index.php?$args;
    }

    location / {
        try_files $uri $uri/ /index.php?$args;
    }
}

NGINX-Whitelist-IP über externe Datei

Zur einfacheren Wartung können Sie Ihre erlaubten IPs in einer separaten Datei speichern:

# /etc/nginx/conf.d/site.conf
location /admin {
    include /etc/nginx/allowlist.conf;
    deny all;

    try_files $uri $uri/ /admin/index.php?$args;
}
# /etc/nginx/allowlist.conf
# Office network
allow 192.168.1.0/24;

# VPN range
allow 10.8.0.0/24;

# Remote workers
allow 203.0.113.50;   # Alice
allow 198.51.100.75;  # Bob

# Localhost for CLI access
allow 127.0.0.1;
allow ::1;

Nach dem Ändern der Allowlist-Datei laden Sie NGINX neu:

nginx -t && systemctl reload nginx

Erstellen einer IP-Blacklist

Eine NGINX-Blacklist blockiert bestimmte Adressen und erlaubt allen anderen den Zugriff. Dies ist nützlich, um bekannte Angreifer zu blockieren.

Basis-Blacklist

location / {
    # Block known bad IPs
    deny 192.168.100.1;
    deny 192.168.100.2;

    # Block entire problematic subnet
    deny 10.99.0.0/24;

    # Allow everyone else
    allow all;

    try_files $uri $uri/ /index.php?$args;
}

Die Reihenfolge ist wichtig für Ausnahmen

Sie können Ausnahmen innerhalb einer Blacklist erstellen, indem Sie spezifische Allows vor breiteren Denies platzieren:

location / {
    # Allow this specific IP even though its subnet is blocked
    allow 192.168.100.10;

    # Block the rest of the subnet
    deny 192.168.100.0/24;

    # Allow everyone else
    allow all;
}

IPv6-Unterstützung

NGINX unterstützt IPv6-Adressen in den Direktiven allow und deny vollständig:

location /admin {
    # IPv4
    allow 192.168.1.0/24;

    # IPv6 localhost
    allow ::1;

    # IPv6 private range (Unique Local Address)
    allow fd00::/8;

    # IPv6 link-local
    allow fe80::/10;

    # Specific IPv6 address
    allow 2001:db8::1;

    # IPv6 subnet
    allow 2001:db8::/32;

    deny all;
}

Wenn Clients über IPv6 verbinden, Ihr Server aber auch eine IPv4-Adresse hat, stellen Sie sicher, dass Sie sowohl die IPv4- als auch die IPv6-Version der erlaubten Adressen angeben.

Das Geo-Modul für große IP-Listen

Bei der Verwaltung von Tausenden von IP-Adressen wird der NGINX-Ansatz mit allow und deny ineffizient. NGINX wertet Regeln sequenziell aus, sodass eine Liste mit 10.000 IPs bis zu 10.000 Vergleiche pro Anfrage bedeutet.

Das Modul geo löst dies mit optimierten Datenstrukturen. Es ordnet IP-Adressen Variablen zu, entweder über einen Radix-Baum (für CIDR-Notation) oder eine zweistufige Lookup-Tabelle (für IP-Bereiche), die beide Lookups mit nahezu konstanter Zeit ermöglichen.

Basis-Geo-Block

geo $is_blocked {
    default 0;            # Not blocked by default
    192.168.100.1 1;      # Block this IP
    192.168.100.2 1;      # Block this IP
    10.99.0.0/24 1;       # Block entire subnet
}

server {
    listen 80;
    server_tokens off;

    location / {
        if ($is_blocked) {
            return 403;
        }

        # Normal request handling
        try_files $uri $uri/ /index.php?$args;
    }
}

Geo-Block mit Zugriffsebenen

geo $access_level {
    default       external;
    127.0.0.1     localhost;
    ::1           localhost;
    10.0.0.0/8    internal;
    172.16.0.0/12 internal;
    192.168.0.0/16 internal;
}

server {
    listen 80;
    server_tokens off;

    # Only allow internal users to access admin
    location /admin {
        if ($access_level = external) {
            return 403;
        }
        try_files $uri $uri/ /admin/index.php?$args;
    }
}

Geo-Daten aus externer Datei laden

geo $blocked_ip {
    default 0;
    include /etc/nginx/geo-blocklist.conf;
}
# /etc/nginx/geo-blocklist.conf
# Format: IP/CIDR value;
192.168.100.0/24 1;
10.99.0.0/16 1;
203.0.113.0/24 1;

Geo-Bereiche für große Datensätze

Verwenden Sie für sehr große IP-Listen (wie GeoIP-Daten) die Direktive ranges für eine effizientere Speicherung:

geo $country {
    ranges;
    default ZZ;
    1.0.0.0-1.0.0.255 AU;
    1.0.1.0-1.0.3.255 CN;
    8.8.8.0-8.8.8.255 US;
}

Der Bereichsmodus verwendet eine zweistufige Nachschlagetabelle mit 65.536 Buckets, die nach den oberen 16 Bits der IPv4-Adresse indiziert werden, und anschließend eine binäre Suche innerhalb jedes Buckets. Dies ermöglicht schnelle Nachschlagevorgänge auch bei Millionen von Einträgen.

Schutz von WordPress-Admin-Bereichen

Hier ist ein vollständiges Beispiel zum Schutz der WordPress-Administration mithilfe von NGINX allow deny-Regeln:

# Define allowed admin IPs
geo $allow_wp_admin {
    default 0;

    # Office network
    192.168.1.0/24 1;

    # VPN range
    10.8.0.0/24 1;

    # Localhost for WP-CLI
    127.0.0.1 1;
    ::1 1;
}

server {
    listen 80;
    server_name example.com;
    root /var/www/wordpress;
    index index.php;
    server_tokens off;

    # Protect wp-admin directory
    location /wp-admin {
        if ($allow_wp_admin = 0) {
            return 403;
        }

        location ~ [.]php$ {
            include fastcgi_params;
            fastcgi_pass unix:/run/php-fpm/www.sock;
            fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        }
    }

    # Protect wp-login.php
    location = /wp-login.php {
        allow 192.168.1.0/24;
        allow 10.8.0.0/24;
        allow 127.0.0.1;
        allow ::1;
        deny all;

        include fastcgi_params;
        fastcgi_pass unix:/run/php-fpm/www.sock;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    }

    # Block xmlrpc.php entirely
    location = /xmlrpc.php {
        deny all;
    }

    # Standard WordPress handling
    location / {
        try_files $uri $uri/ /index.php?$args;
    }

    location ~ [.]php$ {
        include fastcgi_params;
        fastcgi_pass unix:/run/php-fpm/www.sock;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    }
}

Wichtiger Hinweis: Die return-Direktive umgeht die Zugriffskontrolle

Die Direktive return wird in der Rewrite-Phase ausgeführt, die vor der Access-Phase stattfindet, in der die NGINX allow deny-Regeln ausgewertet werden. Das bedeutet:

location /admin {
    allow 10.0.0.1;
    deny all;
    return 200 "Admin panel";  # Bypasses access control!
}

Diese Konfiguration schützt /admin nicht, da return vor der Zugriffsprüfung ausgeführt wird.

Gixy erkennt diese Schwachstelle automatisch:

Problem: [return_bypasses_allow_deny] Return directive bypasses allow/deny restrictions
Severity: MEDIUM
Reason: allow/deny do not restrict access to responses produced by return in the same scope

Verwenden Sie stattdessen try_files oder Content-Handler (wie fastcgi_pass, proxy_pass):

location /admin {
    allow 10.0.0.1;
    deny all;
    try_files $uri $uri/ /admin/index.php?$args;  # Access check runs first
}

Sicherheits-Best-Practices

Befolgen Sie basierend auf der Analyse mit Gixy diese Sicherheits-Best-Practices:

NGINX-Version verbergen

Deaktivieren Sie stets die Preisgabe der Version, um zu verhindern, dass Angreifer bekannte Schwachstellen gezielt ausnutzen:

http {
    server_tokens off;

    server {
        # ...
    }
}

Gixy meldet ein fehlendes server_tokens off als HIGH severity:

Problem: [version_disclosure] Do not enable server_tokens on
Severity: HIGH
Reason: Missing server_tokens directive - defaults to 'on' which promotes information disclosure

Konfigurationen mit Gixy validieren

Führen Sie vor der Bereitstellung Gixy aus, um Sicherheitsfehlkonfigurationen zu erkennen. Gixy ist im GetPageSpeed repository verfügbar:

# Install the GetPageSpeed repository
sudo dnf install https://extras.getpagespeed.com/release-latest.rpm

# Install Gixy
sudo dnf install gixy

# Analyze your configuration
gixy /etc/nginx/nginx.conf

# Check specific file
gixy /etc/nginx/conf.d/site.conf

Testen Ihrer NGINX allow deny-Konfiguration

Testen Sie Ihre Konfiguration stets, bevor Sie sie in der Produktion anwenden:

# Check syntax
nginx -t

# Reload configuration
systemctl reload nginx

# Test von verschiedenen IPs mit curl
curl -I http://example.com/admin

Simulieren von Anfragen von verschiedenen IPs

Zum Testen können Sie das ngx_http_realip_module mit einem benutzerdefinierten Header verwenden:

# Nur Testkonfiguration - in der Produktion entfernen!
set_real_ip_from 127.0.0.1;
real_ip_header X-Test-IP;

Testen Sie dann mit:

curl -H "X-Test-IP: 192.168.1.50" http://localhost/admin
curl -H "X-Test-IP: 203.0.113.10" http://localhost/admin

Konfigurationsvererbung

NGINX allow deny-Regeln folgen dem Standard-Vererbungsmodell:

  • Untergeordnete Blöcke erben Regeln von übergeordneten Blöcken, wenn im untergeordneten Block keine Regeln definiert sind
  • Wenn ein untergeordneter Block irgendwelche Zugriffsregeln hat, erbt er nicht vom übergeordneten Block
server {
    allow 10.0.0.0/8;
    deny all;

    location /public {
        # Keine Zugriffsregeln - erbt Regeln des Server-Blocks
    }

    location /api {
        allow all;  # Hat eigene Regeln - erbt NICHT
    }
}

Leistungsüberlegungen

Allow/Deny-Leistung

Das Access-Modul wertet Regeln sequenziell mit O(n)-Komplexität aus. Bei kleinen Listen (unter 100 Einträgen) ist dies vernachlässigbar. Bei größeren Listen verwenden Sie das geo-Modul.

Geo-Modul-Leistung

Das geo-Modul verwendet optimierte Datenstrukturen:

  • CIDR-Modus: Radix-Baum mit O(32)-Lookups für IPv4, O(128) für IPv6
  • Range-Modus: Zweistufige Tabelle mit O(1)-Bucket-Lookup plus O(log n)-Binärsuche

Bei Listen mit Tausenden von IPs ist das geo-Modul deutlich schneller.

Häufige NGINX Allow Deny-Fehler, die Sie vermeiden sollten

  1. deny all am Ende einer Whitelist vergessen (Gixy: Schweregrad HOCH)
  2. return mit Zugriffsregeln verwenden – das return umgeht Zugriffsprüfungen (Gixy: Schweregrad MITTEL)
  3. server_tokens on belassen – legt die NGINX-Version offen (Gixy: Schweregrad HOCH)
  4. Falsche Regelreihenfolge – denken Sie daran: Der erste Treffer gewinnt
  5. Bedeutungslose CIDR-Bits – 192.168.1.100/24 sollte 192.168.1.0/24
  6. sein

  7. Fehlendes IPv6 – wenn Ihr Server IPv6 unterstützt, fügen Sie IPv6-Regeln hinzu
  8. Testen nur von localhost – testen Sie immer von externen IPs, bevor Sie bereitstellen

Verwandte NGINX-Sicherheitsthemen

Zusammenfassung

Die NGINX allow deny-Direktiven bieten eine unkomplizierte IP-basierte Zugriffskontrolle. Für einfache Konfigurationen mit einer Handvoll IPs funktionieren sie gut. Für größere IP-Listen oder komplexere Logik bietet das geo-Modul bessere Leistung und Flexibilität.

Wichtige Punkte zum Merken:

  • NGINX allow deny-Regeln werden in Reihenfolge ausgewertet; der erste Treffer gewinnt
  • Beenden Sie Whitelists immer mit deny all
  • Verwenden Sie CIDR-Notation für Netzwerkbereiche
  • return umgeht Zugriffsprüfungen
  • Setzen Sie immer server_tokens off, um Versionsinformationen zu verbergen
  • Verwenden Sie das geo-Modul für große IP-Listen
  • Validieren Sie Konfigurationen mit Gixy vor der Bereitstellung
  • Testen Sie von tatsächlichen externen IPs vor der Bereitstellung

Mit ordnungsgemäßer IP-Whitelisting unter Verwendung von NGINX allow deny-Regeln und Validierung mit Tools wie Gixy können Sie Ihre Angriffsfläche erheblich reduzieren, indem Sie sicherstellen, dass nur vertrauenswürdige Netzwerke auf sensible Bereiche Ihrer Anwendung zugreifen können.
Allow/deny-Regeln plus Konfigurationsüberwachung. IP-Listen sind einfach zu schreiben und leicht zu vergessen, sie in einen neuen server-Block aufzunehmen. GetPageSpeed Amplify führt geplante gixy-Scans auf jedem Host aus und verknüpft die Ergebnisse mit Live-NGINX-Laufzeitmetriken. Drop-in-kompatibel mit dem veralteten nginx-amplify-agent (EOL Januar 2026).