Ricerca nel sito web

Installa ModSecurity con Apache in un contenitore Docker


Su questa pagina

  1. Requisiti
  2. Per iniziare
  3. Installa Docker
  4. Crea un Dockerfile per ModSecurity
  5. Crea l'immagine Apache ModSecurity e avvia il contenitore
  6. Verifica ModSecurity
  7. Conclusione

ModSecurity è un web application firewall (WAF) gratuito, open-source e molto diffuso che protegge la tua applicazione web da un'ampia gamma di attacchi Layer 7. È stato progettato per il monitoraggio, la registrazione e il filtraggio delle richieste del server Web Apache. Viene fornito con un set di regole di base che rileva e blocca diversi attacchi tra cui SQL injection, cross-site scripting, trojan, agenti utente dannosi, dirottamento di sessione e altro.

In questo tutorial, ti mostrerò come installare ModSecurity 3 con Apache all'interno di un container Docker.

Requisiti

  • Un server che esegue Ubuntu 20.04.
  • Una password di root è configurata sul tuo server.

Iniziare

Innanzitutto, si consiglia di aggiornare il sistema all'ultima versione. Puoi aggiornarlo con il seguente comando:

apt-get update -y

Una volta che il tuo sistema è aggiornato, dovrai installare alcune dipendenze sul tuo sistema. Puoi installarli tutti con il seguente comando:

apt-get install apt-transport-https ca-certificates curl gnupg2 software-properties-common -y

Una volta installate tutte le dipendenze, puoi procedere al passaggio successivo.

Installa Docker

Successivamente, dovrai installare Docker CE sul tuo sistema. Per impostazione predefinita, l'ultima versione di Docker non è inclusa nel repository predefinito di Ubuntu. Quindi dovrai aggiungere il repository ufficiale Docker all'APT.

Innanzitutto, scarica e aggiungi la chiave GPG Docker con il seguente comando:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -

Successivamente, aggiungi il repository Docker CE all'elenco delle sorgenti APT con il seguente comando:

echo "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -sc) stable" > /etc/apt/sources.list.d/docker-ce.list

Una volta aggiunto il repository, aggiorna il repository con il seguente comando:

apt-get update -y

Una volta aggiornato il repository, installa l'ultima versione di Docker CE con il seguente comando:

apt-get install docker-ce -y

Dopo aver installato Docker CE, verificare la versione installata di Docker CE con il seguente comando:

docker --version

Dovresti ottenere il seguente output:

Docker version 20.10.6, build 370c289

Puoi anche controllare lo stato del servizio Docker con il seguente comando:

systemctl status docker

Dovresti ottenere il seguente output:

? docker.service - Docker Application Container Engine
     Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
     Active: active (running) since Sun 2021-05-16 06:49:29 UTC; 38s ago
TriggeredBy: ? docker.socket
       Docs: https://docs.docker.com
   Main PID: 8964 (dockerd)
      Tasks: 8
     Memory: 40.6M
     CGroup: /system.slice/docker.service
             ??8964 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock

May 16 06:49:29 ubunt4 dockerd[8964]: time="2021-05-16T06:49:29.365433228Z" level=warning msg="Your kernel does not support swap memory li>
May 16 06:49:29 ubunt4 dockerd[8964]: time="2021-05-16T06:49:29.365916961Z" level=warning msg="Your kernel does not support cgroup blkio w>
May 16 06:49:29 ubunt4 dockerd[8964]: time="2021-05-16T06:49:29.366112111Z" level=warning msg="Your kernel does not support cgroup blkio w>
May 16 06:49:29 ubunt4 dockerd[8964]: time="2021-05-16T06:49:29.366653374Z" level=info msg="Loading containers: start."
May 16 06:49:29 ubunt4 dockerd[8964]: time="2021-05-16T06:49:29.498790388Z" level=info msg="Default bridge (docker0) is assigned with an I>
May 16 06:49:29 ubunt4 dockerd[8964]: time="2021-05-16T06:49:29.576691602Z" level=info msg="Loading containers: done."
May 16 06:49:29 ubunt4 dockerd[8964]: time="2021-05-16T06:49:29.610542206Z" level=info msg="Docker daemon" commit=8728dd2 graphdriver(s)=o>
May 16 06:49:29 ubunt4 dockerd[8964]: time="2021-05-16T06:49:29.611668583Z" level=info msg="Daemon has completed initialization"
May 16 06:49:29 ubunt4 systemd[1]: Started Docker Application Container Engine.
May 16 06:49:29 ubunt4 dockerd[8964]: time="2021-05-16T06:49:29.690496888Z" level=info msg="API listen on /run/docker.sock"
lines 1-21/21 (END)

Una volta terminato, puoi procedere al passaggio successivo.

Crea un Dockerfile per ModSecurity

Successivamente, dovrai creare un Dockerfile per installare ModSecurity all'interno del contenitore Ubuntu.

Innanzitutto, cambia la directory in /opt e crea un file modsec_rules.conf con il seguente comando:

cd /opt
nano modsec_rules.conf

