Les 24 meilleures pratiques de sécurité du serveur Web Nginx

Astuces, Reseaux & securite Aucun commentaire

Nginx est un serveur Web / proxy inverse léger et hautes performances et un proxy de messagerie électronique (IMAP / POP3). Il fonctionne sous UNIX, GNU / Linux, variantes BSD, Mac OS X, Solaris et Microsoft Windows. Selon Netcraft, 13,50% de tous les domaines sur Internet utilisent le serveur Web nginx. Nginx fait partie d’une poignée de serveurs écrits pour résoudre le problème C10K. Contrairement aux serveurs traditionnels, Nginx ne s’appuie pas sur les threads pour gérer les demandes. Au lieu de cela, il utilise une architecture événementielle (asynchrone) beaucoup plus évolutive. Nginx alimente plusieurs sites Web à fort trafic, tels que WordPress, Hulu, Github et SourceForge.

Cette page rassemble des conseils pour améliorer la sécurité des serveurs Web nginx fonctionnant sur des systèmes d’exploitation Linux ou UNIX.

Nginx est un serveur Web securite linux

 

Fichiers de configuration par défaut et port Nginx

  • /usr/local/nginx/conf/ ou /etc/nginx/– Le répertoire de configuration du serveur nginx et /usr/local/nginx/conf/nginx.conf est le fichier de configuration principal.
  • /usr/local/nginx/html/ ou /var/www/html– L’emplacement par défaut du document.
  • /usr/local/nginx/logs/ ou /var/log/nginx – Emplacement du fichier journal par défaut.
  • Nginx HTTP port par défaut : TCP 80
  • Nginx HTTPS port par défaut : TCP 443

Vous pouvez tester les modifications de configuration de nginx comme suit:
# /usr/local/nginx/sbin/nginx -t
OU
# nginx -t
Exemples de sorties:

le fichier de configuration /usr/local/nginx/conf/nginx.conf la syntaxe est ok
fichier de configuration /usr/local/nginx/conf/nginx.conf le test est réussi

Pour charger les modifications de configuration, tapez:
# /usr/local/nginx/sbin/nginx -s reload
OU
# nginx -s reload
Pour arrêter le serveur, tapez:
# /usr/local/nginx/sbin/nginx -s stop
OR
# nginx -s stop

1 Activez SELinux

Linux à sécurité renforcée (SELinux) est une fonctionnalité du noyau Linux qui fournit un mécanisme de prise en charge des politiques de sécurité de contrôle d’accès qui offre une excellente protection. Il peut arrêter de nombreuses attaques avant que votre système ne s’enracine. Découvrez comment activer SELinux pour les systèmes basés sur CentOS / RHEL.

Faire un verrouillage booléen

Exécutez la commande getsebool -a et le système de verrouillage:

getsebool -a | less
getsebool -a | grep off
getsebool -a | grep on

Pour sécuriser la machine, examinez les paramètres qui sont définis sur «on» et passez à «off» s’ils ne s’appliquent pas à votre configuration à l’aide de la commande setsebool. Définissez les booléens SE Linux appropriés pour maintenir la fonctionnalité et la protection. Veuillez noter que SELinux ajoute 2 à 8% de frais généraux à une installation RHEL ou CentOS typique.

2 Autoriser des privilèges minimaux via les options de montage

Servez tous vos fichiers webpages / html / php via des partitions séparées. Par exemple, créez une partition appelée / dev / sda5 et montez sur / nginx. Assurez-vous que / nginx est monté avec les autorisations noexec, nodev et nosetuid. Voici mon entrée / etc / fstab pour le montage / nginx:

LABEL=/nginx     /nginx          ext3   defaults,nosuid,noexec,nodev 1 2

Notez que vous devez créer une nouvelle partition à l’aide des commandes fdisk et mkfs.ext3.

3 Renforcement de Linux /etc/sysctl.conf

Vous pouvez contrôler et configurer le noyau Linux et les paramètres réseau via /etc/sysctl.conf.

# Évitez une attaque de schtroumpf
net.ipv4.icmp_echo_ignore_broadcasts = 1
 
# Activer la protection contre les mauvais messages d'erreur icmp
net.ipv4.icmp_ignore_bogus_error_responses = 1
 
# Activez les syncookies pour la protection contre les attaques par inondation SYN
net.ipv4.tcp_syncookies = 1
 
# Activer et journaliser les paquets usurpés, routés à la source et rediriger
net.ipv4.conf.all.log_martians = 1
net.ipv4.conf.default.log_martians = 1
 
# Aucun paquet routé source ici
net.ipv4.conf.all.accept_source_route = 0
net.ipv4.conf.default.accept_source_route = 0
 
