Wéi installéiere ech ModSecurity 3 + OWASP mat Nginx op Rocky Linux 9

ModSecurity, dacks als Modsec bezeechent, ass eng gratis Open-Source Webapplikatioun Firewall (WAF). ModSecurity gouf als Modul fir den Apache HTTP Server erstallt. Wéi och ëmmer, zënter senge fréien Deeg, ass de WAF gewuess an deckt elo eng ganz Rëtsch vun HyperText Transfer Protocol Ufro an Äntwertfilterfunktioune fir verschidde Plattformen wéi Microsoft IIS, Nginx, an Apache. Dem ModSecurity seng primär Roll ass de Schutz fir Webapplikatiounen ze bidden andeems en enkommende Traffic filtert a béiswëlleg Ufroe blockéiert. De WAF kann och konfiguréiert ginn fir den Traffic fir verschidden Aktivitéiten ze iwwerwaachen, wéi SQL Injektiounsattacken, an Alarmer ze generéieren wann esou Aktivitéit festgestallt gëtt. Zousätzlech zu senge Sécherheetsvirdeeler kann ModSecurity d'Webleistung verbesseren andeems d'Regelen cachen an d'Bedierfnes eliminéiert fir déiselwecht Ufro ëmmer erëm ze veraarbecht.

Zesumme mat der Modsecurity Installatioun gëtt OWASP Core Rule Set (CRS) allgemeng a Verbindung benotzt, wat en Open-Source Set vu Reegelen ass, geschriwwen an der ModSecurity's SecRules Sprooch. D'CRS gëtt héich ugesinn an der Sécherheetsindustrie, an ModSecurity gëtt als ee vun den effektivste Weeër ugesinn fir Webapplikatiounen virun Attacken ze schützen. Wärend ModSecurity keng Sëlwerkugel ass, ass et e wesentlecht Tool am Arsenal vun all Organisatioun déi d'Websécherheet eescht hëlt.

OWASP Rule Set mat ModSecurity ka bal direkt hëllefen Äre Server ze schützen.

  • Schlecht Benotzer Agenten
  • drun deelhuelen
  • Kräiz Websäit Scripting
  • SQL Injektioun
  • Sëtzungshaftung
  • Aner Geforen

Am folgenden Tutorial léiert Dir wéi Dir ModSecurity 3 & OWASP Core Rule Set mat Nginx op Rocky Linux 9 installéiert mat Beispiller Konfiguratiounen vun Ufank bis Enn.

Update Rocky Linux

Als éischt, update Äre System fir sécherzestellen datt all existent Packagen aktuell sinn.

sudo dnf upgrade --refresh

Installéiert déi lescht Nginx Stable oder Mainline

Par défaut kënnt Dir Är existent Versioun vun Nginx installéiert halen wann Dir eng passend Versiounsquell fannt. Wann net, ass d'Installatioun entweder déi lescht stabil oder Mainline Build vun Nginx recommandéiert, well d'Tutorial hei ënnen duerchgoe wäert.

Ewechzehuelen bestehend Nginx Installatioun

Stop den aktuellen Nginx Service:

sudo systemctl stop nginx

Elo läschen déi existent Nginx Installatioun wéi follegt:

sudo dnf remove nginx

Elo datt Dir déi al Nginx Versioun erfollegräich geläscht hutt, wann Dir se installéiert hutt, fir d'Nginx Mainline z'installéieren, musst Dir d'Ofhängegkeet fir d'éischt installéieren, wat ass dnf-Utilities mat dem folgendem Kommando:

sudo dnf install dnf-utils -y

Als nächst importéiert d'Repositories hei drënner.

Import Nginx Mainline Repository

sudo tee /etc/yum.repos.d/nginx-mainline.repo<<EOF

[nginx-mainline]
name=nginx mainline repo
baseurl=http://nginx.org/packages/mainline/centos/9/x86_64/
gpgcheck=1
enabled=0
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

EOF

Benotzer mat aarch Architektur, ersetzen am uewe genannte Kommando baseurl=http://nginx.org/packages/mainline/centos/9/x86_64/ mat baseurl=http://nginx.org/packages/mainline/centos/9/aarch64/.

Import Nginx Stable Repository

sudo tee /etc/yum.repos.d/nginx-stable.repo<<EOF