Aggiungi le seguenti righe:

Include "/etc/apache2/modsecurity.d/modsecurity.conf"
Include "/etc/apache2/modsecurity.d/owasp-crs/crs-setup.conf"
Include "/etc/apache2/modsecurity.d/owasp-crs/rules/*.conf"

Salva e chiudi il file quindi crea un altro file con il seguente comando:

nano 000-default.conf

Aggiungi le seguenti righe:

<VirtualHost *:80>
	modsecurity on
	modsecurity_rules_file /etc/apache2/modsecurity.d/modsec_rules.conf 
	ServerAdmin 
	DocumentRoot /var/www/html
	ErrorLog ${APACHE_LOG_DIR}/error.log
	CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

Salva e chiudi il file quando hai finito. Dockerfile copierà i file precedenti nel contenitore Docker durante il processo di compilazione.

Infine, crea un Dockerfile con il seguente comando:

nano Dockerfile

Aggiungi le seguenti righe:

# Install Modsecurity in a Docker container;
FROM ubuntu:latest
ARG DEBIAN_FRONTEND=noninteractive
# update/upgrade your system
RUN apt-get update -y

# Install Required Dependencies
RUN apt-get install -y g++ flex bison curl apache2-dev \
	doxygen libyajl-dev ssdeep liblua5.2-dev \
	libgeoip-dev libtool dh-autoreconf \
	libcurl4-gnutls-dev libxml2 libpcre++-dev \
	libxml2-dev git wget tar apache2

# Download LibModsecurity 
RUN wget https://github.com/SpiderLabs/ModSecurity/releases/download/v3.0.4/modsecurity-v3.0.4.tar.gz

# Extract the Downloaded File
RUN tar xzf modsecurity-v3.0.4.tar.gz && rm -rf modsecurity-v3.0.4.tar.gz

# Compile and Install LibModsecurity
RUN cd modsecurity-v3.0.4 && \
	./build.sh && ./configure && \
	make && make install

# Install ModSecurity-Apache Connector
RUN cd ~ && git clone https://github.com/SpiderLabs/ModSecurity-apache

RUN cd ~/ModSecurity-apache && \
	./autogen.sh && \
	./configure --with-libmodsecurity=/usr/local/modsecurity/ && \
	make && \
	make install

# Load the Apache ModSecurity Connector Module
RUN echo "LoadModule security3_module /usr/lib/apache2/modules/mod_security3.so" >> /etc/apache2/apache2.conf

# Configure ModSecurity
RUN mkdir /etc/apache2/modsecurity.d && \
	cp modsecurity-v3.0.4/modsecurity.conf-recommended /etc/apache2/modsecurity.d/modsecurity.conf && \
	cp modsecurity-v3.0.4/unicode.mapping /etc/apache2/modsecurity.d/ && \
	sed -i 's/SecRuleEngine DetectionOnly/SecRuleEngine On/' /etc/apache2/modsecurity.d/modsecurity.conf
ADD modsec_rules.conf /etc/apache2/modsecurity.d/

# Install OWASP ModSecurity Core Rule Set (CRS) on Ubuntu
RUN git clone https://github.com/SpiderLabs/owasp-modsecurity-crs.git /etc/apache2/modsecurity.d/owasp-crs && \
	cp /etc/apache2/modsecurity.d/owasp-crs/crs-setup.conf.example /etc/apache2/modsecurity.d/owasp-crs/crs-setup.conf

# Activate ModSecurity
RUN mv /etc/apache2/sites-available/000-default.conf /etc/apache2/sites-available/000-default.conf.old
ADD 000-default.conf /etc/apache2/sites-available/

EXPOSE 80
CMD apachectl -D FOREGROUND

Salva e chiudi il file quando hai finito.

Il file sopra scaricherà l'immagine di Ubuntu, installerà tutte le dipendenze, scaricherà ModSecurity, lo compilerà e configurerà Apache per lavorare con ModSecurity.

A questo punto, Dockerfile è pronto. Ora puoi procedere al passaggio successivo.

Crea l'immagine Apache ModSecurity e avvia il contenitore

Ora, cambia la directory in /opt e crea l'immagine Docker per Apache ModSecurity con il seguente comando:

cd /opt
docker build .

Una volta completato il processo di compilazione, dovresti ottenere il seguente output:

Step 13/17 : RUN git clone https://github.com/SpiderLabs/owasp-modsecurity-crs.git /etc/apache2/modsecurity.d/owasp-crs && 	cp /etc/apache2/modsecurity.d/owasp-crs/crs-setup.conf.example /etc/apache2/modsecurity.d/owasp-crs/crs-setup.conf
 ---> Running in 00dfa2a5cd23
Cloning into '/etc/apache2/modsecurity.d/owasp-crs'...
Removing intermediate container 00dfa2a5cd23
 ---> b38c1d874d2f
Step 14/17 : RUN mv /etc/apache2/sites-available/000-default.conf /etc/apache2/sites-available/000-default.conf.old
 ---> Running in 12c9e6d2c559