# Activer le filtrage de chemin inverse
net.ipv4.conf.all.rp_filter = 1
net.ipv4.conf.default.rp_filter = 1
 
# Assurez-vous que personne ne peut modifier les tables de routage
net.ipv4.conf.all.accept_redirects = 0
net.ipv4.conf.default.accept_redirects = 0
net.ipv4.conf.all.secure_redirects = 0
net.ipv4.conf.default.secure_redirects = 0
 
# N'agissez pas comme un routeur
net.ipv4.ip_forward = 0
net.ipv4.conf.all.send_redirects = 0
net.ipv4.conf.default.send_redirects = 0
 
 
# Activez execshild
kernel.exec-shield = 1
kernel.randomize_va_space = 1
 
# Tournez IPv6
net.ipv6.conf.default.router_solicitations = 0
net.ipv6.conf.default.accept_ra_rtr_pref = 0
net.ipv6.conf.default.accept_ra_pinfo = 0
net.ipv6.conf.default.accept_ra_defrtr = 0
net.ipv6.conf.default.autoconf = 0
net.ipv6.conf.default.dad_transmits = 0
net.ipv6.conf.default.max_addresses = 1
 
# Optimisation de l'utilisation des ports pour les LB
# Augmenter la limite de descripteurs de fichiers système
fs.file-max = 65535
 
# Permettre plus de PID (pour réduire les problèmes de roulement); peut interrompre certains programmes 32768
kernel.pid_max = 65536
 
# Augmentez les limites du port IP du système
net.ipv4.ip_local_port_range = 2000 65000
 
# Augmenter la taille maximale de la mémoire tampon TCP configurable à l'aide de setsockopt()
net.ipv4.tcp_rmem = 4096 87380 8388608
net.ipv4.tcp_wmem = 4096 87380 8388608
 
# Augmenter les limites de tampon TCP de réglage automatique de Linux
# nombre minimal, par défaut et maximal d'octets à utiliser
# définissez max sur au moins 4 Mo, ou plus si vous utilisez des chemins BDP très élevés
# Tcp Windows etc
net.core.rmem_max = 8388608
net.core.wmem_max = 8388608
net.core.netdev_max_backlog = 5000
net.ipv4.tcp_window_scaling = 1

4 Supprimer tous les modules Nginx indésirables

Vous devez minimiser le nombre de modules qui sont compilés directement dans le binaire nginx. Cela minimise les risques en limitant les capacités autorisées par le serveur Web. Vous pouvez configurer et installer nginx en utilisant uniquement les modules requis. Par exemple, désactivez SSI et le module autoindex que vous pouvez taper:
# ./configure --without-http_autoindex_module --without-http_ssi_module
# make
# make install
Tapez la commande suivante pour voir quels modules peuvent être activés ou désactivés lors de la compilation du serveur nginx:
# ./configure --help | less
Désactivez les modules nginx dont vous n’avez pas besoin.

(Facultatif) Modifier l’en-tête de version de Nginx

Modifiez src / http / ngx_http_header_filter_module.c, entrez:
# vi +48 src/http/ngx_http_header_filter_module.c
Rechercher une ligne

static char ngx_http_server_string[] = "Server: nginx" CRLF;
static char ngx_http_server_full_string[] = "Server: " NGINX_VER CRLF;

Modifiez-les comme suit:

static char ngx_http_server_string[] = "Server: Ninja Web Server" CRLF;
static char ngx_http_server_full_string[] = "Server: Ninja Web Server" CRLF;

Enregistrez et fermez le fichier. Maintenant, vous pouvez compiler le serveur. Ajoutez ce qui suit dans nginx.conf pour désactiver le numéro de version de nginx affiché sur toutes les pages d’erreur générées automatiquement:

server_tokens off

5 Utiliser mod_security (uniquement pour les serveurs backend Apache)

mod_security fournit un pare-feu au niveau de l’application pour Apache. Installez mod_security pour tous les serveurs Web back-end Apache. Cela arrêtera de nombreuses attaques par injection.

6 Installer la stratégie SELinux pour durcir le serveur Web Nginx

Par défaut, SELinux ne protégera pas le serveur Web nginx. Cependant, vous pouvez installer et compiler la protection comme suit. Tout d’abord, installez le support de temps de compilation SELinux requis:
# yum -y install selinux-policy-targeted selinux-policy-devel
Téléchargez les politiques SELinux ciblées pour durcir le serveur Web nginx sur les serveurs Linux à partir du page d’accueil du projet :
# cd /opt
# wget 'http://downloads.sourceforge.net/project/selinuxnginx/se-ngix_1_0_10.tar.gz?use_mirror=nchc'
Détachez la même chose:
# tar -zxvf se-ngix_1_0_10.tar.gz
Compiler le même
# cd se-ngix_1_0_10/nginx
# make
Exemples de sorties:

Compiler le module nginx ciblé
/usr/bin/checkmodule:  chargement de la configuration de la politique de confidentialite depuis tmp/nginx.tmp
/usr/bin/checkmodule:  configuration de stratégie chargée
/usr/bin/checkmodule:  écrire une représentation binaire (version 6) to tmp/nginx.mod
Création ciblée nginx.pp paquet de politique de confidentialite
rm tmp/nginx.mod.fc tmp/nginx.mod

Installez le module SELinux nginx.pp résultant:
# /usr/sbin/semodule -i nginx.pp

7 Restrictive Iptables Based Firewall

Le script de pare-feu suivant bloque tout et autorise uniquement:

  • Demandes HTTP entrantes (port TCP 80)
  • Demandes ping ICMP entrantes
  • Demandes ntp sortantes (port 123)
  • Demandes SMTP sortantes (port TCP 25)
#!/bin/bash
IPT="/sbin/iptables"
 
#### IPS ######
# Obtenir l'IP publique du serveur
SERVER_IP=$(ifconfig eth0 | grep 'inet addr:' | awk -F'inet addr:' '{ print $2}' | awk '{ print $1}')
LB1_IP="204.54.1.1"
LB2_IP="204.54.1.2"
 
# Faites de la logique intelligente afin que nous puissions également utiliser le script damm sur LB2
OTHER_LB=""
SERVER_IP=""
[[ "$SERVER_IP" == "$LB1_IP" ]] && OTHER_LB="$LB2_IP" || OTHER_LB="$LB1_IP"
[[ "$OTHER_LB" == "$LB2_IP" ]] && OPP_LB="$LB1_IP" || OPP_LB="$LB2_IP"
 
### IPs ###
PUB_SSH_ONLY="122.xx.yy.zz/29"
 
#### FILES #####
BLOCKED_IP_TDB=/root/.fw/blocked.ip.txt
SPOOFIP="127.0.0.0/8 192.168.0.0/16 172.16.0.0/12 10.0.0.0/8 169.254.0.0/16 0.0.0.0/8 240.0.0.0/4 255.255.255.255/32 168.254.0.0/16 224.0.0.0/4 240.0.0.0/5 248.0.0.0/5 192.0.2.0/24"
BADIPS=$( [[ -f ${BLOCKED_IP_TDB} ]] && egrep -v "^#|^$" ${BLOCKED_IP_TDB})
 
### Interfaces ###
PUB_IF="eth0"   # public interface
LO_IF="lo"      # loopback
VPN_IF="eth1"   # vpn / private net
 
### start firewall ###
echo "Setting LB1 $(hostname) Firewall..."
 
# DROP et tout fermer
$IPT -P INPUT DROP
$IPT -P OUTPUT DROP
$IPT -P FORWARD DROP
 
# Accès lo illimité
$IPT -A INPUT -i ${LO_IF} -j ACCEPT
$IPT -A OUTPUT -o ${LO_IF} -j ACCEPT
 
# Accès vpn / pnet illimité
$IPT -A INPUT -i ${VPN_IF} -j ACCEPT
$IPT -A OUTPUT -o ${VPN_IF} -j ACCEPT
 
# Supprimer la synchronisation
$IPT -A INPUT -i ${PUB_IF} -p tcp ! --syn -m state --state NEW -j DROP
 
# Drop Fragments
$IPT -A INPUT -i ${PUB_IF} -f -j DROP
 
$IPT  -A INPUT -i ${PUB_IF} -p tcp --tcp-flags ALL FIN,URG,PSH -j DROP
$IPT  -A INPUT -i ${PUB_IF} -p tcp --tcp-flags ALL ALL -j DROP
 
# Drop NULL packets
$IPT  -A INPUT -i ${PUB_IF} -p tcp --tcp-flags ALL NONE -m limit --limit 5/m --limit-burst 7 -j LOG --log-prefix " NULL Packets "
$IPT  -A INPUT -i ${PUB_IF} -p tcp --tcp-flags ALL NONE -j DROP
 
$IPT  -A INPUT -i ${PUB_IF} -p tcp --tcp-flags SYN,RST SYN,RST -j DROP
 
# Drop XMAS
$IPT  -A INPUT -i ${PUB_IF} -p tcp --tcp-flags SYN,FIN SYN,FIN -m limit --limit 5/m --limit-burst 7 -j LOG --log-prefix " XMAS Packets "
$IPT  -A INPUT -i ${PUB_IF} -p tcp --tcp-flags SYN,FIN SYN,FIN -j DROP
 