[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/9/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

EOF

Benotzer mat aarch Architektur, ersetzen am uewe genannte Kommando baseurl=http://nginx.org/packages/mainline/centos/9/x86_64/ mat baseurl=http://nginx.org/packages/mainline/centos/9/aarch64/.

Installéiert den Nginx

Par défaut gëtt de leschte Repository fir stabil Nginx Packagen als éischt benotzt. Wéi och ëmmer, den Tutorial gëtt installéiert Nginx Haaptlinn, also musst Dir de folgende Kommando ausféieren fir de Mainline Repository wéi follegt z'aktivéieren:

sudo yum-config-manager --enable nginx-mainline

Notéiert wann Dir léiwer stabil ass, benotzt de uewe genannte Kommando net a fuert op den nächsten Deel vum Tutorial.

Als nächst, installéiert Nginx Mainline wéi follegt:

sudo dnf install nginx
Wéi installéiere ech ModSecurity 3 + OWASP mat Nginx op Rocky Linux 9

Wéi uewendriwwer installéiert den Tutorial déi lescht Nginx Mainline Versioun direkt vun Nginx.org. Notéiert datt Dir e Pop-up gesitt deen Iech informéiert iwwer d'Importatioun vun der GPG Schlëssel während der Installatioun. Dëst ass sécher ze maachen an ass erfuerderlech fir d'Installatioun vun der Nginx Mainline erfollegräich ofzeschléissen.

Par défaut kënnt Nginx net aktivéiert an ass bei der Installatioun deaktivéiert. Fir Ären Nginx Service z'aktivéieren, benotzt:

sudo systemctl start nginx

Aktivéiert Nginx fir op Boot ze starten; benotzt de folgende Kommando:

sudo systemctl enable nginx

Optional verifizéiert Är Versioun vun Nginx. An eisem Fall ass et d'Nginx Mainline Versioun; benotzt de folgende Kommando.

nginx -v

Konfiguréieren FirewallD Fir Nginx

Wann Dir net en existente Nginx Service ersetzt an Nginx fir d'éischte Kéier installéiert, musst Dir vläicht d'Firewall fir HTTP an HTTPS Traffic konfiguréieren. E Beispill vu wéi Dir dëst maache kënnt ass hei ënnen:

Erlaabt HTTP-Traffic benotzt de folgende Kommando:

sudo firewall-cmd --permanent --zone=public --add-service=http

Erlaabt HTTPS Traffic benotzt de folgende Kommando:

sudo firewall-cmd --permanent --zone=public --add-service=https

Eemol gemaach, musst Dir d'Ännerungen effektiv maachen andeems Dir d'Firewall nei lued:

sudo firewall-cmd --reload

Download Nginx Source

De nächste Schrëtt ass Elo, an Dir musst den Nginx Quellcode eroflueden fir den ModSecurity dynamesche Modul ze kompiléieren. Dir musst de Quellpaket an der Verzeechnesplaz eroflueden an späicheren /etc/local/src/nginx.

Erstellt a konfiguréiert Verzeechnes

Erstellt de Standuert wéi follegt:

sudo mkdir /usr/local/src/nginx && cd /usr/local/src/nginx

Download Quell Archiv

Als nächst, luet den Nginx Quellarchiv vun der Downloads Säit erof fir mat der Nginx Versioun ze passen, déi Dir virdru identifizéiert hutt. Och wann Dir net op déi lescht Versioun vu stabile oder Mainline Nginx aktualiséiert hutt an eng méi al Versioun benotzt, sollt Dir fäeg sinn eng Quell ze fannen fir Iech selwer ze passen.

Nginx Downloads Säit ka sinn fannen.

Luet d'Quell erof mat der wiisst Kommando wéi follegt (nëmmen Beispill).

sudo wget http://nginx.org/download/nginx-1.23.1.tar.gz

Denkt drun datt et essentiell ass datt d'Nginx Versioun installéiert entsprécht dem erofgelueden Archiv, oder soss hutt Dir Feeler méi spéit am Tutorial.

Als nächst, extrahéiert d'Archiv wéi follegt.

sudo tar -xvzf nginx-1.23.1.tar.gz

Verifizéiert d'Quell Versioun

Als nächst, lëscht d'Verzeichnisdateien mat der ls Kommando wéi follegt.

ls

Beispill Ausgang an Ärer /usr/src/local/nginx Dossier.

[joshua@rocky-linux-9 nginx]$ ls
nginx-1.23.1  nginx-1.23.1.tar.gz

Als nächst bestätegt datt de Quellpaket d'selwecht ass wéi Är Nginx Versioun op Ärem System installéiert, wéi virdru scho gesot.

Installéiert libmodsecurity3 fir ModSecurity

De Package libmodsecurity3 ass de fundamentalen Deel vun der WAF déi den HTTP-Filterung fir Är Webapplikatiounen. Dir wäert et aus der Quell kompiléieren.

Klon ModSecurity Repository vu Github

Den éischte Schrëtt ass de Klon vu Github, a wann Dir net git installéiert hutt, musst Dir de folgende Kommando ausféieren:

sudo dnf install git -y

Als nächst, klon de libmodsecurity3 GIT Repository wéi follegt.

sudo git clone --depth 1 -b v3/master --single-branch https://github.com/SpiderLabs/ModSecurity /usr/local/src/ModSecurity/

Eemol gekloont, Dir musst CD an den Dossier.

cd /usr/local/src/ModSecurity/

Installéiert libmodsecurity3 Ofhängegkeeten

Ier Dir kompiléiert, musst Dir déi folgend Ofhängegkeeten installéieren wéi follegt.

Déi éischt Aufgab ass den EPEL Repository z'installéieren, an d'Empfehlung ass béid Repositories z'installéieren.

Als éischt aktivéiert de CRB Repository.

sudo dnf config-manager --set-enabled crb

Als nächst installéieren EPEL benotzt déi folgend (dnf) terminal Kommando.

sudo dnf install \
    https://dl.fedoraproject.org/pub/epel/epel-release-latest-9.noarch.rpm \
    https://dl.fedoraproject.org/pub/epel/epel-next-release-latest-9.noarch.rpm

Als nächst fuert de folgende Kommando aus fir d'Packagen z'installéieren déi Modsecurity erfuerdert. Dëst sollt déi meescht Optiounen a Funktiounen ofdecken, déi Dir mat Modsecurity an dem Kärregelset benotze kënnt.

sudo dnf install doxygen yajl-devel gcc-c++ flex bison yajl curl-devel zlib-devel pcre-devel autoconf automake git curl make libxml2-devel pcre-static pkgconfig libtool httpd-devel redhat-rpm-config wget curl openssl openssl-devel geos geos-devel geocode-glib-devel geolite2-city geolite2-country nano -y

Installéiert GeoIP, Dir musst als éischt de Remi Repository importéieren.

sudo dnf install dnf-utils http://rpms.remirepo.net/enterprise/remi-release-9.rpm -y

Installéiert elo GeoIP-devel mam folgenden Kommando.

sudo dnf --enablerepo=remi install GeoIP-devel -y

Elo fir ofzeschléissen, installéiert déi folgend GIT Submoduler wéi follegt.

sudo git submodule init

Dann update d'Submodulen:

sudo git submodule update

Baut d'ModSecurity Ëmfeld

De nächste Schrëtt ass elo eigentlech d'Ëmwelt als éischt ze bauen. Benotzt de folgende Kommando:

sudo ./build.sh

Als nächst, fuert de Kommando Konfiguratioun.

sudo ./configure

Notéiert datt Dir méiglecherweis de folgende Feeler gesitt.

fatal: No names found, cannot describe anything.

Dir kënnt dëst sécher ignoréieren an op den nächste Schrëtt weidergoen.

Kompiléiere vum ModSecurity Source Code

Elo datt Dir d'Ëmfeld fir libmodsecurity3 gebaut a konfiguréiert hutt, ass et Zäit et mam Kommando ze kompiléieren maachen.

sudo make

E prakteschen Trick ass fir ze spezifizéieren -j well dëst kann d'Kompiléierungsgeschwindegkeet wesentlech erhéijen wann Dir e mächtege Server hutt.

Zum Beispill, huet de Server 6 CPU, an ech kann all benotzen 6 oder op d'mannst 4 ze 5 fir eng Erhéijung Vitesse.

sudo make -j 6

Nodeems Dir de Quellcode kompiléiert hutt, lafen elo den Installatiounskommando an Ärem Terminal:

sudo make install

Bedenkt datt d'Installatioun an der /usr/local/modsecurity/, déi Dir spéider referenzéiert.

Installéiert ModSecurity-nginx Connector

d' ModSecurity-nginx Connector ass de Verbindungspunkt tëscht nginx a libmodsecurity. Et ass de Komponent deen tëscht Nginx a ModSecurity kommunizéiert (libmodsecurity3).

Klon ModSecurity-nginx Repository vu Github

Ähnlech wéi de virege Schrëtt deen de libmodsecurity3 Repository klonen, musst Dir de Connector Repository nach eng Kéier klonen andeems Dir de folgende Kommando benotzt:

sudo git clone --depth 1 https://github.com/SpiderLabs/ModSecurity-nginx.git /usr/local/src/ModSecurity-nginx/

Installéiert ModSecurity-nginx Ofhängegkeeten

Als nächst, navigéiert an den Nginx Quellverzeechnes; erënneren d'Beispill hei ënnendrënner wäert vun Ärer Versioun anescht ginn; et ass just e Beispill.

Beispill:

cd /usr/local/src/nginx/nginx-1.23.1/

Als nächst kompiléiert Dir d' ModSecurity-nginx Connector Modul nëmmen mat der –Mat-kompatibel Fändel wéi follegt:

sudo ./configure --with-compat --add-dynamic-module=/usr/local/src/ModSecurity-nginx

Beispill Ausgang wann alles bis elo richteg geschafft huet:

Wéi installéiere ech ModSecurity 3 + OWASP mat Nginx op Rocky Linux 9

elo maachen (erstellen) déi dynamesch Moduler mam folgendem Kommando:

sudo make modules

Beispill Ausgab:

Wéi installéiere ech ModSecurity 3 + OWASP mat Nginx op Rocky Linux 9

Als nächst, wärend am Nginx Quellverzeichnis, benotzt de folgende Kommando fir den dynamesche Modul ze réckelen deen Dir gemaach hutt deen op der Plaz gespäichert gouf objs/ngx_http_modsecurity_module.so a kopéiert et un der /usr/share/nginx/modules Dossier.

sudo cp objs/ngx_http_modsecurity_module.so /usr/share/nginx/modules/

Dir kënnt den dynamesche Modul iwwerall späicheren wann Dir de ganze Wee spezifizéiert beim Luede.

Fir Benotzer déi Nginx Mainline oder stabil installéiert hunn, wier d'Location wéi follegt.

sudo cp objs/ngx_http_modsecurity_module.so /etc/nginx/modules/

Lueden a konfiguréieren ModSecurity-nginx Connector mat Nginx

Elo datt Dir den dynamesche Modul kompiléiert hutt an en deementspriechend lokaliséiert hutt, musst Dir Äert änneren /etc/nginx/nginx.conf Konfiguratiounsdatei fir ModSecurity mat Ärem Nginx Webserver ze bedreiwen.

Aktivéiert ModSecurity an nginx.conf

Als éischt musst Dir spezifizéieren load_modul a Wee op Är ModSecurity Modul.

Maach op nginx.conf mat all Text Editor. Fir den Tutorial gëtt Nano benotzt:

sudo nano /etc/nginx/nginx.conf

Als nächst füügt déi folgend Zeil un d'Datei no uewen:

load_module modules/ngx_http_modsecurity_module.so;

Wann Dir de Modul soss anzwousch lokaliséiert hutt, enthält de komplette Wee.

Füügt elo de folgende Code ënner dem HTTP {} Sektioun wéi follegt:

modsecurity on;
modsecurity_rules_file /etc/nginx/modsec/modsec-config.conf;

Beispill:

Wéi installéiere ech ModSecurity 3 + OWASP mat Nginx op Rocky Linux 9

Wann Dir de Modul soss anzwousch lokaliséiert hutt, enthält de komplette Wee.

Späichert d'Datei (CTRL+O), dann Sortie (CTRL+X).

Erstellt a konfiguréiert Verzeechnes a Dateien fir ModSecurity

Fir den Tutorial musst Dir e Verzeechnes erstellen fir d'Konfiguratiounsdateien an zukünfteg Regelen ze späicheren, OWASP CRS.

Benotzt de folgende Kommando fir de /etc/nginx/modsec Dossier.

sudo mkdir /etc/nginx/modsec/

Dir musst d'Probe ModSecurity Konfiguratiounsdatei aus eisem gekloonten GIT Verzeichnis kopéieren.

sudo cp /usr/local/src/ModSecurity/modsecurity.conf-recommended /etc/nginx/modsec/modsecurity.conf

Benotzt Äre Liiblingstexteditor, öffnen d'modsecurity.conf Datei wéi follegt.

sudo nano /etc/nginx/modsec/modsecurity.conf

Par défaut, ModSecurity Configuratioun huet d'Regel Motor uginn als (Nëmmen Detektioun), wat an anere Wierder ModSecurity leeft an all béiswëlleg Verhalen erkennt, awer net Aktiounsblocken oder Verbuet a protokolléiert all HTTP-Transaktiounen, déi se markéiert. Dëst sollt nëmme benotzt ginn wann Dir vill falsch Positiver hutt oder d'Sécherheetsniveau Astellungen op en extremen Niveau erhéicht hutt an Tester fir ze kucken ob falsch Positiver optrieden.

An der Konfiguratiounsdatei ännert dëst Verhalen op (an), fonnt op der Linn 7.

SecRuleEngine DetectionOnly

Ännert d'Linn op dës fir ModSecurity z'aktivéieren:

SecRuleEngine On

Beispill:

Wéi installéiere ech ModSecurity 3 + OWASP mat Nginx op Rocky Linux 9

Elo musst Dir déi folgend fannen SecAuditLogParts, déi op der Linn 224 läit.

# Log everything we know about a transaction.
SecAuditLogParts ABIJDEFHZ

Dëst ass net richteg a muss geännert ginn. Ännert d'Linn op déi folgend:

SecAuditLogParts ABCEFHJKZ

Elo späichert d' Datei mat (CTRL+O), dann Sortie (CTRL+X).

Den nächsten Deel ass déi folgend Datei ze kreéieren modsec-config.conf. Hei wäert Dir de modsecurity.conf Fichier mat a spéider op aner Regelen wéi z.B OWASP CRS, a wann Dir WordPress benotzt, de WPRS CRS Regel gesat.

Benotzt de folgende Kommando fir d'Datei ze kreéieren an opzemaachen.

sudo nano /etc/nginx/modsec/modsec-config.conf

Eemol an der Datei, füügt déi folgend Linn derbäi.

include /etc/nginx/modsec/modsecurity.conf

Späichert d'Modsec-config.conf Datei mat (CTRL+O), dann (CTRL+X) Sortie.

Endlech, kopéiert ModSecurity's unicode.mapping Fichier mat der CP Kommando wéi follegt.

sudo cp /usr/local/src/ModSecurity/unicode.mapping /etc/nginx/modsec/

Ier Dir weidergeet, sollt Dir Ären Nginx Service en dréchene Laf mat dem folgenden Terminal Kommando ginn.

sudo nginx -t

Wann Dir alles richteg ageriicht hutt, sollt Dir déi folgend Ausgab kréien:

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Fir d'Ännerungen live ze maachen, start Ären Nginx Service mat dem Systemctl Kommando:

sudo systemctl restart nginx

Installéiert OWASP Core Rule Set fir ModSecurity

ModSecurity eleng schützt net Äre Webserver, an Dir musst Regelen hunn. Ee vun de bekanntste, respektéierten a bekannte Regelen ass den OWASP CRS Regelset. D'Regele sinn am meeschte verbreet ënner Webserver an aner WAFs, an déi meescht aner ähnlech Systemer baséieren déi meescht vun hire Reegelen op dësem CRS. D'Installatioun vun dësem Regelenset gëtt Iech automatesch eng grouss Quell vu Schutz géint déi meescht opkomende Bedrohungen um Internet andeems béisaarteg Akteuren z'entdecken an se blockéieren.

Kuckt d' OWASP Release Tag Säit fir ze kucken wat dat lescht ass, well d'Beispill hei drënner an Zukunft geännert ka ginn.

Als éischt, navigéiert zréck an Äre Modsec Verzeichnis deen erstallt gouf.

cd /etc/nginx/modsec

mat der wget Kommando, eroflueden OWASP CRS 3.3.2 Archiv, déi vun dësem Datum déi lescht stabil ass, awer behalen virun véier Deeg am Kapp, d'Pre-Release Versioun ass erofgaang, also mäi Rot ass de Link e puer Zeilen uewen ze kontrolléieren fir ze kucken wéi d'Verëffentlechungen ausgesinn fir de Kärregelset.

wget https://github.com/coreruleset/coreruleset/archive/refs/tags/v3.3.2.zip

Dir kënnt den Nuetsbau eroflueden fir déi, déi um Rand wëllen liewen. Benotzt nëmmen d'Nuecht wann Dir bereet sidd weider ze kompiléieren an de CoreRuleSet Github dacks fir Updates ze kontrolléieren a méi zouversiichtlech ze sinn fir d'Froen erauszefannen. Technesch kann d'Nuecht méi sécher sinn awer potenziell Probleemer kreéieren.

Fir Ufänger Benotzer, benotzt déi stabil Versioun a benotzt net déi ënnen Versioun.

wget https://github.com/coreruleset/coreruleset/archive/refs/tags/nightly.zip

Zu der Zäit vun der Schafung vum Tutorial ass de v4.0.0-RC1 Pre-Release och verfügbar, wéi virdru scho gesot.

wget https://github.com/coreruleset/coreruleset/archive/refs/tags/v4.0.0-rc1.zip

installéieren der Paket unzip wann Dir dëst net op Ärem Server installéiert hutt.

sudo dnf install unzip -y

Elo unzip d'Archiv un, an den Tutorial wäert den RC Kandidat installéieren well et no bei der aktualiséierter Versioun méiglech ass ouni d'Nuecht ze benotzen, wat problematesch ka sinn, ausser Dir sidd mat OWASP Regelen a Modsecurity erlieft. Da recommandéieren ech déi Versioun fir déi lescht Sécherheetsregelen ze benotzen.

sudo unzip v4.0.0-rc1 -d /etc/nginx/modsec

Ech recommandéieren d'Versioune vun den OWASP Regelsets ze halen, well Dir kënnt e puer eroflueden an an Zukunft se séier an Ärem modsecurity.conf änneren fir ze kucken wéi eng Regeleset am Beschten ouni Probleemer funktionnéiert, wéi z. a Fräisetzung Kandidat.

Wéi virdrun, wéi de modsecurity.conf Prouf Configuratioun, OWASP CRS kënnt mat enger Prouf Configuratiounsdatei Dir musst ëmbenennen. Et ass am beschten de CP Kommando ze benotzen an e Backup fir d'Zukunft ze halen am Fall wou Dir erëm nei starten musst.

sudo cp /etc/nginx/modsec/coreruleset-4.0.0-rc1/crs-setup.conf.example /etc/nginx/modsec/coreruleset-4.0.0-rc1/crs-setup.conf

Fir d'Regelen z'aktivéieren, öffnen d' /etc/nginx/modsec/modsec-config.conf.

sudo nano /etc/nginx/modsec/modsec-config.conf

Eemol an der Datei erëm, füügt déi folgend zwou zousätzlech Zeilen derbäi:

include /etc/nginx/modsec/coreruleset-4.0.0-rc1/crs-setup.conf
include /etc/nginx/modsec/coreruleset-4.0.0-rc1/rules/*.conf

Beispill:

Wéi installéiere ech ModSecurity 3 + OWASP mat Nginx op Rocky Linux 9

Späichert d'Datei (CTRL+O) an Sortie (CTRL+T).

Denkt drun, wéi e bësse virdru erkläert, Dir kënnt technesch verschidde Versiounen eroflueden, dës Datei änneren, a vergiesst net ze kopéieren an d'Whitelist déi Dir maacht, de bedeitende Bestanddeel vun der Whitelist ass datt et zum gréissten Deel generesch ass.

Wéi virdru musst Dir all nei Ergänzunge fir Ären Nginx Service testen ier Dir et live mécht.

sudo nginx -t

Nodeems Dir den Dréchent-Test ausgefouert hutt, sollt Dir déi folgend Ausgang kréien, wat heescht datt alles richteg funktionnéiert:

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Restart Ären Nginx Service fir d'Ännerunge live ze maachen wéi follegt:

sudo systemctl restart nginx

OWASP Core Rule Set benotzen a verstoen

OWASP CRS huet vill Optiounen, d'Standardastellungen, awer aus der Këscht, schützen déi meescht Serveren direkt ouni Är richteg Besucher a gutt SEO Bots ze schueden. Drënner ginn e puer Beräicher ofgedeckt fir z'erklären. Weider Liesung wier am beschten fir all d'Optiounen an de Konfiguratiounsdateien selwer z'ënnersichen well se zimmlech vill Textdaten hunn ze erklären.

Öffnert Är CRS-setup.conf Fichier.

sudo nano /etc/nginx/modsec/coreruleset-4.0.0-rc1/crs-setup.conf

Notéiert datt dëst d'Dev Versioun Konfiguratioun ass mat zousätzlech Elementer am Verglach mat der Versioun 3.3.

Vun hei aus kënnt Dir déi meescht vun Ären OWASP CRS Astellungen änneren.

OWASP CRS Bewäertung

Fir et ze briechen, ModSecurity huet zwee Modi:

Anomalie Scoring Mode

# -- [[ Anomaly Scoring Mode (default) ]] --
# In CRS3, anomaly mode is the default and recommended mode, since it gives the
# most accurate log information and offers the most flexibility in setting your
# blocking policies. It is also called "collaborative detection mode".
# In this mode, each matching rule increases an 'anomaly score'.
# At the conclusion of the inbound rules, and again at the conclusion of the
# outbound rules, the anomaly score is checked, and the blocking evaluation
# rules apply a disruptive action, by default returning an error 403.

Selbstänneg Modus

# -- [[ Self-Contained Mode ]] --
# In this mode, rules apply an action instantly. This was the CRS2 default.
# It can lower resource usage, at the cost of less flexibility in blocking policy
# and less informative audit logs (only the first detected threat is logged).
# Rules inherit the disruptive action that you specify (i.e. deny, drop, etc).
# The first rule that matches will execute this action. In most cases this will
# cause evaluation to stop after the first rule has matched, similar to how many
# IDSs function.

Anomalie Scoring ass allgemeng, fir déi meescht Benotzer, de beschte Modus fir ze benotzen.

Et gi véier Paranoia Niveauen:

  • Paranoia Niveau 1 - Standardniveau a recommandéiert fir déi meescht Benotzer.
  • Paranoia Niveau 2 - Nëmme fortgeschratt Benotzer.
  • Paranoia Niveau 3 - Expert Benotzer nëmmen.
  • Paranoia Niveau 4 - Iwwerhaapt net recommandéiert, ausser fir aussergewéinlech Ëmstänn.
# -- [[ Paranoia Level Initialization ]] ---------------------------------------
#
# The Paranoia Level (PL) setting allows you to choose the desired level
# of rule checks that will add to your anomaly scores.
#
# With each paranoia level increase, the CRS enables additional rules
# giving you a higher level of security. However, higher paranoia levels
# also increase the possibility of blocking some legitimate traffic due to
# false alarms (also named false positives or FPs). If you use higher
# paranoia levels, it is likely that you will need to add some exclusion
# rules for certain requests and applications receiving complex input.
#
# - A paranoia level of 1 is default. In this level, most core rules
#   are enabled. PL1 is advised for beginners, installations
#   covering many different sites and applications, and for setups
#   with standard security requirements.
#   At PL1 you should face FPs rarely. If you encounter FPs, please
#   open an issue on the CRS GitHub site and don't forget to attach your
#   complete Audit Log record for the request with the issue.
# - Paranoia level 2 includes many extra rules, for instance enabling
#   many regexp-based SQL and XSS injection protections, and adding
#   extra keywords checked for code injections. PL2 is advised
#   for moderate to experienced users desiring more complete coverage
#   and for installations with elevated security requirements.
#   PL2 comes with some FPs which you need to handle.
# - Paranoia level 3 enables more rules and keyword lists, and tweaks
#   limits on special characters used. PL3 is aimed at users experienced
#   at the handling of FPs and at installations with a high security
#   requirement.
# - Paranoia level 4 further restricts special characters.
#   The highest level is advised for experienced users protecting
#   installations with very high security requirements. Running PL4 will
#   likely produce a very high number of FPs which have to be
#   treated before the site can go productive.
#
# All rules will log their PL to the audit log;
# example: [tag "paranoia-level/2"]. This allows you to deduct from the
# audit log how the WAF behavior is affected by paranoia level.
#
# It is important to also look into the variable
# tx.enforce_bodyproc_urlencoded (Enforce Body Processor URLENCODED)
# defined below. Enabling it closes a possible bypass of CRS.

Test OWASP CRS op Ärem Server

Fir ze testen ob OWASP CRS op Ärem Server funktionnéiert, maach Ären Internetbrowser op a benotzt déi folgend:

https://www.yourdomain.com/index.html?exec=/bin/bash

Dir sollt eng kréien 403 verbueden Feeler. Wann net, dann ass e Schrëtt verpasst.

Beispill:

Wéi installéiere ech ModSecurity 3 + OWASP mat Nginx op Rocky Linux 9

De stäerkste gemeinsam Problem ass änneren Nëmmen Detektioun ze maachen On, wéi virdru am Tutorial ofgedeckt.

Ëmgank mat falschen Positiver & Benotzerdefinéiert Regelen Ausgrenzung

Eng vun den dacks onendlechen Aufgaben ass mat falschen Positiver ze këmmeren, ModSecurity an OWASP CRS maachen eng super Aarbecht zesummen, awer et kënnt op d'Käschte vun Ärer Zäit, awer mat dem Schutz deen Dir kritt, ass et derwäert. Fir Ufänger, ni de Paranoia-Niveau héich eropzesetzen ass déi gëllen Regel.

Eng gutt Fauschtregel ass d'Regelset fir e puer Wochen bis Méint mat kaum falsche Positiven auszeféieren, dann zum Beispill Paranoianiveau 1 op Paranoianiveau 2 eropzesetzen, sou datt Dir net mat enger Tonne gläichzäiteg iwwerschwemmt sidd.

Ausgeschloss False Positives bekannt Uwendungen

Modsecurity, par défaut, kann alldeeglech Handlungen whitelistéieren déi zu falsche Positiver féieren wéi hei ënnen:

#SecAction \
# "id:900130,\
#  phase:1,\
#  nolog,\
#  pass,\
#  t:none,\
#  setvar:tx.crs_exclusions_cpanel=1,\
#  setvar:tx.crs_exclusions_dokuwiki=1,\
#  setvar:tx.crs_exclusions_drupal=1,\
#  setvar:tx.crs_exclusions_nextcloud=1,\
#  setvar:tx.crs_exclusions_phpbb=1,\
#  setvar:tx.crs_exclusions_phpmyadmin=1,\
#  setvar:tx.crs_exclusions_wordpress=1,\
#  setvar:tx.crs_exclusions_xenforo=1"

Fir z.B. WordPress, phpBB, an phpMyAdmin wéi Dir all dräi benotzt, unkommentéieren d'Linnen a loosst den (1) Nummer intakt, änneren déi aner Servicer déi Dir net benotzt, zum Beispill Xenforo (0) well Dir wëllt dës Regelen net Whitelist.

Beispill hei drënner:

SecAction \
 "id:900130,\
  phase:1,\
  nolog,\
  pass,\
  t:none,\
  setvar:tx.crs_exclusions_cpanel=0,\
  setvar:tx.crs_exclusions_dokuwiki=0,\
  setvar:tx.crs_exclusions_drupal=0,\
  setvar:tx.crs_exclusions_nextcloud=0,\
  setvar:tx.crs_exclusions_phpbb=1,\
  setvar:tx.crs_exclusions_phpmyadmin=1,\
  setvar:tx.crs_exclusions_wordpress=1,\
  setvar:tx.crs_exclusions_xenforo=0"

Dir kënnt och d'Syntax änneren, wat méi propper wier. Zum Beispill:

SecAction \
 "id:900130,\
  phase:1,\
  nolog,\
  pass,\
  t:none,\
  setvar:tx.crs_exclusions_phpbb=1,\
  setvar:tx.crs_exclusions_phpmyadmin=1,\
  setvar:tx.crs_exclusions_wordpress=1"

Wéi Dir kënnt gesinn, ewechgeholl ginn d'Optiounen net gebraucht a bäigefüügt (“) um Enn vu WordPress fir richteg Syntax.

Ausgeschloss Regelen Virun CRS

Fir mat personaliséierten Ausgrenzungen ze këmmeren, musst Dir als éischt den Numm vun der änneren REQUEST-900-EXCLUSION-RULES-BEFORE-CRS-SAMPLE.conf Fichier mat der cp Kommando wéi follegt:

sudo cp /etc/nginx/modsec/coreruleset-3.4-dev/rules/REQUEST-900-EXCLUSION-RULES-BEFORE-CRS.conf.example /etc/nginx/modsec/coreruleset-3.4-dev/rules/REQUEST-900-EXCLUSION-RULES-BEFORE-CRS.conf

Denkt drun wann Dir Ausgrenzungsregelen erstellt, jidderee muss ID hunn: an eenzegaarteg sinn, oder soss wann Dir Ären Nginx Service testt, kritt Dir e Feeler.

Beispill "id:1544,phase:1,log,allow,ctl:ruleEngine=off", d'ID 1544 kann net fir eng zweet Regel benotzt ginn.

Zum Beispill, e puer REQUEST_URI'en wäerte falsch Positiver erhéijen. D'Beispill hei drënner ass zwee mat Google Pagespeed Beacon a WMUDEV Plugin fir WordPress:

SecRule REQUEST_URI "@beginsWith /wp-load.php?wpmudev" "id:1544,phase:1,log,allow,ctl:ruleEngine=off"

SecRule REQUEST_URI "@beginsWith /ngx_pagespeed_beacon" "id:1554,phase:1,log,allow,ctl:ruleEngine=off"

Wéi Dir kënnt gesinn, gëtt all URL déi mam Wee ufänkt automatesch erlaabt.

Eng aner Optioun ass d'Whitelist IP Adressen; e puer Weeër wéi Dir dëst maache kënnt:

SecRule REMOTE_ADDR "^195\.151\.128\.96" "id:1004,phase:1,nolog,allow,ctl:ruleEngine=off"
## or ###
SecRule REMOTE_ADDR "@ipMatch 127.0.0.1/8, 195.151.0.0/24, 196.159.11.13" "phase:1,id:1313413,allow,ctl:ruleEngine=off"

d' @ipMatch ka méi extensiv fir Subnets benotzt ginn. Wann Dir wëllt e Subnet oder IP Adress änneren ze refuséieren, erlaabt ze refuséieren. Mat e puer Know-how kënnt Dir och Blacklists a Whitelists erstellen an dëst mat fail2ban konfiguréieren. D'Méiglechkeeten kënnen dacks endlos sinn.

Ee lescht Beispill ass nëmmen Reegelen auszeschalten déi falsch Positiver ausléisen, net de ganze Wee Whitelisting, wéi Dir mat dem éischte REQUEST_URI Beispill gesinn hutt. Wéi och ëmmer, dëst brauch méi Zäit an Tester.

Zum Beispill, wann Dir Regele wëllt läschen 941000 an 942999 vun Ärer /admin/ Beräich wéi et weider falsch Verbueter a Späre fir Äert Team ausléist, fannt an Äre Modsecurity Logbicher d'Regel ID an deaktivéiert dann nëmmen dës ID mat RemoveByID wéi d'Beispill hei drënner:

SecRule REQUEST_FILENAME "@beginsWith /admin" "id:1004,phase:1,pass,nolog,ctl:ruleRemoveById=941000-942999"

Beispiller kënnen op der ModSecurity GIT fonnt ginn Wiki Säit.

WordPress WPRS Regelset fir ModSecurity

Eng aner Optioun fir WordPress D'Benotzer sollen niewent Ärem OWASP CRS Regelset installéieren a lafen, e bekannte Projet mam Titel WPRS Regelset. Well dëst fakultativ ass an net fir jiddereen, wäert den Tutorial et net an dëser Sektioun ofdecken.

Wéi och ëmmer, wann Dir dëst fir extra Schutz mat WordPress op Ärem Server installéiere wëllt, besicht w.e.g. eisen Tutorial op Installéiere WordPress ModSecurity Rule Set (WPRS).

ModSecurity LogRotate Datei erstellen

ModSecurity Logbicher kënnen iwwerwuessen, also musst Dir d'Log rotéieren, well dëst net fir Iech gemaach gëtt.

Als éischt, erstellt an oppen Är ModSecurity Rotatiounsdatei modsec.

sudo nano /etc/logrotate.d/modsec

Füügt de folgende Code derbäi:

/var/log/modsec_audit.log
{
        rotate 31
        daily
        missingok
        compress
        delaycompress
        notifempty
}

Dëst wäert Logbicher fir 31 Deeg halen. Wann Dir léiwer manner ze hunn, ännert 31 op 7 Deeg, gläichwäerteg eng Woch Wäert vu Logbicher. Dir sollt all Dag fir ModSecurity rotéieren. Wann Dir d'Protokolldateien muss iwwerpréiwen, déi eng wëchentlech Datei hunn, ass eng Katastroph fir ze siften, gitt wéi grouss et wäert sinn.

Kommentaren a Conclusioun

Am Allgemengen, ModSecurity op Äre Server z'installéieren gëtt direkt Schutz. Wéi och ëmmer, Gedold, Zäit an Engagement fir ze léieren wäerte sou eng super Feature sinn. Déi lescht Saach déi Dir wëllt ass SEO Bots ze blockéieren oder, méi wichteg, real Benotzer déi potenziell Cliente kënne sinn.

Vergiesst net d'Logbicher ze testen an ze kontrolléieren an de Sécherheetsniveau net ze héich ze setzen. Sou gutt wéi dës Software sinn, kënne se de legitimen Traffic ganz séier blockéieren an, ofhängeg ob Är Websäit eng Akommesquell ass, ka katastrofal Resultater hunn.



Follegt LinuxCapable.com!

Wëllt Dir automatesch Updates kréien? Follegt eis op ee vun eise soziale Medien Konten!