
- dernier cas, l'authentification sécurisée : elle fait appel au protocole SSL (ou sa version standardisée, TLS) pour les échanges de données, ce qui évite que les mots de passe circulent en clair sur le réseau. Pour l'utiliser, il faut faire des requêtes de type https://... sur un serveur correctement configuré.
|
|
GET http://www.securiteinfo.com/restricted_zone/ HTTP/1.0 Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/vnd.ms-excel, application/msword, application/vnd.ms-powerpoint, */* Accept-Language: fr User-Agent: Mozilla/4.0 (compatible; MSIE 5.5; Windows NT 4.0) Host: www.securiteinfo.com Proxy-Connection: Keep-Alive HTTP/1.1 401 Authorization Required Via: 1.1 PROXY2 Connection: close Content-type: text/html; charset=iso-8859-1 Date: Wed, 22 Aug 2001 15:25:40 GMT Server: Apache/1.3.12 (Unix) Debian/GNU mod_perl/1.24 Www-authenticate: Basic realm="Acces Restreint" GET http://www.securiteinfo.com/restricted_zone/ HTTP/1.0 Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/vnd.ms-excel, application/msword, application/vnd.ms-powerpoint, */* Accept-Language: fr Authorization: Basic QWxpY2U6TGFwaW4= User-Agent: Mozilla/4.0 (compatible; MSIE 5.5; Windows NT 4.0) Host: www.securiteinfo.com Proxy-Connection: Keep-Alive HTTP/1.1 200 OK Via: 1.1 PROXY2 Connection: close Content-type: text/html Date: Wed, 22 Aug 2001 15:25:45 GMT Server: Apache/1.3.12 (Unix) Debian/GNU mod_perl/1.24 |
Explications :
* L'utilisateur souhaite accéder à une page web qui s'avère être protégée par htaccess. Concrètement, il y a 2 échanges requête/réponse HTTP qui sont éffectués pour donner accès à cette page.
* Le premier est une requête simple (un GET) signifiant que le client souhaite accéder à la page. La réponse est "401 Authorization Required", ce qui signifie que la page est protégée et nécessite une authentification (de type "Basic"). L'utilisateur ne voit pas cette réponse, seul le navigateur (browser) la voit et affiche en réponse une popup dans laquelle il demande à l'utilisateur de taper son login et mot de passe.
* Après cette opération, le navigateur réitère son GET en ajoutant cette fois-ci les informations de l'utilisateur ("Authorization: Basic QWxpY2U6TGFwaW4=") qui serviront au serveur pour l'authentifier.
* Si tout se passe bien, la requête est acceptée ("200 OK") et l'utilisateur peut accéder à la page web.
Nous avons ici le cas le plus simple : les informations de l'utilisateur circulent quasiment en clair sur le réseau. Prenons l'élément "crypté" : QWxpY2U6TGFwaW4=. Cet élément est en fait "login:password" uuencodé en base 64, ce qui n'est d'aucune protection (l'uuencodage est un procédé servant à coder du binaire en ASCII et inversement, autrement dit de passer de 24 à 32 bits tout en restant dans l'intervalle des caractères imprimables, ce qui permet de transférer des fichiers binaires sous forme de texte par exemple).
Copions cet élément dans un fichier type :
begin-base64 644 my_file
QWxpY2U6TGFwaW4=
====
Un simple passage dans la fonction *nix uudecode nous donne :
Alice:Lapin
Nous avons retrouvé le login : "Alice" et le mot de passe : "Lapin".
Il existe une autre méthode utilisée pour coder les informations transitant sur le réseau : on utilise l'algorithme de hash MD5 (c.f. la rfc 1321). Les propriétés d'une fonction de hachage rendent impossible le fait qu'un attaquant puisse remonter aux informations initiales (login/password); de plus, le hasché reste caractéristique de ces données, autrement dit un hasché correspond à un et un seul texte original (dans la limite de son intervalle de sortie, à savoir 2^128 possibilités pour MD5).
Néanmoins, cela ne préserve pas des "replay-attacks", dans lesquelles l'attaquant va se contenter d'intercepter ce hasché et de l'utiliser à son propre compte comme s'il s'agissait du sien : il n'a nul besoin de posséder le texte original puisque c'est le hasché qui est demandé! Pour remédier à cette faiblesse, l'authentification HTTP utilisant cet algorithme va donc rajouter des éléments -uniques- dans le calcul du hasché, le plus souvent en envoyant un challenge (le "nonce") au client lors de la requête d'authentification. Le client va rajouter ce challenge dans le calcul du hasché, le rendant unique par la même occasion (c.f. la rfc 2069 et suivantes).
|
HTTP/1.1 401 Unauthorized (...) WWW-Authenticate: Digest realm="testHash", nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", opaque="5ccc069c403ebaf9f0171e9517f40e41" Authorization header: Authorization: Digest username="Alice", realm="testHash", nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", uri="/dir/index.html", response="e966c932a9242554e42c8ee200cec7f6", opaque="5ccc069c403ebaf9f0171e9517f40e41" |
Malheureusement, cette deuxième méthode d'authentification est peu utilisée (cela dépend entre autres des fonctionnalités du serveur, du navigateur, etc...).
Les navigateurs suivants supportent l'authentification basée sur MD5 :
* Internet Explorer 5.0 et +
* Amaya
* NCSA Mosaic/X 2.7
* Spyglass Mosaic
Alors que ceux-ci ne la supportent pas (liste non-exhaustive):
* Netscape Communicator 4.5 (Mac) et 4.7 (PC)
* iCab Preview 1.7 (Mac)
La méthode d'authentification par htaccess permet de déléguer le contrôle d'accès au niveau local, et autorise ainsi plus de flexibilité pour créer et changer les droits d'accès suivant les besoins.
Par contre, on comprendra que ce système devient rapidement ingérable lorsque le nombre d'utilisateurs et/ou de répertoires augmentent, rendant toute politique de sécurité globale impossible.
D'autre part, le système reste faible dans son concept; il est basé sur les services du Web à l'exclusion de tous les autres sevices d'Internet, ce qui n'est pas une hypothèse raisonnable. En effet, tout utilisateur malveillant qui a accès au serveur par un autre moyen ou service (ce qui n'est pas irréaliste) sera capable de modifier et corrompre complètement ce système d'authentification. Ainsi on peut dresser une liste (non-exhaustive bien sûr) qui permet de se faire une idée du nombre de menaces à prendre en compte lorsque l'on souhaite utiliser ce système d'authentification :
- accès via FTP (utilisateur autorisé)
- accès via FTP (utilisateur non-autorisé, buffer-overflows et autres exploits type wu-ftpd)
- accès via Telnet (sur services particuliers, la liste étant trop longue pour être citée...)
- accès via Web (script cgi non protégé type PHF, débordements)
- ...
On peut protéger un fichier avec la balise
|
AuthUserFile /exemple/.htpasswd AuthName "Accès restreint" AuthType Basic require valid-user |
La balise
Lorsque vous saisissez une URL dans votre navigateur en tapant par exemple www.monsite.com, vous êtes automatiquement redirigés vers l'index, par exemple, index.php.
Dans votre httpd.conf, le fichier de configuration d'apache, vous avez par exemple:
DirectoryIndex index.php index.html /erreurs/erreur_403.php
Donc cette instruction dit: Si rien n'est entré, on redirige vers index.php ; s'il n'existe pas, on redirige vers index.html, s'il n'existe pas, on redirige vers erreur_403.php (qui est la page d'interdiction) afin de ne pas afficher tout le contenu du dossier.
On va interdire au visiteur toutes les pages et de le rediriger vers une page de maintenance.
à l'aide de cet exemple:
|
ErrorDocument 403 /maintenance.html deny from all allow from xx.xxx.xxx.xxx allow from all |
On définit le fichier d'erreur 403 (l'erreur 403 est l'erreur qui indique que l'accès est interdit) comme étant la page maintenance.html : le site va donc afficher cette dernière lorsque la page est "interdite" (à la place du message Error 403 Forbidden).
deny from all
L'accès à tout le répertoire dans lequel se trouve le .htaccess. est interdit
allow from xx.xxx.xxx.xxx
On autorise l'accès au mainteneur du site
L'url rewriting permet de rediriger votre visiteur
Par exemple, si vous saisissez une adresse de type
www.monsite.com/page-1-2.html , en réalité cela correspond à www.monsite.com/page.php?id=1&var=2 .
Cela permet aux moteurs de recherche, qui ont du mal à indexer ce type d'adresse, de vous faire tout de même référencer
On utilise pour cela un fichier .htaccess, placé à la racine de votre site. Et on utilise le mod_rewrite d'Apache.
Pour savoir si ce dernier est activé, ouvrez le fichier httpd.conf situé dans le répertoire d'Apache et vérifiez que ces deux lignes ne sont pas des commentaires (un # indique un commentaire) :
LoadModule rewrite_module modules/mod_rewrite.so
AddModule mod_rewrite.c
Si elles en sont, décommentez le #
POur vérifier si le mod rewrite fonctionne, on va créer un fichier test.php à la racine de votre site. Ensuite, créez un fichier .htaccess ou bien mieux incorporez ces lignes à un fichier htaccess déjà présent
RewriteEngine on ////crée une règle de redirection où test.html devient test.php).
RewriteRule ^test\.html$ /test.php [L] /////^test\.html$ est une regexp
Ensuite allez sur votre serveur à l'adresse à http://www.votresite.com/test.html.
Si le contenu de ce fichier s'affiche, tout fonctionne , sinon le mod_rewrite n'est pas activé
À présent, on va réecrire toutes les pages de votre site php en *.html.
RewriteRule ^([0-9a-zA-Z-]+)\.html$ /$1.php [L]
Bref, avec ce RewriteRule, index.html renvoie sur index.php, liste-news.html renvoie sur liste-news.php, etc.
Et pour les urls avec des variables,
RewriteRule ^news-([0-9]+)-([0-9]+)-([0-9]+)\.html$ /news.php?var=$1&comm=$2&id=$3 [L]
# Jongler avec les pages supprimées ou renommées
Vous avez supprimé ou renommé une page de votre site mais vous voulez quand même que vos visiteurs puisses être redirigés vers une nouvelle page lorsque qu’il essaye d’accèder à celle qui n’existe plus. Rien de plus simple, utiliser une redirection de type 301.
Redirect 301 /old.html http://votresite.com/new.html
Utiliser cette méthode permet de s’assurer que la page continuera à être indexée par les moteurs de recherche.
Si votre serveur affiche une page de type “Erreur 404, fichier non trouvé”, cela veut dire que vous essayez d’accèder à quelque chose qui n’existe pas sur votre serveur.
Vous pouvez évidement remplacer cette page par défaut par la votre et la personnaliser comme bon vous semble en ajoutant ceci dans votre htaccess.
ErrorDocument 404 /404.html
Remplacer
404.html
par la page d’erreur personnalisée que vous voulez afficher.
Quand votre site web est trop lent, vos visiteurs auront tendance à s'orienter vers des sites plus rapides, et vous perdrez donc des utilisateurs, des clients et de l'argent
Un des moyens d'optimiser ceci est d'utiliser un fichier .htaccess, à condition que mod_expires et mod_headers soient compilés avec Apache.
On va utiliser un système de cache pour éviter que des données fréquemment consultées soient téléchargées par le serveur, accroissant de ce fait la bande passante
Utiliser mod_expires
En utilisant mod_expires, on peut définir une durée de vie pour les pages servies ou pour les contenus des pages web. De cette façon, le serveur indique au cache combien de temps les contenus associés doivent demeurer en cache. Après cette période, le contenu s'affichera d'après les pages originales. Cette méthode convient pour des pages dont le contenu change rarement, ou à date fixe
Voici un exemple de .htaccess, avec des fichiers classés selon leur extension
|
<ifmodule mod_expires.c> <filesmatch "\.(jpg|gif|png|css|js)$"> ExpiresActive on ExpiresDefault "access plus 1 year" </filesmatch> </ifmodule> ou classés selon leur type <IfModule mod_expires.c> ExpiresActive On ExpiresDefault "access plus 1 month" ExpiresByType text/html "access plus 1 month 15 days 2 hours" ExpiresByType image/gif "modification plus 1 month" ExpiresByType image/png "modification plus 1 month" ExpiresByType image/jpg "modification plus 1 month" </IfModule> |
Ici, la directive "ExpiresDefault” définit le temps d'expiration par défaut pour tous les fichiers qui ne sont pas spécifiés par la directive “ExpiresByType”.
ON peut aussi utiliser le format “ExpiresDefault A300″, “Expires A300″, Expires M300″ etc. Ici, les deux premieres directives définissent le temps d'expiration à 300 secondes après l'access (A) et la dernière définit le temps d'expiration à 300 secondes après modification.
Même si cela semble utile, il existe des limitations à l'emploi de “Expires”. Par exemple, l'horloge du serveur et celle du cache doivent être synchronisées.
À cause de ces limites, on pourrait être amené à utiliser les en-têtes cache-control.
Par exemple:
|
* max-age — Temps maximum de rafraichissement (en secondes). * no-cache — Quand la directive est définie, le cache contacte le serveur d'origine pour valider avant de délivrer une copie en cache. * public — Les réponses du serveur sont toujours mises en cache, même si elles se trouvent derrière une procédure d'authentification. * private — Une partie ou l'ensemble des réponses du serveur sont destinés à un usage particulier et ne doivent pas être mis en cache * no-store — Indique au cache de ne pas garder une copie de la représentation. * must-revalidate — Le cache doit suivre chaque information de rafraichissement fournie par le serveur. |
Voici un exemple avec un fichier .htaccess
Tous les fichiers textes, javascripts, pdf et css sont cachés pendant 7 jours (604800 secondes).
|
<FilesMatch "\.(js|css|pdf|txt)$"> Header set Cache-Control "max-age=604800, public" </FilesMatch> Tous les fichiers html pour deux heures. <FilesMatch "\.(html|htm)$"> Header set Cache-Control "max-age=7200, public" </FilesMatch> Ne pas employer de cache pour php, perl et les scripts cgi <FilesMatch "\.(php|cgi|pl)$"> Header set Cache-Control "no-store, no-cache, must-revalidate, max-age=0" </FilesMatch> On peut aussi utiliser “Expires” adossé avec “cache-control”. Modifions ci-dessous <FilesMatch "\.(php|cgi|pl)$"> ExpiresDefault A0 Header set Cache-Control "no-store, no-cache, must-revalidate, max-age=0" </FilesMatch> ou <FilesMatch "\.(php|cgi|pl)$"> Header unset Cache-Control Header unset Expires </FilesMatch> Admettons que nous souhaitons mettre en cache définitivement des fichiers mp3 et mp4 <FilesMatch "\.(mp3|mp4)$"> Header set Cache-Control "max-age=31536000, public" </FilesMatch> |
Nous avons vu que la méthode d'authentification par htaccess comporte beaucoup d'inconvénients, voir de faiblesses, pour un nombre d'avantages assez restreint. Néanmoins, il ne faut pas oublier son principal intérêt qui est le fait qu'elle reste la seule méthode facilement utilisable par le client de base d'un fournisseur d'accès internet et d'espace web. En effet la plupart du temps cette personne n'a pas accès aux serveurs et ne peut donc pas faire appel à des services auxiliaires pour des types d'authentifications alternatives. Les quelques options restantes sont plus compliquées à implémenter (PHP/MySQL par exemple) surtout si l'on souhaite assurer un bon niveau de sécurité (modules cryptographiques en PHP). Et l'on ne parle même pas des solutions utilisées par la plupart des interfaces web de mail gratuit type Yahoo!, où l'on utilise un simple POST dans lequel le mot de passe est présent en clair!
Pour finir, la méthode htaccess peut très bien être sécurisée car elle en possède les moyens : cryptographie avec MD5 ou sécurisation de bout en bout grace à SSL... A chacun de s'assurer que ces mesures soient correctement utilisées.