# Drop FIN packet scans
$IPT  -A INPUT -i ${PUB_IF} -p tcp --tcp-flags FIN,ACK FIN -m limit --limit 5/m --limit-burst 7 -j LOG --log-prefix " Fin Packets Scan "
$IPT  -A INPUT -i ${PUB_IF} -p tcp --tcp-flags FIN,ACK FIN -j DROP
 
$IPT  -A INPUT -i ${PUB_IF} -p tcp --tcp-flags ALL SYN,RST,ACK,FIN,URG -j DROP
 
# Connectez-vous et supprimez la diffusion / multidiffusion et invalide
$IPT  -A INPUT -i ${PUB_IF} -m pkttype --pkt-type broadcast -j LOG --log-prefix " Broadcast "
$IPT  -A INPUT -i ${PUB_IF} -m pkttype --pkt-type broadcast -j DROP
 
$IPT  -A INPUT -i ${PUB_IF} -m pkttype --pkt-type multicast -j LOG --log-prefix " Multicast "
$IPT  -A INPUT -i ${PUB_IF} -m pkttype --pkt-type multicast -j DROP
 
$IPT  -A INPUT -i ${PUB_IF} -m state --state INVALID -j LOG --log-prefix " Invalid "
$IPT  -A INPUT -i ${PUB_IF} -m state --state INVALID -j DROP
 
# Enregistrer et bloquer les IPS usurpées
$IPT -N spooflist
for ipblock in $SPOOFIP
ou
         $IPT -A spooflist -i ${PUB_IF} -s $ipblock -j LOG --log-prefix " SPOOF List Block "
         $IPT -A spooflist -i ${PUB_IF} -s $ipblock -j DROP
terminé
$IPT -I INPUT -j spooflist
$IPT -I OUTPUT -j spooflist
$IPT -I FORWARD -j spooflist
 
# Autoriser ssh uniquement à partir d'ips publics sélectionnés pour ip in ${PUB_SSH_ONLY}
ou
        $IPT -A INPUT -i ${PUB_IF} -s ${ip} -p tcp -d ${SERVER_IP} --destination-port 22 -j ACCEPT
        $IPT -A OUTPUT -o ${PUB_IF} -d ${ip} -p tcp -s ${SERVER_IP} --sport 22 -j ACCEPT
terminé
 
# autoriser les trucs de ping-pong ICMP entrants
$IPT -A INPUT -i ${PUB_IF} -p icmp --icmp-type 8 -s 0/0 -m state --state NEW,ESTABLISHED,RELATED -m limit --limit 30/sec  -j ACCEPT
$IPT -A OUTPUT -o ${PUB_IF} -p icmp --icmp-type 0 -d 0/0 -m state --state ESTABLISHED,RELATED -j ACCEPT
 
# autoriser le port HTTP entrant 80
$IPT -A INPUT -i ${PUB_IF} -p tcp -s 0/0 --sport 1024:65535 --dport 80 -m state --state NEW,ESTABLISHED -j ACCEPT
$IPT -A OUTPUT -o ${PUB_IF} -p tcp --sport 80 -d 0/0 --dport 1024:65535 -m state --state ESTABLISHED -j ACCEPT
 
 
# autoriser le ntp sortant
$IPT -A OUTPUT -o ${PUB_IF} -p udp --dport 123 -m state --state NEW,ESTABLISHED -j ACCEPT
$IPT -A INPUT -i ${PUB_IF} -p udp --sport 123 -m state --state ESTABLISHED -j ACCEPT
 
# autoriser le smtp sortant
$IPT -A OUTPUT -o ${PUB_IF} -p tcp --dport 25 -m state --state NEW,ESTABLISHED -j ACCEPT
$IPT -A INPUT -i ${PUB_IF} -p tcp --sport 25 -m state --state ESTABLISHED -j ACCEPT
 
### ajoutez vos autres règles ici ####
 
#######################
# déposer et enregistrer tout le reste
$IPT -A INPUT -m limit --limit 5/m --limit-burst 7 -j LOG --log-prefix " DEFAULT DROP "
$IPT -A INPUT -j DROP
 
exit 0

 

8 Contrôle des attaques de dépassement de tampon

Modifiez nginx.conf et définissez les limitations de taille de tampon pour tous les clients.
# vi /usr/local/nginx/conf/nginx.conf
Modifiez et définissez les limitations de taille de tampon pour tous les clients comme suit:

 ## Début: limites de taille et débordements de tampon ##
  client_body_buffer_size  1K;
  client_header_buffer_size 1k;
  client_max_body_size 1k;
  large_client_header_buffers 2 1k;
 ## END: Limites de taille et débordements de tampon ##