Removing intermediate container 12c9e6d2c559
 ---> 899e26019297
Step 15/17 : ADD 000-default.conf /etc/apache2/sites-available/
 ---> eb11751afd6c
Step 16/17 : EXPOSE 80
 ---> Running in 2f4ba47e2b66
Removing intermediate container 2f4ba47e2b66
 ---> dd59b0ac7c7c
Step 17/17 : CMD apachectl -D FOREGROUND
 ---> Running in 98b8cc77df0f
Removing intermediate container 98b8cc77df0f
 ---> f603dbc38018
Successfully built f603dbc38018

Ora puoi elencare tutte le immagini docker utilizzando il seguente comando:

docker images

Dovresti ottenere il seguente output:

REPOSITORY   TAG       IMAGE ID       CREATED          SIZE
           f603dbc38018   32 seconds ago   2.48GB
ubuntu       latest    7e0aa2d69a15   3 weeks ago      72.7MB

Ora, seleziona il primo ID immagine dall'output precedente e avvia il contenitore Apache ModSecurity con il seguente comando:

docker run --name modsec-apache -ditp 80:80 f603dbc38018

Dovresti ottenere il seguente output:

40eb0e77e61635c3cee2bfaffbd9489bc7d20aa3e1befb52749de079aaadb528

Ora puoi verificare il contenitore in esecuzione con il seguente comando:

docker ps

Dovresti ottenere il seguente output:

CONTAINER ID   IMAGE          COMMAND                  CREATED          STATUS          PORTS                               NAMES
40eb0e77e616   f603dbc38018   "/bin/sh -c 'apachec…"   17 seconds ago   Up 15 seconds   0.0.0.0:80->80/tcp, :::80->80/tcp   modsec-apache

Come puoi vedere, il contenitore ModSecurity è avviato e in ascolto sulla porta 80.

Verificare ModSecurity

A questo punto, il contenitore ModSecurity è in esecuzione. Ora è il momento di verificare se le regole di ModSecurity bloccano o meno le richieste dannose.

Per fare ciò, apri il tuo terminale ed esegui il seguente comando:

curl localhost?doc=/bin/ls

Dovresti vedere il seguente output:

<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
<html><head>
<title>403 Forbidden</title>
</head><body>
<h1>Forbidden</h1>
<p>You don't have permission to access this resource.</p>
<hr>
<address>Apache/2.4.41 (Ubuntu) Server at localhost Port 80</address>
</body></html>

Dovresti vedere l'errore \403 Forbidden\. Perché ModSecurity ha bloccato la richiesta di cui sopra.

Puoi anche controllare il registro di Apache per ulteriori informazioni.

Per fare ciò, per prima cosa, connettiti al contenitore con il seguente comando:

docker exec -it modsec-apache /bin/bash

Una volta connesso, dovresti ottenere la seguente shell:

:/#

Ora, controlla il registro di Apache con il seguente comando:

tail -f /var/log/apache2/error.log

Dovresti vedere che ModSecurity ha bloccato la richiesta dannosa:

[Sun May 16 07:24:54.456327 2021] [mpm_event:notice] [pid 15:tid 140204464299072] AH00489: Apache/2.4.41 (Ubuntu) configured -- resuming normal operations
[Sun May 16 07:24:54.456352 2021] [core:notice] [pid 15:tid 140204464299072] AH00094: Command line: '/usr/sbin/apache2 -D FOREGROUND'
[Sun May 16 07:25:36.680515 2021] [:error] [pid 16:tid 140204216108800] [client 172.17.0.1:45298] ModSecurity: Warning. Matched "Operator `PmFromFile' with parameter `unix-shell.data' against variable `ARGS:doc' (Value: `/bin/ls' ) [file "/etc/apache2/modsecurity.d/owasp-crs/rules/REQUEST-932-APPLICATION-ATTACK-RCE.conf"] [line "496"] [id "932160"] [rev ""] [msg "Remote Command Execution: Unix Shell Code Found"] [data "Matched Data: bin/ls found within ARGS:doc: /bin/ls"] [severity "2"] [ver "OWASP_CRS/3.2.0"] [maturity "0"] [accuracy "0"] [tag "application-multi"] [tag "language-shell"] [tag "platform-unix"] [tag "attack-rce"] [tag "paranoia-level/1"] [tag "OWASP_CRS"] [tag "OWASP_CRS/WEB_ATTACK/COMMAND_INJECTION"] [tag "WASCTC/WASC-31"] [tag "OWASP_TOP_10/A1"] [tag "PCI/6.5.2"] [hostname "172.17.0.2"] [uri "/"] [unique_id "162114993662.860969"] [ref "o1,6v10,7t:urlDecodeUni,t:cmdLine,t:normalizePath,t:lowercase"]

Conclusione

Congratulazioni! hai installato correttamente ModSecurity all'interno del contenitore Docker. Spero che ora tu abbia abbastanza conoscenze per implementare questa soluzione nell'ambiente Docker. Non esitate a chiedermi se avete domande.