Où,

  1. client_body_buffer_size 1k – (la valeur par défaut est 8k ou 16k) La directive spécifie la taille de la mémoire tampon du corps de la demande client.
  2. client_header_buffer_size 1k – La directive définit la taille du tampon de tête pour l’en-tête de demande du client. Pour la grande majorité des demandes, une taille de mémoire tampon de 1 Ko est suffisante. Augmentez cela si vous avez un en-tête personnalisé ou un gros cookie envoyé par le client (par exemple, client wap).
  3. client_max_body_size 1k– La directive attribue la taille maximale acceptée du corps de la demande du client, indiquée par la ligne Content-Length dans l’en-tête de la demande. Si la taille est supérieure à celle donnée, le client obtient l’erreur «Request Entity Too Large» (413). Augmentez cela lorsque vous obtenez des téléchargements de fichiers via la méthode POST.
  4. large_client_header_buffers 2 1k – La directive attribue le nombre et la taille maximum de tampons pour les grands en-têtes à lire à la demande du client. Par défaut, la taille d’un tampon est égale à la taille de la page, selon la plate-forme, soit 4K ou 8K, si à la fin de la demande de travail, la connexion se convertit en état de conservation, ces tampons sont libérés. 2x1k acceptera l’URI de données de 2kB. Cela aidera également à combattre les mauvais robots et les attaques DoS.

Vous devez également contrôler les délais d’expiration pour améliorer les performances du serveur et couper les clients. Modifiez-le comme suit:

 ## Start: Timeouts ##
  client_body_timeout   10;
  client_header_timeout 10;
  keepalive_timeout     5 5;
  send_timeout          10;
## End: Timeouts ##
  1. client_body_timeout 10; – La directive définit le délai de lecture pour le corps de la demande du client. Le délai d’expiration n’est défini que si un corps n’est pas en une seule étape de lecture. Si après cette heure, le client n’envoie rien, nginx renvoie l’erreur «Request time out» (408). La valeur par défaut est 60.
  2. client_header_timeout 10; – La directive attribue un délai à la lecture du titre de la demande du client. Le délai d’attente n’est défini que si un en-tête n’est pas obtenu en une seule lecture. Si après cette heure, le client n’envoie rien, nginx renvoie l’erreur «Request time out» (408).
  3. keepalive_timeout 5 5; – Le premier paramètre affecte le délai d’expiration des connexions persistantes avec le client. Le serveur fermera les connexions après cette heure. Le deuxième paramètre facultatif affecte la valeur de temps dans l’en-tête Keep-Alive: timeout = heure de la réponse. Cet en-tête peut convaincre certains navigateurs de fermer la connexion, ce qui évite au serveur de le faire. Sans ce paramètre, nginx n’envoie pas d’en-tête Keep-Alive (bien que ce ne soit pas ce qui rend une connexion «keep-alive»).
  4. send_timeout 10; – La directive attribue un délai de réponse au client. Le délai d’attente n’est pas établi sur le transfert complet de la réponse, mais seulement entre deux opérations de lecture, si après ce temps le client ne prend rien, alors nginx ferme la connexion.

9 Contrôlez les connexions simultanées

Vous pouvez utiliser le module Nginx Http TimeZone pour limiter le nombre de connexions simultanées pour la session attribuée ou, dans un cas particulier, à partir d’une seule adresse IP. Modifiez nginx.conf:

### La directive décrit la zone dans laquelle les états de session sont stockés, c'est-à-dire stockés dans des slimits. ###
### 1m peut gérer 32000 sessions avec 32 octets / session, défini sur 5m x 32000 session ###
       limit_zone slimits $binary_remote_addr 5m;
 
### Contrôlez le nombre maximum de connexions simultanées pour une session i.e. ###
### restreint la quantité de connexions à partir d'une seule adresse IP ###
        limit_conn slimits 5;

Ce qui précède limitera les clients distants à pas plus de 5 connexions simultanées «ouvertes» par adresse IP distante.

10 Autoriser l’accès à votre domaine uniquement

Si le bot fait juste une analyse aléatoire du serveur pour tous les domaines, il suffit de le refuser. Vous ne devez autoriser que les demandes de domaine virtuel configurées ou de proxy inverse. Vous ne souhaitez pas afficher la demande à l’aide d’une adresse IP:

## Seules les demandes à notre hôte sont autorisées, à savoir nixcraft.in, images.nixcraft.in et www.nixcraft.in
      if ($host !~ ^(nixcraft.in|www.nixcraft.in|images.nixcraft.in)$ ) {
         return 444;
      }
##

11 Limiter les méthodes disponibles

GET et POST sont les méthodes les plus courantes sur Internet. Les méthodes de serveur Web sont définies dans la RFC 2616. Si un serveur Web ne nécessite pas la mise en œuvre de toutes les méthodes disponibles, elles doivent être désactivées. Les éléments suivants filtrent et autorisent uniquement les méthodes GET, HEAD et POST:

## Autoriser uniquement ces méthodes de demande ##
     if ($request_method !~ ^(GET|HEAD|POST)$ ) {
         return 444;
     }
## N'acceptez pas DELETE, SEARCH et d'autres méthodes ##

En savoir plus sur les méthodes HTTP

  • La méthode GET est utilisée pour demander un document tel que http://www.congohacking.com/index.php.
  • La méthode HEAD est identique à GET sauf que le serveur NE DOIT PAS retourner un corps de message dans la réponse.
  • La méthode POST peut impliquer n’importe quoi, comme stocker ou mettre à jour des données, ou commander un produit, ou envoyer un e-mail en soumettant le formulaire. Ceci est généralement traité à l’aide des scripts côté serveur tels que PHP, PERL, Python, etc.
  • Vous devez l’utiliser si vous souhaitez télécharger des fichiers et traiter des formulaires sur le serveur.

12 Comment refuser certains agents utilisateurs?

Vous pouvez facilement bloquer les agents utilisateurs, c’est-à-dire les scanners, les robots et les spammeurs qui peuvent abuser de votre serveur.

## Bloquer les agents de téléchargement ##
     if ($http_user_agent ~* LWP::Simple|BBBike|wget) {
            return 403;
     }
##

Bloquer les robots appelés msnbot et scrapbot:

## Bloquer certains robots ##
     if ($http_user_agent ~* msnbot|scrapbot) {
            return 403;
     }

12 Comment bloquer le spam de parrainage?

Le spam référent est dangereux. Cela peut nuire à votre classement SEO via les journaux Web (s’ils sont publiés) car le champ référent fait référence à leur site de spam. Vous pouvez bloquer l’accès aux spammeurs référents avec ces lignes.

## Refuser certains référents ###
     if ( $http_referer ~* (babes | à vendre | fille | bijoux | amour | nudité | organique | poker | porno | sexe | adolescent) 
     {
         # return 404;
         return 403;
     }
##

13 Comment puis-je arrêter le hotlinking d’images??

Le lien d’images ou HTML signifie que quelqu’un crée un lien vers votre site vers l’une de vos images, mais l’affiche sur son propre site. Le résultat final, vous finirez par payer les factures de bande passante et faire ressembler le contenu à une partie du site du pirate de l’air. Cela se fait généralement sur les forums et les blogs. Je vous suggère fortement de bloquer et d’arrêter le hotlinking d’image au niveau de votre serveur lui-même.

# Arrêter les liens profonds ou les liens chauds
location /images/ {
  valid_referers aucun bloqué www.exemple.com exemple.com;
   if ($invalid_referer) {
     return   403;
   }
}

Exemple: réécriture et affichage de l’image

Un autre exemple avec un lien vers une image interdite:

valid_referers bloqué www.exemple.com exemple.com;
 if ($invalid_referer) {
  rewrite ^/images/uploads.*\.(gif|jpg|jpeg|png)$ http://www.exemples.com/banned.jpg last
 }

 

14 Restrictions de répertoires

Vous pouvez définir le contrôle d’accès pour un répertoire spécifié. Tous les répertoires Web doivent être configurés au cas par cas, permettant l’accès uniquement en cas de besoin.

Limiter l’accès par adresse IP

Vous pouvez limiter l’accès au répertoire par adresse IP à / médecins / répertoire:

location /docs/ {
  ## block one workstation
  deny    192.168.1.1;

  ## allow anyone in 192.168.1.0/24
  allow   192.168.1.0/24;

  ## drop rest of the world
  deny    all;
}

Mot de passe protéger le répertoire

Créez d’abord le fichier de mot de passe et ajoutez un utilisateur appelé vivek:
# mkdir /usr/local/nginx/conf/.htpasswd/
# htpasswd -c /usr/local/nginx/conf/.htpasswd/passwd vivek
Modifiez nginx.conf et protégez les répertoires requis comme suit:

### Protection par mot de passe / répertoires-images-personnelles / et / delta / ###
location ~ /(personal-images/.*|delta/.*) {
  auth_basic  "Restricted";
  auth_basic_user_file   /usr/local/nginx/conf/.htpasswd/passwd;
}

Une fois qu’un fichier de mot de passe a été généré, les utilisateurs suivants peuvent être ajoutés avec la commande suivante:
# htpasswd -s /usr/local/nginx/conf/.htpasswd/passwd userName

15 Configuration SSL Nginx

HTTP est un protocole en texte brut et il est ouvert à la surveillance passive. Vous devez utiliser SSL pour crypter votre contenu pour les utilisateurs:

  1. HowTo: créer un certificat SSL auto-signé sur Nginx pour CentOS / RHEL 
  2. Comment configurer Nginx avec le certificat SSL Let’s Encrypt gratuit sur Debian ou Ubuntu Linux 
  3. Comment installer le certificat Letsencrypt gratuit SSL / TLS pour Nginx sur Alpine Linux 
  4. Comment configurer le passthrough SSL / TLS Nginx avec l’équilibrage de charge TCP 
  5. nginx: Configuration du proxy inverse SSL (proxy SSL à charge équilibrée)

16 Conseils de sécurité Nginx et PHP

PHP est l’un des langages de script côté serveur les plus populaires. Modifiez /etc/php.ini comme suit:

# Disallow dangerous functions
disable_functions = phpinfo, system, mail, exec
 
## Try to limit resources  ##
 
# Maximum execution time of each script, in seconds
max_execution_time = 30
 
# Maximum amount of time each script may spend parsing request data
max_input_time = 60
 
# Maximum amount of memory a script may consume (8MB)
memory_limit = 8M
 
# Maximum size of POST data that PHP will accept.
post_max_size = 8M
 
# Whether to allow HTTP file uploads.
file_uploads = Off
 
# Maximum allowed size for uploaded files.
upload_max_filesize = 2M
 
# Do not expose PHP error messages to external users
display_errors = Off
 
# Turn on safe mode
safe_mode = On
 
# Only allow access to executables in isolated directory
safe_mode_exec_dir = php-required-executables-path
 
# Limit external access to PHP environment
safe_mode_allowed_env_vars = PHP_
 
# Restrict PHP information leakage
expose_php = Off
 
# Log all errors
log_errors = On
 
# Do not register globals for input data
register_globals = Off
 
# Minimize allowable PHP post size
post_max_size = 1K
 
# Ensure PHP redirects appropriately
cgi.force_redirect = 0
 
# Disallow uploading unless necessary
file_uploads = Off
 
# Enable SQL safe mode
sql.safe_mode = On
 
# Avoid Opening remote files
allow_url_fopen = Off

 

17 Exécutez Nginx dans une prison Chroot (conteneurs) si possible

Mettre nginx dans une prison chroot minimise les dommages causés par une effraction potentielle en isolant le serveur Web sur une petite section du système de fichiers. Vous pouvez utiliser une configuration chroot traditionnelle avec nginx. Si possible, utilisez les prisons FreeBSD, XEN, les conteneurs Linux sur Debian / Ubuntu, LXD sur Fedora ou la virtualisation OpenVZ qui utilise le concept de conteneurs.

18 Limite les connexions par IP au niveau du pare-feu

Un serveur Web doit garder un œil sur les connexions et limiter les connexions par seconde. Cela sert 101. Les deux pf et iptables peuvent étrangler les utilisateurs finaux avant d’accéder à votre serveur nginx.

Iptables Linux: accélération des connexions Nginx par seconde

L’exemple suivant supprimera les connexions entrantes si IP effectue plus de 15 tentatives de connexion au port 80 dans les 60 secondes:

/sbin/iptables -A INPUT -p tcp --dport 80 -i eth0 -m state --state NEW -m recent --set
/sbin/iptables -A INPUT -p tcp --dport 80 -i eth0 -m state --state NEW -m recent --update --seconds 60  --hitcount 15 -j DROP
service iptables save

BSD PF: Connexions de l’accélérateur Nginx par seconde

Modifiez votre /etc/pf.conf et mettez-le à jour comme suit. Les éléments suivants limiteront le nombre maximal de connexions par source à 100. 15/5 spécifie le nombre de connexions par seconde ou intervalle de secondes, c’est-à-dire limiter le nombre de connexions à 15 dans un intervalle de 5 secondes. Si quelqu’un enfreint nos règles, ajoutez-les à notre table abusive_ips et bloquez-les pour établir d’autres connexions. Enfin, le mot clé flush tue tous les états créés par la règle de correspondance provenant de l’hôte qui dépasse ces limites.

webserver_ip="202.54.1.1"
table <abusive_ips> persist
block in quick from <abusive_ips>
pass in on $ext_if proto tcp to $webserver_ip port www flags S/SA keep state (max-src-conn 100, max-src-conn-rate 15/5, overload <abusive_ips> flush)

 

19 Configurer le système d’exploitation pour protéger le serveur Web

Activez SELinux comme décrit ci-dessus. Définissez les autorisations correctes sur la racine du document / nginx. Le nginx s’exécute en tant qu’utilisateur nommé nginx. Cependant, les fichiers dans DocumentRoot (/ nginx ou / usr / local / nginx / html) ne doivent pas être détenus ou accessibles en écriture par cet utilisateur. Pour rechercher des fichiers avec des autorisations incorrectes, utilisez:
# find /nginx -user nginx
# find /usr/local/nginx/html -user nginx
Assurez-vous de changer la propriété du fichier en root ou autre utilisateur. Un ensemble typique de permissions / usr / local / nginx / html /
# ls -l /usr/local/nginx/html/
Exemples de sorties:

-rw-r--r-- 1 root root 925 Jan  3 00:50 error4xx.html
-rw-r--r-- 1 root root  52 Jan  3 10:00 error5xx.html
-rw-r--r-- 1 root root 134 Jan  3 00:52 index.html

Vous devez supprimer les fichiers de sauvegarde indésirables créés par vi ou un autre éditeur de texte:
# find /nginx -name '.?*' -not -name .ht* -or -name '*~' -or -name '*.bak*' -or -name '*.old*'
# find /usr/local/nginx/html/ -name '.?*' -not -name .ht* -or -name '*~' -or -name '*.bak*' -or -name '*.old*'

Passez l’option -delete pour trouver la commande et elle se débarrassera également de ces fichiers.

20 Restreindre les connexions Nginx sortantes

Les crackers téléchargeront le fichier localement sur votre serveur à l’aide d’outils tels que wget. Utilisez iptables pour bloquer les connexions sortantes de l’utilisateur nginx. Le module ipt_owner tente de faire correspondre différentes caractéristiques du créateur de paquets, pour les paquets générés localement. Il n’est valable que dans la chaîne OUTPUT. Dans cet exemple, autorisez l’utilisateur vivek à se connecter à l’extérieur à l’aide du port 80 (utile pour l’accès RHN ou pour récupérer les mises à jour de CentOS via les repos):

/sbin/iptables -A OUTPUT -o eth0 -m owner --uid-owner vivek -p tcp --dport 80 -m state --state NEW,ESTABLISHED  -j ACCEPT

Ajoutez la règle ci-dessus à votre script shell basé sur iptables. N’autorisez pas l’utilisateur du serveur Web nginx à se connecter à l’extérieur.

21 Gardez votre logiciel à jour

Vous devez garder votre logiciel et votre noyau à jour à tout moment. Appliquez le patch selon votre version ou distribution. Si vous utilisez un Debian / Ubuntu Linux, utilisez la commande apt-get / apt pour appliquer des correctifs:
$ sudo apt-get update
$ sudo apt-get upgrade
Si vous utilisez un RHEL / CentOS / Oracle / Scientific Linux, utilisez la commande yum:
$ sudo yum update
Si vous utilisez une commande Alpine Linux, utilisez la commande apk:
# apk update
# apk upgrade

22  Évitez le détournement de clics

Ajoutez les éléments suivants dans votre nginx.conf ou domaine virtuel pour éviter le détournement de clics:
add_header X-Frame-Options SAMEORIGIN;

23  Désactiver le reniflement de type de contenu sur certains navigateurs

Ajoutez les éléments suivants dans votre nginx.conf ou domaine virtuel:
add_header X-Content-Type-Options nosniff;

24  Activer le filtre de script intersite (XSS)

Activer le filtre de script intersite (XSS)
add_header X-XSS-Protection "1; mode=block";

 

Astuce Bounce: surveiller vos journaux et effectuer des audits

Vérifiez les fichiers journaux. Ils vous permettront de comprendre quelles attaques sont lancées contre le serveur et vous permettront de vérifier si le niveau de sécurité nécessaire est présent ou non.
# grep "/login.php??" /usr/local/nginx/logs/access_log
# grep "...etc/passwd" /usr/local/nginx/logs/access_log
# egrep -i "denied|error|warn" /usr/local/nginx/logs/error_log
Le service auditd est fourni pour l’audit du système. Activez-le pour auditer les événements SELinux du service, les événements d’authentification, les modifications de fichier, la modification de compte, etc. Comme d’habitude, désactivez tous les services et suivez nos conseils de sécurité «Renforcement du serveur Linux».

Conclusion

Votre serveur nginx est maintenant correctement durci et prêt à accueillir des pages Web. Cependant, vous devriez être consulté d’autres ressources pour vos besoins de sécurité des applications Web. Par exemple, wordpress ou toute autre application tierce a ses propres exigences de sécurité.

Related Posts

About The Author

admin

No Responses

Leave a Reply