evolix/evoformations
21
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Première publication d'un certain nombre de supports de formation Evolix

Browse source
This commit is contained in:
Gregory Colpart 2010-04-09 00:19:50 +00:00
commit 5fcdf8fd22
12 changed files with 6108 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1087
support/apache.tex Normal file
View file

@ -0,0 +1,1087 @@
% Copyright (c) 2004-2010 Evolix <info@evolix.fr>
% Permission is granted to copy, distribute and/or modify this document
% under the terms of the GNU Free Documentation License, Version 1.2
% or any later version published by the Free Software Foundation;
% with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
% A copy of the license is included at http://www.gcolpart.com/howto/fdl.html
\chapter{Apache}
\section{Rappel de l'architecture client/serveur}
L'architecture client-serveur\footnote{http://www.faqs.org/faqs/client-server-faq/} se résume à la demande de services d'un programme client à un programme serveur. Il s'agit de l'extension logique du partitionnement des logiciels importants en modules donnant la possibilité de développement et de maintenance plus aisés. Les modules "demandeurs" sont appelés client et les modules appelés sont appelés service. Ainsi les différents modules fonctionnent sur des plateformes différentes et appropriées à leur fonction. Par exemple, les systèmes de gestion de base de données tournent sur des plateformes logicielles et matérielles conçues pour optimiser les requêtes, ou les serveurs de fichiers tournent sur des plateformes adaptées pour la gestion de fichiers.\\
~\\
Le client est donc un programme qui envoie un message à un programme serveur, demandant au serveur un service. Les programmes client sont en général constitués d'une interface permettant de valider les données entrées par l'utilisateur et d'un programme permettant de traiter et d'envoyer les requêtes aux programmes serveur.\\
~\\
Le programme contient donc un certain nombre de facilités pour interagir avec l'utilisateur. Ainsi, il accède aux ressources locales (écran, clavier, processeur, périphériques, etc.).\\ Un des éléments souvent présent sur une machine de type poste de travail est une interface graphique : GUI (Graphical User Interface).\\
Normalement, c'est le Windows Manager qui détecte les actions de l'utilisateur, gère les différentes fenêtres et affiche les données.\\
~\\
Le serveur est un programme qui répond aux demandes du client en réalisant la tâche demandée. Les programmes serveur recoivent en général des requêtes des programmes client, exécutent des requêtes et mises-à-jour sur une base de données, contrôlent l'intégrité des données et répondent aux programmes clients. Le programme serveur devrait être sur une machine indépendante sur le réseau mais souvent plusieurs programmes serveur sont sur la même machine et dans certains cas, la machine hébergeant le service est un poste de travail. Le programme serveur peut souvent accéder à des resources locales telles que les bases de données, imprimantes, interfaces et processeur(s).\\
~\\
\section{Le protocole HTTP}
\subsection{Différentes versions}
HTTP/0.9 : première version du protocole HTTP, très simple, permettant uniquant une requête GET et une réponse sans méta-données. \\
HTTP/1.0 : ancienne version du protocole HTTP, encore utilisée par certains logiciels. Le serveur HTTP ferme encore la connexion dès qu'il a envoyé sa réponse. \\
HTTP/1.1 : version la plus répandue du protocole HTTP. Elle permet notamment les connexions persistantes, la négociation du contenu, et une meilleure gestion du cache.~\\
~\\
\subsection{Méthodes :}
~\\
GET : requête d'une ressource \\
HEAD : requête uniquement des entête d'une ressource \\
POST : envoi de données à une ressource \\
Il existes d'autres méthodes moins utilisées (PUT, DELETE, TRACE, CONNECT) \\
~\\
\subsection{Codes d'état :}
\begin{itemize}
\item{1xx} : Information (peu utilisé)
\item{2xx} : Succès, notamment le code 200 correspondant à OK
\item{3xx} : Redirection, notamment 301 (déplacement défintif) et 302 (déplacement temporaire)
\item{4xx} : Erreur du client, notamment 404 (non trouvé) et 403 (non autorisé)
\item{5xx} : Erreur du serveur, notamment 500 (erreur interne)
\end{itemize}
\subsection{Champs d'entête :}
\begin{itemize}
\item{Allow}
\item{Authorization}
\item{Content-Encoding}
\item{Content-Length}
\item{Date}
\item{Expires}
\item{From}
\item{If-Modified-Since}
\item{Last-Modified}
\item{Location}
\item{Pragma}
\item{Referer}
\item{Server}
\item{User-Agent}
\item{WWW-Authenticate}
\item{etc.}
\end{itemize}
\section{Présentation}
~\\
Le logiciel Apache est un serveur HTTP. Apparu en 1995, il est dérivé de nombreux patches pour le serveur NCSA HTTPD\footnote{http://hoohoo.ncsa.uiuc.edu/}. Complètement réécrit, son nom serait tiré officieusement de l'appelation "a patchy server", c'est-à-dire un serveur fait de patches. La version officielle indique que le nom a été choisi en l'honneur de la tribu Apache, bien connue pour son sens aigu de la stratégie guerrière et pour son endurance. Dès 1996, il devenait le serveur HTTP le plus répandu sur Internet et sa popularité ne cesse de croître car en 1999, il était présent sur 57\% des serveurs et en 2004, le chiffre atteind 67\% \footnote{http://news.netcraft.com/archives/web\_server\_survey.html}.\\
La fondation Apache, Apache Software Foundation\footnote{http://www.apache.org/foundation/}, a été créée en 1999 afin de soutenir le développement d'Apache mais aussi de nombreux autres projets orientés web (Jakarta, Spamassassin, etc.).\\
Apache est l'un des logiciels libres - sous licence Apache\footnote{http://www.apache.org/licenses/} souvent cité en exemple quand on parle des logiciels libres car il est notamment réputé pour sa sécurité et sa fiabilité.\\
Liens : \\
\url{http://www.apache.org/}\\
\url{http://en.wikipedia.org/wiki/Apache\_HTTP\_Server}\\
~\\
On distingue actuellement la version 1.x de la version 2.x qui comprend de nombreuses avancées telles qu'une nouvelle API, le support natif de l'IPv6 et la possibilité d'installation sur des plateformes non UNIX. Apache possède également de nombreux modules (CGI, Perl, PHP, authentification avancée, etc.) offrant des possibilités de mise en oeuvre de services complexes.\\
\section{Installation}
\subsection{Compilation}
~\\
Comme la plupart des logiciels libres, il est possible de compiler Apache à partir des sources. Cela permet de compiler uniquement avec les options que l'on a besoin et d'avoir des binaires bien adaptés à sa machine.\\
Pour la compilation en elle-même, on applique donc la procédure classique. On va reprendre en détail cette procédure.\\
~\\
On télécharge les sources mais également le hash MD5 des sources ainsi que la signature PGP (et les clés des développeurs Apache) de ces sources~:
\begin{verbatim}
$ wget apache\_x.y.z.tar.gz
$ wget apache\_x.y.z.tar.gz.md5
$ wget KEYS
$ wget apache\_x.y.z.tar.gz.asc
\end{verbatim}
On vérifie le bon déroulement du téléchargement des sources en comparant le résultat des commandes suivantes~:
\begin{verbatim}
$ md5sum apache_x.y.z.gz
$ cat apache_x.y.z.tar.gz.md5
\end{verbatim}
~\\
On importe les clés des développeurs Apache et on vérifie l'intégrité des sources~:
\begin{verbatim}
$ gpg --import KEYS
$ gpg --verify apache_x.y.z.tar.gz.asc
\end{verbatim}
On peut ensuite décompresser et désarchiver les sources~:
\begin{verbatim}
tar -zxvf apache_x.y.z.tar.gz
cd apache_x.y.z.tar.gz
\end{verbatim}
On prend ensuite connaissance des options qui s'offrent à nous grâce à la commande~:
\begin{verbatim}
./configure --help
\end{verbatim}
On distinguera les options d'administration (noms des répertoires, chemins des librairies, etc.). Par exemple~:
\begin{verbatim}
--sysconfdir=/etc/apache2 --sbindir=/usr/sbin ;
\end{verbatim}
Et les options relatives aux fonctionnalités, par exemple~:
\begin{verbatim}
--with-mpm=worker --enable-ssl --enable-rewrite
--enable-cgi --enable-dav-fs --enable-dav
\end{verbatim}
On aura bien sûr besoin de nombreuses librairies de développement pour compiler Apache (l'étape suivante sert bien sûr à vérifier leurs présences). Ensuite, on spécifie les options choisies avant de lancer l'étape de vérification :\\
~\\
\texttt{./configure [options]}\\
~\\
On compile :\\
~\\
\texttt{make}\\
~\\
Et on procède à l'installation :\\
~\\
\texttt{make install}\\
~\\
\subsection{Paquets}
~\\
Les paquets offrent plusieurs avantages sur la compilation à partir des sources. Ils permettent notamment de gagner du temps, et parfois de gérer les dépendances. On distinguera les paquets RPM\footnote{http://www.rpm.org/}, DEB\footnote{http://www.debian.org/distrib/packages}, etc.\\
~\\
Par exemple, sur un système Debian~:\\
~\\
\textbf{Pour Apache 2 :}
~\\
\texttt{ aptitude install apache2-mpm-prefork}\\
~\\
\emph{Paquets principaux :}\\
~\\
\begin{itemize}
\item[apache2.2-common :] modules de base, documentations et icones pour Apache
~\\
\textit{Plusieurs choix pour Apache MPM (Multi-Processing Module) :}
~\\
\item[apache2-mpm-worker :] version par défaut. Adapté aux serveurs à fort trafic
\item[apache2-mpm-prefork :] implémentation "non-threaded" (similaire à l'historique Apache 1.3.x)
\item[apache2-mpm-itk :] similaire au prefork, avec la possibilité de préciser l'utilisateur et le groupe pour chaque VirtualHost
\end{itemize}
~\\
\emph{Dépendances directes :}\\
~\\
\begin{center}
\begin{tabular}{|c|c|}
\hline
libapr0 :& librairie "Apache Portable Runtime"\\
\hline
openssl :& librairies "Authentication abstraction"\\
\hline
ssl-cert :& surcouche pour générer des certificats\\
\hline
libldap2 :& librairies OpenLDAP\\
\hline
libgnutls11 :& librairies GNU TLS\\
\hline
libgcrypt11 :& librairies cryptographiques LGPL\\
\hline
libgpg-error0 :& librairie pour erreurs/messages composants GnuPG\\
\hline
liblzo1 :& librairies de compression LZO\\
\hline
libopencdk8 :& Kit "Open Crypto Development"\\
\hline
libtasn1-2 :& librairies structures ASN.1\\
\hline
zlib1g :& librairies de compression gzip\\
\hline
libsasl2 :& librairies SASL v2\\
\hline
\end{tabular}
\end{center}
\section{Configuration}
On vérifiera sa configuration grâce à la commande :\\
~\\
\texttt{apache2ctl configtest}\\
~\\
La configuration d'Apache 2 se trouve dans le répertoire /etc/apache2/ \\
La configuration principale est dans le fichier apache2.conf \\
\textit{Note :} Selon les systèmes (distributions Linux, BSD, etc.), cela peut varier : la commande peut être apachectl, le répertoire de configuration peut être /etc/httpd ou /usr/local/etc/apache22 par exemple, et la configuration peut être dans un fichier httpd.conf \\
~\\
Passons en revue quelques options à connaître grâce à un exemple de fichier de configuration.\\
Détaillons la première partie correspondant à l'environnement et aux modules :\\
~\\
\begin{verbatim}
### Section 1: Environnement
# mode d'execution du serveur : inetd ou standalone
ServerType standalone
# repertoire de configuration
ServerRoot /etc/apache2
# lock and PID file
LockFile /var/lock/apache.lock
PidFile /var/run/apache.pid
# temporisation pdt laquelle Apache attend temps total réception requête GET
# ou entre réception paquets TCP lors d'une requête POST ou PUT etc.
Timeout 300
# connexions persistentes
#KeepAlive On
# nombre de requêtes permises pour une connexion unique
# lorsque la directive KeepAlive est activée
#MaxKeepAliveRequests 100
# nombre de secondes pendant lesquelles Apache
# attendra une requête postérieure avant de rompre une connexion.
#KeepAliveTimeout 15
# nombre minimum de processus fils en attente qu'un serveur pourra conserver
#MinSpareServers 5
# nombre maximal de processus fils en attente
#MaxSpareServers 10
# nombre de processus fils créés dès le démarrage du serveur
#StartServers 5
# nombre limite de requêtes simultanées pouvant être acceptées par le serveur
MaxClients 150
# nombre limite de requêtes qu'un processus serveur fils peut traîter
MaxRequestsPerChild 100
# modules
LoadModule ...
LoadModule ...
LoadModule ...
# MIME
<IfModule mod_negotiation.c>
LanguagePriority fr en da nl et de el it ja pl pt pt-br ltz ca es sv
</IfModule>
AddType application/x-httpd-php .html .php .php3
AddType application/x-httpd-php-source .phps
AddType application/x-tar .tgz
...
# avoir le maximum d'informations (mod_status)
<Location /server-status-0906>
SetHandler server-status
Order deny,allow
Deny from all
Allow from 127.0.0.1
Allow from 1.2.3.4
</Location>
ExtendedStatus On
<Location /server-info-0906>
SetHandler server-info
Order deny,allow
Deny from all
Allow from 127.0.0.1
Allow from 1.2.3.4
</Location>
# xxx
ReadmeName README
HeaderName HEADER
IndexIgnore .??* *~ *# HEADER* README* RCS CVS *,v *,t
# redirection vers fichiers index (mod_dir)
<IfModule mod_dir.c>
DirectoryIndex index.html index.htm index.shtml index.cgi index.php index.php3 index.php4
</IfModule>
# Répertoires utilisateurs (mod_userdir)
<IfModule mod_userdir.c>
#nom du répertoire public
UserDir public_html
#root n'a pas de site perso
UserDir disabled root
</IfModule>
<Directory /home/*/public_html>
AllowOverride FileInfo AuthConfig Limit
Options MultiViews Indexes FollowSymLinks IncludesNoExec
<Limit GET POST OPTIONS PROPFIND>
Order allow,deny
Allow from all
</Limit>
<Limit PUT DELETE PATCH PROPPATCH MKCOL COPY MOVE LOCK UNLOCK>
Order deny,allow
Deny from all
</Limit>
</Directory>
# navigateurs particuliers (mod_setenvif)
<IfModule mod_setenvif.c>
BrowserMatch "Mozilla2" nokeepalive
BrowserMatch "MSIE 4.0b2;" nokeepalive downgrade-1.0
force-response-1.0
BrowserMatch "RealPlayer 4.0" force-response-1.0
BrowserMatch "Java/1.0" force-response-1.0
BrowserMatch "JDK/1\.0" force-response-1.0
</IfModule>
\end{verbatim}
Détaillons maintenant la seconde partie~:
\begin{verbatim}
### Section 2: configuration principale
#numéro du port
Port 80
#utilisateur et groupe propriétaire d'apache
User www-data
Group www-data
#adresse e-mail que le serveur peut inclure dans un message d'erreur
#retourné au client
ServerAdmin webmaster@domaine.tld
#nom d'hote (sert pour redirection)
ServerName www.example.com
ServerAlias example.com tmp.example.com
#Répertoire racine du serveur
DocumentRoot /var/www
#configuration par defaut
<Directory />
#pas d'acces par defaut
Order Deny,Allow
Deny from all
#possibilite de liens symboliques ssi liens et destinations
#ont meme proprio
Options SymLinksIfOwnerMatch
#htaccess desactive
AllowOverride None
</Directory>
<Directory /var/www/>
Options Indexes Includes FollowSymLinks MultiViews
AllowOverride AuthConfig FileInfo
Allow from all
</Directory>
#HTACCESS si directive AllowOverride
AccessFileName .htaccess
<Files ~ " ^.ht">
Order allow,deny
Deny from all
</Files>
# resolution inverse double
#HostnameLookups Off
# Desactive version verbeuse
ServerTokens Prod
# ajoute une ligne contenant ServerName et ServerAdmin
# en bas des pages d'erreurs notamment
ServerSignature On
#CGI
ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/
<Directory /usr/lib/cgi-bin/>
AllowOverride None
Options ExecCGI -MultiViews +SymLinksIfOwnerMatch
Order allow,deny
Allow from all
</Directory>
# icones
Alias /icons/ /usr/share/apache/icons/
<Directory /usr/share/apache/icons>
Options Indexes MultiViews
AllowOverride None
Order allow,deny
Allow from all
</Directory>
# forcer
#AddDefaultCharset UTF-8
\end{verbatim}
Revenons sur certaines options :\\
~\\
Dans \textbf{<Directory ...></Directory>} :\\
~\\
\textbf{- Gestion des accès}\\
~\\
\url{http://httpd.apache.org/docs-2.0/mod/mod\_access.html}\\
~\\
\begin{verbatim}
Order [option]
Allow/Deny from [nom de domaine, adresse IPv4/v6, réseau]
Order Deny,Allow
Allow from 10.1.0.0/255.255.0.0
Deny from all
\end{verbatim}
\textbf{- Options :}
Options [options]
\begin{itemize}
\item[\textbf{None}] : rien
\item[\textbf{MultiViews}] : rediriger les demandes selon les préférences du navigateur (mod\_negotiated)
\item[\textbf{All}] : toutes les options ci-dessous
\item[\textbf{Indexes}] : lister le répertoire si il n'y a pas de fichier index (mod\_index)
\item[\textbf{FollowSymLinks}] : suit les liens symboliques
\item[\textbf{SymLinksIfOwnerMatch}] : suit les liens symboliques ssi liens et destinations ont le même propriétaire
\item[\textbf{Includes}] : possibilité de filtres Server-side (mod\_include)
\item[\textbf{IncludesNOEXEC}] : Includes mais sans scripts exécutables
\item[\textbf{ExecCGI}] : l'exécution de scripts CGI est permise (mod\_cgi)
\end{itemize}
Possibilités de faire +/- [options] par rapport à une directive supérieure (répertoire contenant ou racine)
\textbf{- AllowOverride :}
AllowOverride [options]
Permet de spécifier certains paramètres dans des fichiers .htaccess :
\begin{itemize}
\item[\textbf{AuthConfig}] : pour les directives d'authentification (Auth*, Require, etc.)
\item[\textbf{FileInfo}] : pour les directives de contrôle des types de fichier (DefaultType, ErrorDocument, SetHandler, etc.)
\item[\textbf{Indexes}] : pour les directives d'indexation de répertoire (DirectoryIndex, DefaultIcon, etc.)
\item[\textbf{Limit}]: permet de spécifier les directives de gestion d'accès (Allow, Deny, Order)
\item[\textbf{Options}] : permet de spécifier les options d'Options
\end{itemize}
~\\
\textbf{Fichiers .htaccess}
~\\
\url{http://httpd.apache.org/docs-2.2/howto/htaccess.html} \\
~\\
\textit{Exemple de fichier .htaccess :}\\
\begin{verbatim}
AuthUserFile .htpasswd
AuthGroupFile /dev/null
AuthName "Acces reserve"
AuthType Basic
<LIMIT GET POST>
Require valid-user
</LIMIT>
\end{verbatim}
~\\
Voir mod\_auth\\
\textbf{<Location ...></Location>} est similaire à <Directory></Directory> à la différence que les directives sont valables sur les chemins d'URL\\
~\\
Exemple~:
\begin{verbatim}
<Location /status>
SetHandler server-status
Order Deny,Allow
Deny from all
Allow from 192.168.176.53
</Location>
\end{verbatim}
Dans \textbf{<Files ...></Files>} :\\
~\\
Directives portant sur les fichiers.\\
~\\
Exemple :\\
\begin{verbatim}
<Files ~".(mp3|ogg|avi|mpeg)\$">
Order allow,deny
Deny from all
</Files>
\end{verbatim}
~\\
\textbf{<Limit ... ></Limit>} impose des restrictions sur certaines méthodes du protocole HTTP.
~\\
Exemple :\\
\begin{verbatim}
<Limit PUT DELETE PATCH PROPPATCH MKCOL COPY MOVE LOCK UNLOCK>
Order deny,allow
Deny from all
</Limit>
\end{verbatim}
~\\
Par défaut, la configuration d'Apache est souvent répartie dans plusieurs
fichiers pour une meilleure gestion. Ainsi, sous Debian, on retrouve
le partitionnement suivant, indiqué dans le fichier de configuration principal :\\
\begin{verbatim}
Include /etc/apache2/mods-enabled/*.load
Include /etc/apache2/mods-enabled/*.conf
Include /etc/apache2/httpd.conf
Include /etc/apache2/ports.conf
Include /etc/apache2/conf.d/[^.#]*
Include /etc/apache2/sites-enabled/[^.#]*
\end{verbatim}
~\\
~\\
\textbf{Les modules :}\\
~\\
On trouve les répertoires mods-available et mods-enabled dans le répertoire de configuration. mods-available contient des fichiers NOM.load et NOM.conf : un fichier NOM.load contient la directive permettant le chargement d'un module disponible :\\
\begin{verbatim}
LoadModule /chemin/NOM.so
\end{verbatim}
~\\
Le fichier NOM.conf contient les éventuelles options de configuration du modèle, par exemple :\\
\texttt{
<IfModule mod\_NOM.c>\\
...\\
</IfModule>\\
}
~\\
Pour activer un module, on fait simplement un lien symbolique du fichier NOM.load (et NOM.conf si il existe) vers le répertoire mods-enabled.\\
~\\
Exemple :\\
{\small
\texttt{
\# ln -s /etc/apache2/mods-available/ssl.load /etc/apache2/mods-enabled/ssl.load
\# ln -s /etc/apache2/mods-available/ssl.conf /etc/apache2/mods-enabled/ssl.conf
}
}
~\\
\textit{Voir les modules}\\
~\\
-Le fichier \texttt{httpd.conf} :\\
~\\
Utilisé pour les directives supplémentaires
(vide par défaut)\\
~\\
-Le fichier \texttt{ports.conf} :
\begin{verbatim}
Listen 80
Listen IP:80
Listen domain.tld:80
\end{verbatim}
La troisième possibilité est à éviter si possible\footnote{http://httpd.apache.org/docs-2.2/dns-caveats.html}\\
~\\
\subsection{VirtualHost}
~\\
Le terme de VirtualHost se réfère à la pratique de faire tourner plusieurs sites Internet sur une seule machine alors que l'utilisateur final ne se rend pas compte que les différents sites tournent physiquement sur la même machine.\\
~\\
Apache est capable d'avoir des VirtualHost basés sur les adresses IP et sur les noms. Attention, les ports d'écoute sont définis avec le paramètre Listen. Les VirtualHost ne font que "rediriger" les requêtes entrantes.\\
~\\
\begin{verbatim}
NameVirtualHost IP:*
NameVirtualHost *
<VirtualHost 10.1.2.3:>
ServerAdmin webmaster@host.foo.com
DocumentRoot /www/docs/host.foo.com
ServerName host.foo.com
ErrorLog logs/host.foo.com-error_log
TransferLog logs/host.foo.com-access_log
</VirtualHost>
\end{verbatim}
~\\
Exemple complexe :\\
\begin{verbatim}
Listen IP1:80
Listen IP2:8080
NameVirtualHost IP1:80
<VirtualHost IP1:80>
DocumentRoot /www/ip1
ServerName www.name1.tld
</VirtualHost>
<VirtualHost IP1:80>
DocumentRoot /www/ip2
ServerName www.name2.tld
</VirtualHost>
#basé sur l'IP
<VirtualHost IP2:8080>
DocumentRoot /www/ip3
ServerName www.name3.tld
</VirtualHost>
\end{verbatim}
~\\
À l'intérieur d'un VirtualHost, on peut spécifier de nombreuses directives. Souvent il s'agira de~:\\
\begin{verbatim}
DocumentRoot
ServerAdmin
ServerName
ServerAlias
ErrorLog
TransferLog
LogLevel
CustomLog
ServerSignature
ErrorDocument
Rewrite*
etc.
\end{verbatim}
~\\
Ainsi que le <Directory /></Directory> spécifiant les droits par défaut sur les répertoires concernés (DocumentRoot, script CGI, script Perl, icones, manuel, ...)\\
~\\
Voir dans la documentation, les paramètres pouvant s'appliquer dans un VirtualHost.\\
~\\
Lien:\url{http://httpd.apache.org/docs/vhosts/}\\
~\\
\subsection{Configuration des sites en ligne}
~\\
La configuration d'Apache fonctionne souvent avec des VirtualHost... même pour un seul site mis en ligne ! On trouve les répertoires \textit{sites-enabled} et \textit{sites-available} dans le répertoire de configuration. Par exemple, le fichier \textit{default} :
\begin{verbatim}
NameVirtualHost *
<VirtualHost *>
ServerName www.example.com
ServerAlias example.com
ServerAdmin webmaster@example.com
DocumentRoot /var/www/
<Directory />
Order Deny,Allow
Deny from all
Options None
AllowOverride None
</Directory>
<Directory /var/www/>
Options Indexes FollowSymLinks MultiViews
AllowOverride None
</Directory>
ErrorLog /var/log/apache2/error.log
LogLevel warn
CustomLog /var/log/apache2/access.log combined
ServerSignature On
</VirtualHost>
\end{verbatim}
Pour activer un site, on fait simplement un lien symbolique du fichier dans le répertoire sites-available vers le répertoire sites-enabled. Par contre, Apache passe en revue les liens du répertoire sites-enabled dans l'ordre alphanumérique/alphabétique. Il faut donc nommer les liens selon ses préférences. Ainsi, on créra un lien :
~\\
{\small \# ln -s /etc/apache2/sites-available/default /etc/apache2/sites-enabled/000-default}
{\small \# a2ensite test}
~\\
\section{Modules}
~\\
Un grand nombre de modules sont préinstallés. On cherchera les paquets des modules supplémentaires avec la commande :
\texttt{\\
apt-cache search \textasciicircum libapache2-mod \\
}
~\\
\subsection{mod\_cgi}
~\\
Lien~: \url{http://httpd.apache.org/docs-2.2/mod/mod\_cgi.html}\\
~\\
Ce module permet l'exécution de scripts CGI (les scripts CGI peuvent être écrits en C, Perl, Shell, etc.).\\
~\\
\textbf{Configuration :}
~\\
\begin{verbatim}
ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/
<Directory /usr/lib/cgi-bin/>
AllowOverride None
Options ExecCGI -MultiViews +SymLinksIfOwnerMatch
Order allow,deny
Allow from all
</Directory>
\end{verbatim}
~\\
\textbf{Exemple} :
~\\
date.cgi :
\begin{verbatim}
#!/bin/sh
tmp=`/bin/date`
cat << EndFile
Content-type: text/html
<HTML><HEAD><TITLE>Date du serveur</TITLE></HEAD>
<BODY>
<CENTER>
<H1>La date du serveur est</H1>
$tmp
</CENTER>
</BODY>
</HTML>
EndFile
\end{verbatim}
\subsection{mod\_perl}
~\\
Lien:\url{http://perl.apache.org/}\\
~\\
Ce module permet d'exécuter des scripts Perl. Il offre de nombreux avantages par rapport aux scripts CGI en Perl (rapidité, optimisation, etc.)\\
~\\
\texttt{apt-cache search \textasciicircum libapache perl}
~\\
\subsection{mod\_php4}
\textit{voir PHP}
\subsection{mod\_auth}
Lien:\url{http://httpd.apache.org/docs-2.0/mod/mod\_auth.html}\\
~\\
Exemple :\\
~\\
\begin{verbatim}
AuthUserFile /var/apache/passwd/.htpasswd
AuthGroupFile /dev/null
AuthName "Accès reservé"
AuthType Basic
<LIMIT GET POST>
Require valid-user
</LIMIT>
\end{verbatim}
~\\
Exemple :\\
~\\
\begin{verbatim}
mkdir /etc/apache2/pass
htpasswd -c /etc/apache2/pass/.htpasswd user1
htpasswd /etc/apache2/pass/.htpasswd user2
\end{verbatim}
~\\
Souvent dans un fichier .htaccess\\
\subsection{mod\_proxy}
~\\
Lien~: \url{http://httpd.apache.org/docs-2.0/mod/mod\_proxy.html}\\
~\\
Ce module implémente un proxy/cache pour Apache. Il gère les fonctionnalités de proxy pour FTP, CONNECT (pour SSL), HTTP/0.9, et HTTP/1.0.\\
\subsection{mod\_rewrite}
~\\
Lien : \url{http://httpd.apache.org/docs-2.0/mod/mod\_rewrite.html}\\
\begin{verbatim}
RewriteEngine On
RewriteCond
Variables :
RegEx :
^ : début
$ : fin
. : tous les caractères
* : nombre infini de fois
RewriteRule
\end{verbatim}
~\\
Exemple : forcer le nom SERVER\_NAME pour le serveur :
\begin{verbatim}
RewriteEngine On
RewriteLog "/var/log/apache/rewrite.log"
RewriteLogLevel 3
RewriteCond %{HTTP_HOST} !^%www.domaine.tld$
RewriteRule ^/(.*) http://%{SERVER_NAME}/$1 [L,R]
\end{verbatim}
\subsection{mod\_dav}
~\\
Lien : \url{http://httpd.apache.org/docs-2.0/mod/mod\_dav.html}\\
~\\
mod\_dav et mod\_dav\_fs
~\\
dav\_fs.conf:\\
\begin{verbatim}
DAVLockDB /var/lock/apache2/DAVLock/DAVLockDB
\end{verbatim}
~\\
\subsection{mod\_ssl}
~\\
SSLEngine On\\
~\\
Lien:\url{http://httpd.apache.org/docs-2.0/mod/mod\_ssl.html}\\
~\\
On rappelle la procédure de génération d'un certificat auto-signé~:\\
~\\
On crée une "demande" de certificat en se basant sur des paramètres aléatoires ainsi que sur une clé privée \texttt{privkey.pem} protégée par un mot de passe~:
\begin{verbatim}
$ openssl req -new > demande.csr
\end{verbatim}
Si l'on veut supprimer ce mot de passe de protection (utile dans le cas d'un serveur), on ajoute l'argument \texttt{-out cleprivee.pem} et l'on obtient une clé privée \texttt{cleprivee.pem} non protégée~:
\begin{verbatim}
$ openssl rsa -in privkey.pem -out cleprivee.pem
\end{verbatim}
Enfin, on génère le certificat basé sur la demande et signé par la clé privée~:
\begin{verbatim}
$ openssl x509 -in demande.csr -out certificat.pem -req -signkey cleprivee.pem -days 365
\end{verbatim}
~\\
On peut ajouter ensuite les lignes suivantes dans le VirtualHost~:
\begin{verbatim}
#activation SSL
SSLEngine on
#certificats
SSLCertificateFile /path/to/certs/certificat.pem
#cle privee
SSLCertificateKeyFile /path/to/certs/cleprivee.pem
\end{verbatim}
~\\
\textbf{Exemple 1} : avoir un site disponible avec HTTP et HTTPS\\
\begin{verbatim}
ports.conf :
Listen 80
Listen 443
sites-available/default :
NameVirtualHost *:80
<VirtualHost *:80>
...
</VirtualHost>
sites-available/default-ssl :
NameVirtualHost *:443
<VirtualHost *:443>
...
#SSL
SSLEngine on
#certificats
SSLCertificateFile /etc/apache2/ssl/certificat.cert
#cle privee
SSLCertificateKeyFile /etc/apache2/ssl/cle-privee.key
</VirtualHost>
\end{verbatim}
~\\
{\small ln -s /etc/apache2/sites-available/default /etc/apache2/sites-enabled/000-default}\\
{\small ln -s /etc/apache2/sites-available/default-ssl /etc/apache2/sites-enabled/001-default-ssl}\\
~\\
\textbf{Exemple 2} : avoir un site disponible en HTTPS et HTTP redirigé vers HTTPS\\
~\\
\begin{verbatim}
sites-available/default-ssl :
NameVirtualHost *:80
NameVirtualHost *:443
<VirtualHost *:80>
RewriteEngine On
RewriteRule ^/(.*) https://webmail.domain.tld/ [L,R]
</VirtualHost>
<VirtualHost *:443>
...
</VirtualHost>
\end{verbatim}
~\\
Lien:\url{http://home.earthlink.net/~fjhirsch/Papers/wwwj/article.html}\\
~\\
\subsection{autres options}
UseCanonicalName : On|Off|DNS (défaut=On)
Permet de spécifier que l'on se réfère à l'option ServerName pour déterminer les variables SERVER\_NAME et SERVER\_PORT
\section{Optimisation}
~\\
Lien:\url{http://httpd.apache.org/docs-2.0/misc/perf-tuning.html}\\
\begin{verbatim}
HostnameLookups off
<Files ~ ".(html|cgi)$">
HostnameLookups on
</Files>
\end{verbatim}
~\\
\texttt{AllowOverride None} : partout où l'on peut (évite de chercher .htaccess partout)\\
~\\
\texttt{Options SymLinksIfOwnerMatch} à utiliser le moins possible (pas par défaut)\\
~\\
DirectoryIndex index.php index.html index.html index.cgi index.pl
~\\
\section{Sécurité}
~\\
Pour améliorer la sécurité d'Apache, on peut installer mod\_security~:
\begin{verbatim}
# aptitude install libapache2-mod-security2
\end{verbatim}
Avec le fichier de configuration conf.d/mod-security2.conf resemblant à :
\begin{verbatim}
# enable mod_security
SecRuleEngine On
# access to request bodies
SecRequestBodyAccess On
#SecRequestBodyLimit 134217728
#SecRequestBodyInMemoryLimit 131072
# access to response bodies
SecResponseBodyAccess On
#SecResponseBodyLimit 524288
SecResponseBodyMimeType (null) text/html text/plain text/xml
#SecServerSignature "Apache/2.2.0 (Fedora)"
SecUploadDir /tmp
SecUploadKeepFiles Off
# default action
SecDefaultAction "log,auditlog,deny,status:406,phase:2,t:none"
SecAuditEngine RelevantOnly
#SecAuditLogRelevantStatus "^[45]"
# use only one log file
SecAuditLogType Serial
# audit log file
SecAuditLog /var/log/apache2/modsec_audit.log
# what is logged
SecAuditLogParts "ABIFHZ"
#SecArgumentSeparator "&"
SecCookieFormat 0
SecDebugLog /var/log/apache2/modsec_debug.log
SecDebugLogLevel 0
SecDataDir /tmp
SecTmpDir /tmp
#########
# RULES
#########
# File name
SecRule REQUEST_FILENAME "modsecuritytest1"
# Complete URI
SecRule REQUEST_URI "modsecuritytest2"
SecRule REQUEST_FILENAME "(?:n(?:map|et|c)|w(?:guest|sh)|cmd(?:32)?|telnet|rcmd|ftp)\.exe"
\end{verbatim}
~\\
Afin de sécuriser les requêtes vers l'extérieur, il est recommandé d'installation
un proxy tel que Squid. Voici le fichier squid.conf~:
\begin{verbatim}
# ports
http_port 8888 transparent
icp_port 0
# ACL
acl all src 0.0.0.0/0.0.0.0
acl localhost src 127.0.0.1/255.255.255.255
acl INTERNE src 1.2.3.4/32 127.0.0.0/8
acl Safe_ports port 80 # http
acl SSL_ports port 443 563
acl WHITELIST url_regex "/etc/squid/whitelist.conf"
http_access deny !WHITELIST
http_access allow INTERNE
http_access deny all
\end{verbatim}
Avec le fichier /etc/squid/whitelist.conf suivant :
\begin{verbatim}
http://.*debian.org/.*
http://zidane.evolix.net/.*
http://pub.evolix.net/.*
http://www.kernel.org/.*
http://pear.php.net/.*
http://.*akismet.com/.*
http://.*wordpress.org/.*
http://etc.inittab.org/.*
http://.*twitter.com/.*
http://feeds.feedburner.com/.*
http://feeds2.feedburner.com/.*
http://sync.openx.org/.*
http://oxc.openx.org/.*
http://code.openx.org/.*
http://pc.openx.com/.*
http://api.pc.openx.com/.*
http://bid.openx.net/.*
http://blog.openx.org/.*
http://forum.openx.org/.*
http://www.backports.org/.*
\end{verbatim}
Pour l'activer, on ajoute les regles suivantes dans le firewall :
\begin{verbatim}
#HTTPSITES='0.0.0.0/0'
# Proxy
/sbin/iptables -t nat -A OUTPUT -p tcp --dport 80 -m owner --uid-owner proxy -j ACCEPT
/sbin/iptables -t nat -A OUTPUT -p tcp --dport 80 -d 1.2.3.4 -j ACCEPT
/sbin/iptables -t nat -A OUTPUT -p tcp --dport 80 -d 127.0.0.1 -j ACCEPT
/sbin/iptables -t nat -A OUTPUT -p tcp --dport 80 -j REDIRECT --to-port 8888
\end{verbatim}
\section{Surveillance}
~\\
Apache génère donc les logs selon votre configuration.
Généralement, on retrouvera les erreurs dans error.log et les logs des VirtualHost là où on veut :)\\
~\\
\textbf{Analyse des logs :} awstats, webalizer, scanerrlog, webdruid, vlogger\\
~\\
\textbf{Outils :}
~\\
\begin{itemize}
\item[\textbf{ab}] - ApacheBench\\
\texttt{ab -n 5000 -c 100 http://www.domaine.com/index.html}\\
\item[\textbf{siege}] - outil de benchmark semblable à ab\\
\item[\textbf{tsung}] - outil de benchmark très puissant\\
\item[\textbf{apachetop}] - surveillance Apache en temps réel\\
\item[\textbf{Munin}] - surveillance notamment d'Apache via divers graphes\\
Installer le paquet libwww-perl et configurer mod\_status pour assurer
le bon fonctionnement des courbes.
\item[\textbf{awstats}] - analyse de logs\\
\textit{awstats.VHOST.conf} :\\
\begin{verbatim}
LogFile="/var/log/apache/access.VHOST.log"
SiteDomain="www.VHOST.tld"
Lang="fr"
[...]
\end{verbatim}
~\\
\textit{cron.d/awstats.VHOST}\\
{\small
\begin{verbatim}
30 * * * * root [ -x /usr/lib/cgi-bin/awstats.pl -a -f
/etc/awstats/awstats.VHOST.conf -a -r /var/log/apache/access.VHOST.log ]
&& /usr/lib/cgi-bin/awstats.pl -config=VHOST -update >/dev/null
\end{verbatim}
}
\end{itemize}
~\\
%http://www.SERVER.tld/cgi-bin/awstats.pl?config=VHOST
\newpage

209
support/debian.tex Normal file
View file

@ -0,0 +1,209 @@
% Copyright (c) 2004-2010 Evolix <info@evolix.fr>
% Permission is granted to copy, distribute and/or modify this document
% under the terms of the GNU Free Documentation License, Version 1.2
% or any later version published by the Free Software Foundation;
% with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
% A copy of the license is included at http://www.gcolpart.com/howto/fdl.html
\section{Focus sur Debian GNU/Linux}
\subsection{Méthodes d'installation}
Il existe donc diverses méthodes d'installation\footnote{\url{http://www.debian.org/distrib/}}~: \\
~\\
\begin{itemize}
\item{{\emph{À partir de CD-ROM (ou DVD-ROM)\footnote{\url{http://www.debian.org/CD/}}}}}\\
Pour obtenir un jeu de CD-ROM (ou DVD-ROM) de Debian, on passera par l'un des revendeurs\footnote{\url{http://www.debian.org/CD/vendors/}} ou par le réseau en téléchargeant des images\footnote{\url{http://www.debian.org/distrib/cd}}.\\
Les moyens de téléchargement sont sur des images complètes par HTTP/FTP sur des mirroirs\footnote{\url{http://www.debian.org/CD/http-ftp/}}, une construction d'image grâce à l'outil Jigdo\footnote{\url{http://atterer.net/jigdo/}} qui télécharge séparément tous les fichiers du CD-ROM (ou DVD-ROM)\footnote{\url{http://www.debian.org/CD/jigdo-cd/}} ou encore grâce au Peer-to-peer comme le système BitTorrent\footnote{\url{http://www.debian.org/CD/torrent-cd/}}.\\
\item{{\emph{À partir des disquettes\footnote{\url{http://www.debian.org/distrib/floppyinst}}}}}\\
On peut amorcer une installation de Debian à partir d'un nombre très réduit de disquettes
(pratique notamment en cas d'absence de lecteur CD-ROM utilisable).
Deux disquettes sont nécessaires pour débuter l'installation (disquettes Root et Rescue)
puis quatre autres pour charger le noyau et ses modules.\\
\item{{\emph{À partir du réseau}}}\\
Suite à l'installation à partir de disquettes ou à partir d'un CD-ROM minimal, on poursuit souvent l'installation par le réseau pour installer le système de base ainsi que les logiciels supplémentaires. En téléchargeant directement les paquets sur internet ou sur un mirroir local, il suffit donc d'une image minimale pour installer Debian GNU/Linux. Néanmoins, il est préférable de ne pas installer directement par internet car il faudrait ne pas connecter un serveur avant de l'avoir totalement sécurisé (et parce que les versions des paquets installés par défaut peuvent comporter des failles de sécurité). On préférera des mirroirs locaux, voir par exemple apt-proxy\footnote{\url{http://apt-proxy.sourceforge.net/}} ou apt-move\footnote{\url{http://ptitlouis.dyndns.org/~ptitlouis/doc/}}.\\
~\\
On peut également amorcer complètement l'installation de Debian par le réseau\footnote{\url{http://www.debianplanet.com/node.php?id=818}} si l'on possède un périphériphérique réseau amorçable.\\
~\\
\end{itemize}
{\textit{Remarques sur les possibilités d'installation}}\\
Les possibilités d'installation de Debian sont nombreuses. On notera que le programme debootstrap\footnote{\url{http://www.debian.org/releases/stable/i386/ch-rescue-boot.fr.html\#s-dbootstrap-intro}} permet d'installer Debian à partir d'un système de fichiers, qu'une installation automatisée est possible en passant l'argument \textsl{preseed}\footnote{\url{http://d-i.alioth.debian.org/manual/fr.i386/ch04s07.html}} à l'amorce de l'installation par CD-ROM (ou DVD-ROM) et que la personnalisation de l'installation est possible.
\\
(voir \url{http://people.debian.org/~osamu/hackdi/}) \\
%TODO
%http://thierrylhomme.developpez.com/cfengine.html
%http://www.informatik.uni-koeln.de/fai/fai-guide-fr/
%utiliser Kickstart pour Ubuntu Hoary
\subsection{Installation et réglages de base}
La version stable de Debian est toujours celle à privilégier
pour de nouvelles installations. Dans certains cas, dans les mois
précédents la sortie de la future version stable, celle-ci peut
être installé si le serveur n'est pas trop critique. Dans ces
périodes charnières, il faut bien prendre en compte qu'il existera
toujours des administrateurs qui affirmeront le contraire. Il faut donc
essayer de se faire un avis objectif à partir de plusieurs serveurs de
test avant toute décision importante.\\
~\\
%http://lists.debian.org/debian-devel-announce/2004/08/msg00001.html
%http://ftp-master.debian.org/testing/hints/freeze
%http://bugs.debian.org/release-critical/
Voici les recommandations que nous faisons à nos clients~:\\
~\\
\textit{Pour un serveur en production}\\
~\\
Nous conseillons d'utiliser Debian stable, à moins de vraiment nécessiter beaucoup de fonctionnalités présentes dans la prochaine version stable, et dans ce cas la version Debian testing peut être envisagée. \\
~\\
\textit{Pour un serveur en semi-production}\\
~\\
Dans un environnement non critique et dans l'optique est de préparer une future mise en production, Debian testing peut être utilisée si la version stable date de plus de 12 à 18 mois ; sinon l'utilisation de Debian stable reste à privilégier. \\
~\\
\textit{Pour un poste de travail}\\
~\\
Nous conseillons l'utilisation de Debian testing (voire unstable) afin d'avoir des versions récentes (mais néanmoins testées) des logiciels de bureautique. Cela permet de passer de façon souple vers la prochaine version stable lors de sa sortie et de l'utiliser pendant quelques mois avant de rebasculer vers Debian testing. \\
~\\
\textbf{Installation de Debian}\\
~\\
Revenons brièvement sur l'installation de Debian gérée par le Debian-Installeur\footnote{\url{http://www.debian.org/devel/debian-installer/}}~: \\
\begin{itemize}
\item{Démarrage, détection des cartes réseau, des paquets udebs (.udeb est un format particulier de paquet pour l'installeur)}
\item{Chargement éventuel de pilotes ou firmware}
\item{Outils de partitionnement, installation de base}
\item{Détection avancée des périphériques grâce à discover\footnote{\url{http://d-i.alioth.debian.org/manual/fr.i386/index.html}} ce qui permet de charger automatiquement les modules adéquats}
\item{Installation de GRUB, redémarrage}
\item{Configuration de base}
\end{itemize}
~\\
Après cette installation, on procédera à une mise-à-jour générale (sur un miroir local si possible), une installation d'outils pratiques, une compilation du noyau puis une sécurisation. Voici quelques outils pratiques à installer~: ssh vim less mailx metche sudo munin log2mail apt-listchanges apticron evocheck\\
\subsection{Système de packages Debian}
L'installation de nouveaux logiciels Open Source sous environnement Linux peut toujours se faire selon la méthode classique de recompilation des sources. Néanmoins cette méthode est peu aisée pour la gestion des dépendances, des mises-à-jour, etc. Ainsi les distributions utilisent souvent des systèmes de paquetage. Debian utilise des paquets à l'extension \texttt{.deb} qui fournissent non seulement les binaires précompilés (le plus souvent) mais également des méthodes de gestion pour faciliter la manipulation de ces paquets. \\
L'utilitaire basique de manipulation des paquets Debian porte le nom de \texttt{dpkg}. Il est important de bien maîtriser les différentes options de \texttt{dpkg} :
\begin{verbatim}
dpkg --unpack :
\end{verbatim}
le paquet est dépaqueté mais n'est pas configuré
\begin{verbatim}
dpkg --configure
\end{verbatim}
configuration d'un paquet
\begin{verbatim}
dpkg -i
\end{verbatim}
installation complète
\begin{verbatim}
dpkg -r
\end{verbatim}
supression du paquet
\begin{verbatim}
dpkg -r -P
\end{verbatim}
suppression complète (fichiers de configuration compris)
\begin{verbatim}
dpkg -L
\end{verbatim}
affiche la liste des fichiers appartenant au paquet
\begin{verbatim}
dpkg -S
\end{verbatim}
recherche un fichier dans les paquets installés
\begin{verbatim}
dpkg -l
\end{verbatim}
liste tous les paquets installés sur le système.
\begin{verbatim}
dpkg --get-selections / --set-selections
\end{verbatim}
Donne/installe la/une liste des paquets installés
~\\
Debian possède un programme de gestion avancée de paquets appelé APT (Advanced Packaging Tool).\\
Ce système gère les paquets d'après une liste (Packages.gz) et permet de gérer les dépendances, les mises-à-jour particulières ou globales ou encore les conflits. Le fichier qui référence toutes les sources de paquets disponibles est \texttt{/etc/apt/sources.list}. On peut gérer le contenu de ce fichier à l'aide de la fonction \texttt{apt-setup}. \\
~\\
Exemple de fichier \texttt{/etc/apt/sources.list} pour Debian Etch :\\
\begin{verbatim}
deb http://security.debian.org/ etch/updates main contrib non-free
deb ftp://ftp2.fr.debian.org/debian etch main contrib non-free
deb-src ftp://ftp2.fr.debian.org/debian etch main contrib non-free
\end{verbatim}
~\\
\texttt{dselect} est l'outil de gestion des paquets historique (dpkg a une dépendance envers dselect~!). Son utilisation n'est pas forcément aisée pour les novices. \\
~\\
Lien : \url{http://www.debian.org/releases/woody/i386/dselect-beginner}\\
~\\
La commande \texttt{apt-get} est une interface pour APT. Voici quelques commandes souvent utilisées~: \\
~\\
\texttt{apt-get update}\\
Cette commande resynchronise les informations sur les fichiers disponibles à partir des endroits spécifiés dans le \texttt{sources.list}. Cette commande récupère donc les fichiers Packages.gz et les analyse de manière à rendre disponibles les informations concernant les nouveaux paquets.\\
~\\
\texttt{apt-get upgrade}\\
Cette commande met à jour tous les paquets dont une version plus récente est disponible sans supprimer de paquets, ni en ajouter. \\
~\\
\texttt{apt-get dist-upgrade}\\
Cette commande met à jour les paquets (comme upgrade) en utilisant une gestion intelligente des changements de dépendances. Ainsi des paquets pourront être supprimés et des nouveaux paquets pourront être installés.\\
~\\
\texttt{apt-get install <paquet>}\\
Cette commande installe le paquet <paquet> ainsi que toutes ses dépendances nécessaires.
\begin{verbatim}
apt-get remove --purge <paquet>
\end{verbatim}
Cette commande supprime le paquet <paquet> ainsi que tous ceux qui en dépendent.\\
~\\
\texttt{apt-get clean}\\
Cette commande supprime les paquets installés du répertoire de cache d'APT (libère de l'espace disque). On peut également utiliser autoclean qui va supprimer uniquement les paquets les plus anciens et inutiles.\\
~\\
D'autres interfaces utilisent APT~:\\
~\\
\begin{itemize}
\item[{\textbf{aptitude}}]
Outil de gestion des paquets directement au-dessus d'APT. Il peut être utilisé comme alternative à apt-get (les "commandes apt-get" sont acceptées) et offre certains avantages supplémentaires\footnote{\url{http://www.debian.org/doc/manuals/reference/ch-package.fr.html\#s-aptitude}} (par exemple, aptitude retient les dépendances installées et les supprime lorsqu'elles ne sont plus nécessaires). Le Debian-Installeur utilise d'ailleurs aptitude et l'utilisation de cet outil est désormais recommandée. \\
~\\
\item[{\textbf{synaptic}}]
Outil graphique de gestion des paquets en GTK+ basé sur APT. Il permet d'utiliser la plupart des fonctions (recherche, installation, mise-à-jour, etc.)\\
\end{itemize}
~\\
Enfin de nombreux outils supplémentaires existent pour gérer les paquets~:
~\\
\begin{itemize}
\item[{\textbf{apt-cache}}] utilitaire permettant d'obtenir un certain nombre d'informations sur les paquets et le cache d'APT.\\
\item[{\textbf{apt-file}}] utilitaire permettant d'effectuer des recherches dans le système de paquets d'APT. À la différence d'apt-cache, on peut rechercher des informations précises (noms des fichiers du paquet) sur l'ensemble des paquets même si ils ne sont pas installés.\\
Exemple : \texttt{apt-file search stdio.h}\\
\item[{\textbf{apt-listbugs}}] outil qui liste automatiquement les bogues critiques avant d'installer les nouveaux packages, et, si des bogues critiques sont référencés, qui vous demande de confirmer ou non la mise à jour. Il permet de "blacklister" les paquets ayant des bogues critiques et donc de ne pas les installer.\\
\item[{\textbf{apt-show-versions}}] liste des paquetages installés.\\
\item[{\textbf{apticron}}] script pour signaler les mises-à-jour disponibles.\\
\end{itemize}
~\\
Lien : \url{http://www.debian.org/doc/manuals/apt-howto/}\\
~\\
\newpage
\emph{Problèmes dans la gestion des paquets}\\
~\\
Bien connaître le système de gestion de paquets Debian est une condition nécessaire pour un administrateur. Ainsi, s'il arrive un problème lors de l'installation ou la mise-à-jour (assez rare avec la version stable), on pourra déboguer les conflits. On gardera à l'esprit quelques commandes essentielles à utiliser avec précaution :\\
\begin{verbatim}
# apt-get -f install
\end{verbatim}
commande qui tente de corriger les éventuels problèmes lors d'une installation ou mise-à-jour
\begin{verbatim}
# dpkg --ignore-depends --force-all
\end{verbatim}
commande qui permet de forcer l'installation d'un paquet
\begin{verbatim}
# dpkg --configure -a
\end{verbatim}
commande qui relance les étapes de configuration de tous les paquets présents sur le système
% http://www.cyberdogtech.com/firewalls/

460
support/libre.tex Normal file
View file

@ -0,0 +1,460 @@
% Copyright (c) 2004-2010 Evolix <info@evolix.fr>
% Permission is granted to copy, distribute and/or modify this document
% under the terms of the GNU Free Documentation License, Version 1.2
% or any later version published by the Free Software Foundation;
% with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
% A copy of the license is included at http://www.gcolpart.com/howto/fdl.html
\chapter{Introduction à Unix/Linux}
\section{Les débuts}
En 1969, Ken Thompson\footnote{\url{http://www.cs.bell-labs.com/who/ken/}},
employé dans les laboratoires Bell\footnote{\url{http://cm.bell-labs.com/}},
développe UNICS (UNiplexed Information and Computing Service), système
d'exploitation mono-utilisateur écrit en langage assembleur. Rebaptisé UNIX,
Ken Thompson tenta en 1971 de réécrire le système en langage FORTRAN ou en B.
Entre-temps Dennis
Ritchie\footnote{\url{http://cm.bell-labs.com/cm/cs/who/dmr/}}, également
employé dans les laboratoires de Bell a pris part au projet, et mis au point
le successeur du langage B : le langage C. UNIX fut donc réécrit en langage C
et nommé UNIX Time-Sharing System (UTS). UNIX commença également à être diffusé
hors des laboratoires de Bell. Or les laboratoires de Bell appartiennent à la
société AT\&T qui ne peut commercialiser autre chose que des équipements
téléphoniques ou télégraphiques. La décision fut prise de distribuer le système
UNIX complet avec son code source complet dans les universités puis également
dans les entreprises. De nombreuses contributions furent apportées par
l'université de Berkeley (Californie) qui distribua ainsi UNIX BSD (Berkeley
Software Distribution).\\
Les laboratoires Bell développèrent le système UNIX Time-Sharing System
jusqu'en octobre 1989 (sa 10ème version). La branche commerciale d'AT\&T
développa les premières versions commerciales d'UNIX : System III puis System
V.\\
Les droits d'UNIX appartenant à AT\&T ont été rachetés par l'entreprise
Novell\footnote{\url{http://www.novell.com/}}. En 1994, Novell a transféré les
droits sur la marque UNIX ainsi que les spécifications à
l'OpenGroup\footnote{\url{http://www.opengroup.org/}}, et a également revendu
le code source et l'implémentation UNIXWARE (dérivée de System V) à
l'entreprise SCO\footnote{\url{http://www.sco.com/}}.\\
L'université de Berkeley développa UNIX BSD jusqu'en 1993 (4.4BSD) dont
dérivent les projets libres NetBSD, FreeBSD et OpenBSD mais également le
système d'exploitation d'Apple MAC OS X. Du fait de la mise à disposition du
code source d'UNIX, de nombreux dérivés propriétaires d'UNIX furent développés
: AIX (IBM), Solaris (Sun Microsystems), HP-UX (Hewlett-Packard), Ultrix (DEC),
Xenix (Microsoft), Unixware (SCO), Tru64 (DEC), IRIX (SGI), etc.\\
Les systèmes d'exploitation UNIX sont multi-tâches, multi-utilisateurs et en
général ouverts (code source disponible).\\
~\\
\textit{Liens :} \\
\url{http://fr.wikipedia.org/wiki/UNIX} \\
\url{http://www.commentcamarche.net/unix/} \\
\url{http://www.unix.org/} \\
\url{http://www.levenez.com/unix/} \\
\section{Historique des logiciels libres}
Au commencement de l'informatique, le matériel était volumineux et coûteux. On
se focalisait surtout sur l'équipement~: les codes des programmes étaient
disponibles gratuitement et chacun pouvait les améliorer librement. Avec
l'apparition de la micro-informatique dans les années 1980, les développements
de logiciels furent de plus en plus nombreux. De nombreuses restrictions
apparurent sur ces logiciels (licences, accord de non-divulgation) qui étaient
souvent vendus uniquement sous forme de binaires. En 1984, suite à des
problèmes liés à ces restrictions, Richard
Stallman\footnote{\url{http://www.stallman.org/}}, informaticien au
MIT(Institut de Technologie du Massachusetts), démissionne du laboratoire où il
travaille pour fonder le projet GNU\footnote{\url{http://www.gnu.org/}}. GNU
est un acronyme récursif qui signifie GNU's Not Unix (GNU n'est pas Unix).\\
Son ambition est de développer un système d'exploitation complètement libre et
promouvoir la liberté des logiciels. Ainsi, en 1985 est créée la Free Software
Fundation (FSF) qui a écrit un grand nombre de paquetages logiciels, notamment
GNU Compiler Collection (GCC) et Bourne-Again SHell
(BASH\footnote{\url{http://www.gnu.org/software/bash/}}). Des licences dites
libres ont également été rédigées, dont la GNU General Public License
(GPL\footnote{\url{http://www.gnu.org/copyleft/gpl.html}}) qui oblige les
programmes dérivés à rester avec la même licence.\\
~\\
D'autres licences dites libres existent comme la licence
BSD\footnote{\url{http://www.opensource.org/licenses/bsd-license.php}} qui
permet la réutilisation du code sous la dite licence dans des programmes
propriétaires. Le terme d'Open Source définit un ensemble de licences moins
restrictives. L'Open Source
Initiative\footnote{\url{http://www.opensource.org/licenses/}} publie sur son
site les licences dites Open Source.
~\\
La définition de liberté pour un logiciel n'est pas forcément triviale et
diffère selon certains organismes.\\
~\\
La Free Software Fundation (FSF) spécifie les 4 libertés pour un logiciel libre~: \\
\begin{itemize}
\item{La liberté d'exécuter le programme, pour tous les usages \textbf{(liberté 0)}.}
\item{La liberté d'étudier le fonctionnement du programme, et de l'adapter à vos besoins \textbf{(liberté 1)}. Pour ceci l'accès au code source est une condition requise.}
\item{La liberté de redistribuer des copies, donc d'aider votre voisin, \textbf{(liberté 2)}.}
\item{La liberté d'améliorer le programme et de publier vos améliorations,
pour en faire profiter toute la communauté \textbf{(liberté 3)}. Pour ceci
l'accès au code source est une condition requise.}
\end{itemize}
~\\
\textit{Lien :} \url{http://www.gnu.org/philosophy/free-sw.fr.html} \\
~\\
\section{Définitions des 'logiciels libres'}
Le projet Debian spécifie ses propres principes du logiciel libre~: \\
\begin{itemize}
\item{redistribution libre et gratuite}
\item{distribution du code source}
\item{aucune discrimination de personne ou de groupe}
\item{aucune discrimination de champ d'application}
\item{distribution de licences}
\item{la licence ne doit pas être spécifique à Debian}
\item{la licence ne doit pas contaminer d'autres logiciels}
\end{itemize}
~\\
\textit{Lien :} \url{http://www.debian.org/social\_contract#guidelines} \\
~\\
L'Open Source Initiative (OSI) spécifie les critères pour un logiciel Open
Source, inspirés des principes du logiciel libre selon Debian~: \\
\begin{itemize}
\item{Libre redistribution}
\item{Code source}
\item{Travaux dérivés}
\item{Intégrité du code source de l'auteur}
\item{Aucune discrimination envers les personnes ou les groupes}
\item{Aucune discrimination envers les champs d'effort}
\item{Distribution de la licence}
\item{Licence non spécifique d'un produit}
\item{Licence non restrictive envers d'autres produits}
\item{Licence neutre technologiquement}
\end{itemize}
~\\
\textit{Lien~:} \url{http://opensource.org/docs/definition.php} \\
~\\
On se rend compte que la définition d'un logiciel libre est beaucoup plus
complexe qu'on pourrait le croire. Elle s'appuie notamment sur la notion de
respect des droits d'auteurs, comme tout écrit, et non sur la notion de brevets
valables pour les inventions. Il faut noter que la notion de brevets logiciels
existe désormais dans plusieurs pays (notamment aux États-Unis) et des
discussions ont lieu au niveau de l'Europe pour l'adoption de ce
principe.\footnote{\url{http://brevets-logiciels.info/}}\\
~\\
Pour bien se rendre compte des subtilités entre les différentes appellations,
il suffit d'énumérer quelques catégories de logiciels~:
\footnote{\url{http://www.gnu.org/philosophy/category.fr.jpg}}\\
\begin{itemize}
\item{Logiciel libre}
\item{Logiciel Open source}
\item{Logiciel du domaine public}
\item{Logiciel copylefté (sous gauche d'auteur)}
\item{Logiciel libre non-copylefté}
\item{Logiciel couvert par la GPL}
\item{Logiciel privé}
\item{Logiciel propriétaire}
\item{Shareware (Partagiciel)}
\item{Freeware}
\end{itemize}
~\\
\textit{Lien :} \url{http://www.gnu.org/licenses/license-list.fr.html}
\begin{itemize}
\item{\textbf{La licence GNU General Public License
(GPL)}\footnote{\url{http://www.gnu.org/copyleft/gpl.html}}\\ Cette licence a
été écrite par la FSF (Free Software Foundation) comptant pour membres Richard
Stallman et Eben Moglen\footnote{\url{http://emoglen.law.columbia.edu/}}. Elle
a été écrite pour fixer les conditions légales de distribution des logiciels du
projet GNU.\\
Elle fait partie des licences restrictives (notion de copyleft). Il faut aussi
savoir que c'est probablement la licence libre la plus utilisée aujourd'hui
(Linux, GCC, KDE, Gnome, etc.).\\
~\\
\textit{Liens :} \\
\url{http://www.gnu.org/copyleft/gpl.html} \\
\url{http://www.linux-france.org/article/these/gpl.html}\\
\url{http://fsffrance.org/gpl/gpl.fr.html}\\
\url{http://crao.net/gpl/}\\
\item{\textbf{Les licences de type BSD}} \\
~\\
La licence BSD originale est une licence simple et permissive (elle n'est pas
soumise au principe du copyleft). Néanmoins, elle comporte une clause de
publicité qui a provoqué de nombreux débats (la licence impose un texte à
mentionner chaque fois que le logiciel est cité). Cette clause a été supprimée
par la suite dans ce qu'on appelera la licence BSD modifiée.\\
Cette licence et des variantes de cette dernière sont utilisées notamment par
les projets FreeBSD, NetBSD, OpenBSD, etc.\\
Elle ne comporte aucune restriction, ce qui permet à des sociétés comme
Microsoft de réutiliser le code source placé sous cette licence, ou
d'inclure dans MacOSX des parties de FreeBSD et d'OpenBSD.\\
L'université de Berkeley développa UNIX BSD jusqu'en 1993 (4.4BSD) dont
dérivent MAC OS X (Apple) ainsi que de nombreux projets libres comme NetBSD,
FreeBSD et OpenBSD, etc.\\
~\\
Le projet OpenBSD définit un logiciel libre, comme un logiciel sous une licence
n'apportant aucune restriction. Certaines licences peuvent être acceptées pour
certaines parties.\\
La capacité à disposer d'un Unix Berkeley librement distribuable permet
d'avancer sur une base compétitive par rapport aux autres systèmes
d'exploitation, mais dépend directement de la volonté des différents
groupes de développement qui échangent des sources, entre-eux et entre
projets. Comprendre les implications légales qui entourent le concept
de "copyright" est fondamental afin de pouvoir échanger et redistribuer
du code source, et somme toute de promouvoir la coopération des
personnes impliquées.\\
~\\
Chaque système se concentre sur des points particuliers, ou du moins en
théorie :\\
\begin{itemize}
\item FreeBSD est orienté performances et applications; l'enjeu n'est
clairement pas de supporter un grand nombre d'architectures
\item NetBSD mise sur la portabilité avant tout, avec un grand nombre
d'architectures supportées.
\item OpenBSD accentue ses efforts de développement sur la sécurité, de
son système et des applications qui le composent. Une grande attention est portée au niveau des licences.
\end{itemize}
Il existe également d'autres systèmes BSD moins connus, comme
DragonflyBSD, etc.
~\\
\textit{Lien :} \url{http://www.opensource.org/licenses/bsd-license.php} \\
\item{\textbf{La licence Artistique}} \\
Licence mise en place par le créateur de Perl, Larry Wall. Outre les droits
d'utilisation, de modification, et de distribution, l'auteur conserve certains
droits (droit de négocier des arrangements au coup par coup, interdiction de
diffuser une version entrant en conflit avec la distribution "standard" de
l'auteur).\\
~\\
\textit{Liens :}\\
{\small
\url{http://www.opensource.org/licenses/artistic-license.php}\\
\url{http://www.perl.com/pub/language/misc/Artistic.html}\\
\url{http://linux-france.org/article/these/licence/artistic/fr-artistic.html}\\
}
\\
\item{\textbf{La GNU Lesser General Public License (LGPL)}} \\
LGPL signifie Licence publique générale limitée GNU, ou GNU LGPL (pour GNU
Lesser General Public License) en anglais. Comme la Licence publique générale
GNU (ou GNU GPL), elle a été écrite par la Free software foundation. La
différence avec la GPL est que la LGPL permet de lier un programme tiers non
libre à une bibliothèque LGPL, sans pour autant révoquer la licence (licence
non copyleft). Elle est surtout utilisée pour des librairies (elle s'appellait
initalement Library General Public License) \\
~\\
\textit{Lien :} \url{http://www.gnu.org/licenses/lgpl.html} \\
\item{\textbf{Licence Apache}} \\
La licence Apache en est à sa Version 2.0 (approuvée le 21 janvier 2004 par la
fondation Apache). Tous les projets Apache (dont Ant, Jakarta, ou Cocoon) sont
sous cette licence. Cette licence est libre, non-copyleft, et compatible GPL
(en version 1.0 et 1.1, la Apache License n'était pas compatible GPL).\\
~\\
\textit{Lien :} \url{http://www.apache.org/licenses/} \\
\item{\textbf{Licence X11 (ou MIT)}} \\
Cette licence est simple et permissive, sans copyleft, compatible avec la GPL
de GNU. Les anciennes versions de XFree86 utilisaient cette licence, et
quelques variantes actuelles de XFree86 l'utilisent également. Les licences
ultérieures de XFree86 sont distribuées sous la licence XFree86 1.1 (qui est
incompatible avec la GPL). La licence est parfois appelée «licence du MIT» mais
ce terme est trompeur : le MIT a publié ses logiciels sous diverses licences.\\
~\\
\textit{Liens :} \\
\url{http://www.x.org/Downloads\_terms.html}\\
\url{http://www.opensource.org/licenses/mit-license.php}\\
\item{\textbf{Licence Mozilla Public Licence}} \\
Cette licence n'est pas très stricte en terme de "copyleft"; contrairement à la
licence X11 elle présente des restrictions complexes qui la rendent
incompatibles avec la GPL de GNU. Ainsi, on ne peut pas, légalement, lier un
module couvert par la GPL et un module couvert par la MPL. Pour entrer dans le
détail, la licence MPL 1.1 permet (section 13) à un programme ou à une portion
de programme d'offrir le choix entre la MPL et une autre licence. La licence
d'une partie de programme qui offre le choix de la GPL est alors compatible
avec la GPL. Les logiciels de Mozilla mais également NVu (création de pages
Web), Compière (ERP/CRM) sont sous licence MPL. SugarCRM utilise la SPL
(SugarCRM Public Licence) qui est très proche de la MPL.\\
~\\
\textit{Liens :}\\
\url{http://www.mozilla.org/MPL/} \\
\url{http://www.sugarcrm.com/home/Public\_License\_FAQ/228/} \\
\item{\textbf{Licence IBM Public License}} \\
Cette licence en est à sa version 1.0 et est incompatible avec la GPL en raison
de d'exigences spécifiques. Elle exige notamment que certains droits soient
accordés en-dehors de ce que la GPL prévoit.\\
~\\
\textit{Lien :} \url{http://oss.software.ibm.com/developerworks/opensource/license10.html}} \\
\item{\textbf{Licence Sendmail \footnote{\url{http://www.sendmail.org/}}}}
~\\
Il s'agit de la licence du serveur de messagerie électronique éponyme, le plus populaire sur Internet. \\
~\\
\textit{Lien :} \url{ftp://ftp.sendmail.org/pub/sendmail/LICENSE} \\
\item{\textbf{Licence Common Public License}} \\
Licence libre qui n'est pas compatible avec la GPL. La Common Public
License est incompatible avec la GPL parce qu'elle énonce diverses
exigences spécifiques qui ne se trouvent pas dans la GPL. Elle exige
notamment que certaines licences de brevets soient données, ce que la GPL n'exige pas. \\
~\\
\textit{Lien :} \url{http://www.eclipse.org/legal/cpl-v10.html} \\
~\\
\textbf{\textit{Licences pour un usage particulier}}
~\\
\item{\textbf{Licence GNU Free Documentation License}} \\
Cette licence a été conçue pour les documents sous copyleft. Elle convient pour d'autres catégories d'oeuvres utiles telles que les manuels scolaires ou les dictionnaires, par exemple. Son domaine d'application n'est d'ailleurs pas exclusivement celui des oeuvres textuelles.\\
~\\
\textit{Lien :} \url{http://www.gnu.org/copyleft/fdl.html} \\
\item{\textbf{Les licences Creative Commons}} \\
Des juristes de l'université de Stanford ont créé un ensemble de licences
destinées aux contenus tels que l'audio, la vidéo, les images, les textes et
les ressources éducatives. Le but est de faciliter la mise à disposition et le
partage de ces contenus aux auteurs avec les restrictions qu'ils veulent (usage
commercial, possibilité de modifications, etc.) Il suffit en effet de
visualiser deux ou trois pages illustrées d'images explicites sur le site
Internet pour choisir la licence appropriée. \\
~\\
\textit{Liens :} \\
\url{http://creativecommons.org/} \\
\url{http://fr.creativecommons.org/} \\
\url{http://philippe.daigremont.free.fr/CreativeCommons/BD/} \\
\item{\textbf{Licence Art Libre}} \\
Cette licence libre copyleftée est faite pour les oeuvres artistiques. Elle
autorise la distribution commerciale, tout en précisant qu'une oeuvre de plus
grande taille qui inclurait l'oeuvre soumise à la licence doit être elle-même
libre.\\
~\\
\textit{Lien :} \url{http://artlibre.org/licence.php/lal.html}\\
~\\
\end{itemize}
\section{Modèle de développement}
Le modèle de développement des logiciels libres connaît un vif succès grâce à
l'expansion des réseaux et d'Internet dans les années 1990. Ainsi, de nombreux
projets (dont l'un des plus marquants est Linux) voient le jour avec une
communauté répartie dans le monde entier. Des logiciels initiés à des buts
commerciaux basculent également sous des licences libres afin de profiter des
avantages de la communauté du logiciel libre (beta-testeurs nombreux,
accroissement de l'équipe de développeurs, politique de sécurité, etc.). Parmi
les logiciels libres, on distingue donc de nombreux projets issus de
communautés (Apache, Debian, FreeBSD, NetBSD, Sendmail, etc.) et des projets
proches d'entreprises commerciales (Mandrake, Red Hat, OpenOffice, etc.). \\
~\\
En ce qui concerne l'organisation, la philosophie des logiciels libres basée
sur l'ouverture n'empêche pas une structuration précise. On peut ainsi dégager
un modèle de développement typique qui comprend~: \\
\begin{itemize}
\item{Une ou plusieurs personnes responsables globalement du projet (souvent à l'initiative du projet ou élues)}
\item{Plusieurs développeurs officiels du projet ayant été acceptés avec précaution}
\item{Des contributeurs occasionnels qui font généralement parvenir leurs contributions aux développeurs officiels}
\item{Des utilisateurs avancés qui participent activement aux forums, listes de diffusion, canaux IRC}
\item{Des utilisateurs de base qui ont à leur disposition, outre le logiciel, une documentation et des moyens d'interaction (demande de fonctionnalités, rapport de bogues)}
\item{On note aussi la nécessité de rédacteurs de documentation, de relecteurs, de traducteurs, de webmasters, etc.}
\end{itemize}
~\\
On constate que ce modèle de développement nécessite l'utilisation de nombreux
outils. Il existe des plateformes mises à la disposition des projets de
développement proposant un panel d'outils : hébergement de site Web,
hébergement des courriels électroniques, forums, listes de diffusion, outils de
développement, miroirs de téléchargements, etc. Parmi ces plateformes, on note
SourceForge\footnote{\url{http://www.sourceforge.net/}} (plus de 100.000
projets), FreshMeat\footnote{\url{http://freshmeat.net/}} (plus de 45.000
projets), Savannah\footnote{\url{http://savannah.gnu.org/}} (plus de 3.000
projets) ou encore Gna\footnote{\url{https://gna.org/}},
Tuxfamily\footnote{\url{http://www.tuxfamily.org/}} ou
Berlios\footnote{\url{http://www.berlios.de/}}. \\
~\\
En ce qui concerne les outils de développements collaboratifs, on note le
logiciel très utilisé CVS\footnote{\url{https://www.cvshome.org/}}
(mises-à-jour contrôlées, téléchargement souvent public), mais aussi des outils
plus récents tels que SVN\footnote{\url{http://subversion.tigris.org/}} et
Arch\footnote{\url{http://www.gnu.org/software/gnu-arch/}} ou encore
GIT\footnote{\url{http://git.or.cz/}}. Pour la gestion des outils de
communication, on note les outils de publication web
(SPIP\footnote{\url{http://www.spip.net/}},
Wiki\footnote{\url{http://en.wikipedia.org/wiki/Wiki}}), les forums
(PHPBB\footnote{\url{http://www.phpbb.com/}},
Phorum\footnote{\url{http://phorum.org/}}), les gestionnaires de listes de
diffusion (Sympa\footnote{\url{http://www.sympa.org/}},
Mailman\footnote{\url{http://www.gnu.org/software/mailman/}}), les serveurs IRC
(Freenode\footnote{\url{http://freenode.net/}},
Undernet\footnote{\url{http://www.undernet.org/}}), etc. \\
~\\
La connaissance de ces outils permet de mieux appréhender la diversité des
membres de la communauté du logiciel libre. Des règles sont implicites aux
utilisateurs finaux, à savoir lire la documentation officielle, les FAQ (Foires
Aux Questions) ainsi que les archives des forums ou listes de diffusion avant
d'utiliser les outils de communication. On se référera aux documents "Les
règles de la
Netiquette"\footnote{\url{http://www.sri.ucl.ac.be/SRI/rfc1855.fr.html}},
"Comment poser les questions de manière
intelligente"\footnote{\url{http://www.gnurou.org/documents/smart-questions-fr.html}},
"Comment signaler efficacement un
bug"\footnote{\url{http://www.chiark.greenend.org.uk/~sgtatham/bugs-fr.html}}
ou encore "Comment faire un rapport sans se faire
lyncher"\footnote{\url{http://www.asktog.com/columns/047HowToWriteAReport.html}}.
Il faut bien noter l'organisation souvent pyramidale du modèle de
développement. Ainsi, même s'il est souvent possible de contacter directement
les responsables d'un projet par courrier électronique, cela se fera avec
réserve et uniquement pour des questions majeures. Il semble aussi entendu que
pour obtenir des droits ou des responsabilités dans un projet, les échelons se
gravissent petit à petit.\\
~\\
Les logiciels en eux-mêmes, produits finaux des équipes de développement, sont
souvent disponibles sous plusieurs formes. Généralement, on distingue une
version dite stable et une version en cours de développement. La version stable
est une version ayant subi plusieurs phases de tests et corrections. C'est
cette version que le projet propose d'installer aux utilisateurs de base et
c'est encore plus vrai en environnement professionnel.\\
La version en cours de développement (parfois accessible à partir des outils de
développements collaboratifs comme CVS) est à réserver aux développeurs, aux
utilisateurs désirant contribuer en rapportant les erreurs, ou bien aux
impatients.\\
Il faut noter que les contraintes imposées à une version stable diffèrent d'un
projet à un autre. Ce sera également le cas avec les numéros de version, qui
n'ont plus grande signification du fait des politiques de numérotation
différentes entre les projets. À l'exception des mentions "Version Beta",
"Realease Candidate"... qui signifient qu'il s'agit de versions en cours de
correction et validation avant une sortie officiellement stable. Sans que cela
soit une règle absolue, on peut néanmoins distinguer certaines règles communes,
voir par exemple une tentative de formalisation de certaines
conventions\footnote{\url{http://semver.org/}}.\\
~\\
Les utilisateurs de logiciels libres prennent donc part au modèle de
développement grâce au support communautaire qui leur permet non seulement de
trouver de l'aide mais de rapporter les erreurs éventuellement rencontrées et
de demander l'ajout de nouvelles fonctionnalités. Parmi les utilisateurs de
logiciels, on trouve également de nombreuses structures professionnelles.
Ainsi, les contraintes engendrées par l'utilisation dans un environnement
professionnel ont nécessité la création de support commercial pour certains
logiciels libres. De même, on constate l'apparition de structures spécialisées
dans le support de solutions libres.\\
En France, il existe ainsi de nombreuses SS2L (Société de Service en Logiciels
Libres) réparties sur le territoire. D'une manière générale, l'utilisation des
logiciels libres dans le monde professionnel est un phénomène en vogue
actuellement ; il en résulte souvent de nombreux avantages (fiabilité accrue,
correction de bogues, etc.) pour les logiciels libres concernés. \\
~\\
\textit{Liens :} \\
\url{http://www.gnu.org/prep/SERVICE} \\
\url{http://www.linux-france.org/article/pro/annuaire/} \\

546
support/linux.tex Normal file
View file

@ -0,0 +1,546 @@
% Copyright (c) 2004-2010 Evolix <info@evolix.fr>
% Permission is granted to copy, distribute and/or modify this document
% under the terms of the GNU Free Documentation License, Version 1.2
% or any later version published by the Free Software Foundation;
% with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
% A copy of the license is included at http://www.gcolpart.com/howto/fdl.html
\chapter{Systèmes GNU/Linux}
\section{Présentation de Linux}
Linux est un noyau de système d'exploitation de type UNIX créé par Linus
Torvalds et de nombreux développeurs. \\
Tout ordinateur inclue un ensemble basique de programmes appelé système
d'exploitation. Le programme le plus important d'un système d'exploitation est
appelé le noyau : il est chargé dans la mémoire physique (RAM) quand le système
démarre et contient les instructions nécessaires à l'ordinateur pour
fonctionner. Les autres programmes permettent d'interagir avec l'ordinateur
mais ils sont moins importants car les possibilités d'interaction avec
l'ordinateur sont déterminées par le noyau. \\
Le 5 octobre 1991, Linus Torvalds, un informaticien finlandais, annonce sur un
forum Usenet la disponibilité du système d'exploitation Linux, inspiré de
Minix.
\begin{verbatim}
From: Linus Benedict Torvalds (torvalds@klaava.Helsinki.FI)
Subject: Free minix-like kernel sources for 386-AT
Newsgroups: comp.os.minix
Date: 1991-10-05 08:53:28 PST
Do you pine for the nice days of minix-1.1, when men were men and wrote
their own device drivers? Are you without a nice project and just dying
to cut your teeth on a OS you can try to modify for your needs? Are you
finding it frustrating when everything works on minix? No more all-
nighters to get a nifty program working? Then this post might be just
for you
As I mentioned a month ago, I'm working on a free version of a
minix-lookalike for AT-386 computers. It has finally reached the stage
where it's even usable (though may not be depending on what you want),
and I am willing to put out the sources for wider distribution. It is
just version 0.02 (+1 (very small) patch already), but I've successfully
run bash/gcc/gnu-make/gnu-sed/compress etc under it.
Sources for this pet project of mine can be found at nic.funet.fi
(128.214.6.100) in the directory /pub/OS/Linux. The directory also
contains some README-file and a couple of binaries to work under linux
(bash, update and gcc, what more can you ask for . Full kernel
source is provided, as no minix code has been used. Library sources are
only partially free, so that cannot be distributed currently. The
system is able to compile "as-is" and has been known to work. Heh.
Sources to the binaries (bash and gcc) can be found at the same place in
/pub/gnu.
[...]
I can (well, almost) hear you asking yourselves "why?". Hurd will be
out in a year (or two, or next month, who knows), and I've already got
minix. This is a program for hackers by a hacker. I've enjouyed doing
it, and somebody might enjoy looking at it and even modifying it for
their own needs. It is still small enough to understand, use and
modify, and I'm looking forward to any comments you might have.
I'm also interested in hearing from anybody who has written any of the
utilities/library functions for minix. If your efforts are freely
distributable (under copyright or even public domain), I'd like to hear
from you, so I can add them to the system. I'm using Earl Chews estdio
right now (thanks for a nice and working system Earl), and similar works
will be very wellcome. Your (C)'s will of course be left intact. Drop me
a line if you are willing to let me use your code.
Linus
\end{verbatim}
Linux est multi-tâches, multi-utilisateurs et compatible Unix (il respecte les
normes POSIX). Conçu au départ pour les machines de type Intel x86, Linux est
maintenant disponible pour les architectures PowerPC, Alpha, MIPS, Sparc, etc. \\
Les sources de Linux sont disponibles (sous licence GPL) et l'explosion
d'Internet a permis un mode de développement innovant~: de nombreux
développeurs (bénévoles ou rémunérés par des entreprises) participent au
développement de Linux et forment avec tous les utilisateurs une communauté.
Linux est d'ailleurs l'un des exemples les plus connus de logiciel libre.\\
L'un des objectifs du projet GNU est d'avoir un système d'exploitation
complètement libre. Or, de très nombreux outils ont été développés par le
projet GNU (GCC, Bash, etc.) mais Hurd, noyau développé par le projet GNU,
tardant à sortir, Linux a été adopté par le projet GNU en 1993 pour être le
noyau du système prôné par le projet GNU. L'ensemble formé par les outils du
projet GNU et du noyau Linux est souvent appelé système GNU/Linux.\\
Une distribution est un système GNU/Linux avec un certain de nombre de choix et
d'outils mis à disposition pour gérer au mieux les logiciels et leurs
configurations. Il existe un grand nombre de distributions adaptées à un usage
(ou un matériel) spécifique. Les distributions généralistes les plus connues
sont Red Hat, Debian, Mandriva, SuSe, Gentoo, Slackware, Fedora.
\section{Méthode d'installation}
Il existe diverses méthodes d'installation~: \\
Dans les années 1990, on installait un système GNU/Linux à l'aide de
(nombreuses) disquettes. Aujourd'hui la méthode d'installation la plus répandue
est d'utiliser un jeu de CD-ROM ou un DVD-ROM téléchargé sur Internet par HTTP ou
FTP. D'autres méthodes existent selon les distributions et peuvent s'avérer
très pratiques notamment des installations amorcées par le réseau.~\\
En cas de problème à l'installation d'un système GNU/Linux, voici quelques suggestions~: \\
~\\
\begin{itemize}
\item{Prendre garde à la fiabilité des périphériques d'amorçage (CD-ROM, DVD-ROM) en vérifiant systématiquement l'empreinte MD5 des CD-ROMs}\\
\item{Prendre connaissance des paramètres spécifiques d'amorçage du noyau Linux permettant d'éviter certains dysfonctionnements.}\\
\item{Pour les controleurs RAID ou cartes réseau exotiques (ou récentes), il faudra peut-être charger un module spécifique lors de l'installation.} \\
\item{Vérifier la compatibilité du matériel. Il existe plusieurs sites dont le "HardWare Howto"\footnote{\url{http://www.tldp.org/HOWTO/Hardware-HOWTO/}} ou encore le "Debian GNU/Linux device driver check page"\footnote{\url{http://kmuto.jp/debian/hcl/}}}\\
\item{Utiliser les moyens de support communautaire tels que les listes de diffusion ou les canaux IRC. En cas de bogue (ou pas) avec l'installation de Debian, il faut rapporter le bogue pour le pseudo-paquet "installation-reports"\footnote{\url{http://www.debian.org/devel/debian-installer/report-template}}}\\
\item{Un support professionnel peut également être trouvé auprès de sociétés de services en logiciels libres.}
\end{itemize}
~\\
\textit{Liens~:} \\
\url{http://www.tldp.org/HOWTO/BootPrompt-HOWTO.html}\\
\url{http://people.debian.org/~blade/install/preload/index.old.html}\\
\url{http://www.gnu.org/prep/service.html}\\
\section{Systèmes de fichiers}
Il existe une norme appelée Filesystem Hierarchy Standard\footnote{\url{http://www.pathname.com/fhs/}} à laquelle se conforment certaines distributions. Rappelons la hiérarchie du système de fichiers (cela varie d'une distribution à une autre) d'un système GNU/Linux~: \\
~\\
\begin{center}
\begin{tabular}{|c|c|}
\hline
Arborescence & Contenu \\
\hline
bin & Binaires (exécutables) des commandes essentielles \\
\hline
boot & Fichiers statiques pour le chargeur d'amorçage (boot) \\
\hline
dev & Fichiers des pilotes de périphériques \\
\hline
etc & Configuration système propre à la machine \\
\hline
home & Répertoires personnels des utilisateurs \\
\hline
lib & Bibliothèques partagées et modules noyaux essentiels \\
\hline
mnt,media & Points de montage pour les montages temporaires \\
\hline
proc,sys & Répertoire virtuel pour les informations systèmes \\
\hline
root & Répertoire personnel de l'utilisateur root \\
\hline
sbin & Exécutables système essentiels \\
\hline
tmp & Fichiers temporaires \\
\hline
usr & Hiérarchie secondaire \\
\hline
var & Données variables \\
\hline
opt & Suites applicatives additionnelles \\
\hline
srv & Données pour les services \\
\hline
\end{tabular}
\end{center}
~\\
\section{Partitionnement}
\textbf{Conseils de partitionnement} \\
~\\
Pour une machine de type serveur, on appliquera un partitionnement\footnote{\url{http://www.tldp.org/HOWTO/Partition/}} plus réfléchi qu'un poste de travail (où l'on se contente souvent d'isoler la partition contenant le répertoire home, la partition swap et le système). Il n'existe pas de vérité absolue (cela varie selon l'utilité de la machine et les habitudes des administrateurs) mais on passera en revue certaines recommandations. Voici quelques détails sur la taille des partitions destinées à accueillir certains répertoires~: \\
\begin{itemize}
\item{/boot/ : partition d'environ 100 Mo}
\item{/ : partition supérieure à 100 Mo (conseil~: 500 Mo)}
\item{/tmp : quelques centaines de Mo ou davantage dans des cas particuliers}
\item{/var : partition supérieure à 250 Mo (conseil~: plusieurs Go si possible)}
\item{/usr : partition supérieure à 500 Mo (conseil~: quelques Go)}
\item{/home : à voir selon les quotas et le nombre d'utilisateurs}
\item{swap : partition supérieure à 16 Mo et inférieure à 2 Go (systèmes 32-bits). On conseille souvent de mettre la même taille (ou le double) de la mémoire physique (sauf pour des applications spécifiques comme Oracle par exemple ou dans les cas de taille très importante de la mémoire physique) et si possible proche du centre du disque.\\
D'autres espaces spécifiques notamment pour l'espace web, la base de données pourront être créés selon les utilisations.}
~\\
\end{itemize}
\textbf{Exemple de partitionnement pour un disque d'environ 40 Go~:} \\
~\\
\begin{center}
\begin{tabular}{|c|c|c|}
\hline
Partition & Rep.montage & Taille \\
\hline
sda1 & /boot & 100 Mo \\
\hline
sda3 & / & 500 Mo \\
\hline
sda4 & /usr & 3 Go \\
\hline
sda6 & /var & 5 Go \\
\hline
sda7 & /tmp & 500 Mo \\
\hline
sda8 & /mnt/ftp & 1 Go \\
\hline
sda9 & swap & 500 Mo \\
\hline
sda10 & /home & 20 Go \\
\hline
\end{tabular}
\end{center}
~\\
\textbf{Programmes de partitionnement} \\
~\\
{\emph{fdisk}}\\
Programme de partitionnement en ligne de commande très répandu. Lire la page de manuel pour en savoir plus. \\
\textit{Lien :} \url{http://evolix.org/man/fdisk.html} \\
~\\
{\emph{cfdisk}}\\
Programme de partitionnement graphique en console. Il est utilisé par défaut lors de l'installation sous Debian Woody. Son utilisation est plutôt simple et intuitive. \\
\textit{Lien :} \url{http://evolix.org/man/cfdisk.html} \\
~\\
{\emph{sfdisk}}\\
Programme de partitionnement en ligne de commande. sfdisk a quatre utilisations principales~: liste la taille d'une partition, liste les partitions d'un périphérique, vérifier une partition sur un périphérique, et repartitionner un périphérique.\\
\textit{Lien :} \url{http://evolix.org/man/sfdisk.html} \\
~\\
{\emph{parted}}\\
Programme de partitionnement en ligne de commande. GNU Parted est notamment indispensable pour gérer des partitions sur des volumes d'une taille importante (supérieure à 2 To) en permettant la gestion des tables de partitions GPT\\
\textit{Lien :} \url{http://www.gnu.org/software/parted/} \\
\section{Gestion des disques}
~\\
%\emph{Disques de grande capacité}\\
%\textit{Lien :} \url{http://www.freenix.org/unix/linux/HOWTO/Large-Disk-HOWTO.html}\\
%~\\
\emph{Systèmes multi-disques}\\
\textit{Lien :} \url{http://tldp.org/HOWTO/Multi-Disk-HOWTO.html}\\
~\\
{\it{\bf LVM}}\\
~\\
LVM (Logical Volume Manager) permet une gestion plus aisée que l'utilisation classique disques et partitions. Cela permet une plus grande flexibilité pour redimensionner les volumes en fonction des besoins et des nouveaux disques disponibles.\\
\textit{Lien :} \url{http://www.tldp.org/HOWTO/LVM-HOWTO/} \\
~\\
{\it{\bf RAID}}\\
~\\
Le RAID (Redundant Arrays of Inexpensive Disks) est une solution bien connue pour obtenir des disques redondants afin de sécuriser les machines demandant une qualité de service élevée. On parlera bien sûr ici de RAID logiciel.\\
\textit{Lien :} \url{http://www.tldp.org/HOWTO/Software-RAID-HOWTO.html} \\
~\\
{\small{Note : Nous recommandons d'utiliser le RAID logiciel et/ou LVM avec prudence pour les répertoires sensibles tels que /boot et le répertoire racine. Une solution de RAID matériel sera à privilégier bien que plus coûteuse.}} \\
~\\
\textbf{Choix du système de fichiers journalisé : ext3, ReiserFS, XFS ou JFS} \\
~\\
Il existe de nombreuses comparaisons entre ces systèmes de fichiers mais il est difficile d'en tirer des conclusions générales car cela dépend beaucoup de l'utilisation de la machine. La fiabilité de ces systèmes est désormais éprouvée même si la prudence naturelle des administrateurs poussera à conserver ext3\footnote{\url{http://www.zip.com.au/~akpm/linux/ext3/}}, dérivé du système de fichier historique (Extended File System a été implémenté en 1992 et intégré à Linux 0.96c). En terme de performances, il semble se dégager quelques constations comme la performance de ReiserFS\footnote{\url{http://www.namesys.com/}} pour les petits fichiers, un léger gain de XFS\footnote{\url{http://oss.sgi.com/projects/xfs/}} pour la copie de fichiers de grande taille mais une lenteur à l'effacement et la bonne tenue d'ext3 pour des opérations classiques. JFS\footnote{\url{http://www-124.ibm.com/developerworks/oss/jfs/}} semblant légèrement moins performant pour le moment. \\
~\\
Sachant la perpétuelle évolution des développements, les conditions dans lesquelles se déroulent les tests et les autres paramètres (processeur, mémoire...) on se gardera bien de tirer des conclusions définitives. Disons simplement que l'utilisation de ext3 est encore assez raisonnable pour des serveurs classiques. En ce qui concerne ext4, il manque encore du recul pour l'utiliser dans des environnements critiques.\\
~\\
\textit{\textit{Liens :}}\\
\url{http://www.linux-france.org/article/sys/ext3fs/Benchmarks/} \\
\url{http://fsbench.netnation.com/} \\
~\\
\section{Packages}
Au fil des années, les distributions Linux se sont vu dotées de systèmes de packaging multiples, et sont devenus des moyens très utilisés permettant d'installer des logiciels plus rapidement et plus facilement qu'avec une compilation classique :
\begin{itemize}
\item le RPM initialement développé par Redhat
\item les packages Slackware
\item les packages Debian (.deb)
\end{itemize}
Pour plus d'informations sur les RPMs, vous pouvez consulter \url{http://www.rpm.org/} et \url{http://www.lilit.be/formations/systeme_fichier/node5.html}.
\section{Configuration réseau}
Au niveau des cartes réseau, il est désormais assez rare de rencontrer des problèmes de pilotes. Une fois les cartes réseau correctement détectées, on procédera à la configuration du réseau. Si un serveur DHCP est présent sur le réseau, la configuration est automatique. On préférera néanmoins une configuration statique pour des raisons de sécurité. Plus généralement la configuration réseau se définit souvent dans un fichier spécifique selon les distributions. Voici un exemple d'un fichier \texttt{/etc/network/interfaces} pour Debian : \\
~\\
\texttt{auto eth0\\
iface eth0 inet dhcp\\
~\\
auto eth1\\
iface eth1 inet static\\
address 192.168.12.67\\
netmask 255.255.255.0\\
gateway 192.168.12.254}
~\\
En ce qui concerne la configuration DNS, c'est dans le fichier \texttt{/etc/resolv.conf} qu'on trouvera les adresses des serveurs de nom. On utilisera les outils \texttt{host} et \texttt{dig} pour s'assurer du bon fonctionnement. Voici un exemple de fichier~: \\
~\\
\texttt{search domain.tld \\
nameserver 192.168.12.71 \\
nameserver 62.4.17.69} \\
~\\
Les détails de la configuration réseau et DNS ne sont pas abordés ici, on se référera à de nombreuses documentations disponibles sur Internet ou dans les bonnes bibliothèques. Passons tout de même en revue quelques outils indipensables à tout administrateur réseau~: \\
~\\
\emph{ifconfig} permet de configurer les interfaces réseau\\
Exemple : \texttt{ifconfig eth0 192.168.13.47}\\
\texttt{ifconfig eth0:0 1.2.3.4 netmask 255.255.0.0}\\
~\\
\emph{route} gestion de la table de routage\\
Exemple : \texttt{route add -net 192.168.100.10/24 gw 192.168.100.1}\\
~\\
\emph{ip} gestion avancée de la configuration réseau (routage, périphériques, etc.) \\
Exemple : \texttt{ip addr add 10.0.0.1/24 dev eth0 label eth01} \\
~\\
\emph{netstat} informations avancées sur l'état réseau \\
Exemple : \texttt{netstat -a -t} \\
~\\
\emph{traceroute} pour tester la route vers un hôte du réseau\\
Exemple : \texttt{traceroute -v google.fr} \\
~\\
\textit{\textit{Lien :}} \url{http://perso-info.enst-bretagne.fr/~leroy/Unix/Guide/LinuxReseau.html}\\
\section{Réglages de base}
Revenons sur quelques réglages de base~: \\
~\\
\emph{Boot loader} \\
~\\
Selon les distributions, le boot loader sera LILO ou Grub. Grub est plus flexible que LILO mais chacun possède des fonctionnalités différentes qui peuvent s'avérer utiles dans certains cas particuliers. Notons que sur un serveur en production, le choix du Boot loader n'est pas essentiel.\\
~\\
\emph{Réglage des locales} \\
~\\
Les locales sont l'environnement de localisation du système. Cet environnement est utilisé par les programmes pour reconnaître la langue et le jeu de caractères que votre système utilise. On peut choisir ses locales grâce au paquet locales. Actuellement, un choix s'offre entre le codage en ISO ou en UTF-8 (Unicode sur 8 bits). \\
Bien que de plus en plus d'applications soient compatibles avec le codage unicode, les utilisateurs hésitent souvent à basculer en UTF-8. Pour un serveur, l'importance des locales est assez limitée. Si l'on pourrait rester en ISO-8859-1 ou ISO-8859-15 (extension du codage européen avec le support de l'euro), il n'est désormais plus imprudent d'utiliser de l'UTF-8. \\
En ce qui concerne le choix de la langue, il peut être judicieux d'utiliser une locale de langue anglaise pour obtenir des messages d'erreur en anglais, ce qui facilite les recherches Internet par exemple. Ainsi, l'utilisation la plus raisonnable semble la locale en\_us.UTF-8 et l'ajout des locales françaises (fr\_FR et fr\_FR.UTF-8) est conseillée (pour PHP ou PostgreSQL par exemple). \\
~\\
\emph{Réglage du clavier} \\
~\\
On pourra utiliser différents claviers. On chargera la table de traduction en utilisant la commande loadkeys. Les tables disponibles sont contenues dans le répertoire /usr/share/keymaps\\
~\\
Exemples pour passer en azerty ou en qwerty sur certaines distributions~: \\
\texttt{\# loadkeys fr-latin0}\\
\texttt{\# loadkeys us-latin1}\\
~\\
Le programme kbdconfig peut aussi proposer une interface pour choisir son type de clavier. \\
~\\
\emph{Système de messagerie}\\
~\\
Par défaut, un système du type Unix a besoin d'un système de messagerie, ne serait-ce que pour envoyer des alertes système à l'administrateur local. Si l'on n'a pas besoin de serveur de messagerie, on laissera donc un système de mail avec une configuration locale uniquement. \\
~\\
\emph{Mise à l'heure}\\
~\\
Il est souvent essentiel pour un serveur d'être à l'heure. Pour cela le protocole NTP (Network Time Protocol)\footnote{\url{ftp://ftp.rfc-editor.org/in-notes/rfc2030.txt}} permet de se synchroniser sur un serveur de temps. Si l'on possède plusieurs serveurs, il est intéressant d'avoir un serveur NTP\footnote{\url{http://www.ntp.org/}} sur lequel les autres machines locales vont se synchroniser. La synchronisation du serveur de temps ou du serveur isolé se fera sur plusieurs serveurs de temps officiels (certains sont en libre accès comme \texttt{ntp.tuxfamily.net} ou \texttt{swisstime.ee.ethz.ch}, sinon il faut demander un accès en envoyant un courrier électronique) \\
~\\
Concrètement, on installe le paquet \textit{ntpdate} et on peut lancer une synchronisation dans un cron avec la commande suivante: \\
\begin{verbatim}
ntpdate ntp.evolix.net > /dev/null 2>&1 || echo \
"pas de mise a l'heure `date`" | /usr/bin/mail -s \
"[alert] ntpdate sur serveur.domain.tld `date`" admin@example.com
\end{verbatim}
\textit{Lien :} \url{http://www.cru.fr/NTP/serveurs\_francais.html} \\
\section{Présentation des principales distributions}
\subsection{Red Hat}
\url{http://www.redhat.com/}\\
\url{http://www.europe.redhat.com/documentation/rhl9/rhl-ig-x86-fr-9/}\\
\url{http://www.com.univ-mrs.fr/ssc/info/linux/install_linux.html}\\
~\\
Red Hat est la plus importante société avec une activité dédiée aux logiciels Open Source.
Fondée en 1993, cette société basée aux États-Unis propose le déploiement d'infrastructures réseau en se basant sur sa distribution : Red Hat Linux. Entrée en bourse en 1999, Red Hat a changé de stratégie en 2003 en se consacrant uniquement au monde professionnel : Red Hat propose désormais une gamme de distributions payantes (Red Hat Entreprise) et se contente de sponsoriser un dérivé de Red Hat : le projet Fedora. La société compte aujourd'hui plus de 700 salariés répartis dans plus de 20 pays.\\
Les versions :
\begin{itemize}
\item Redhat version 9, plus supportée, plus mise à jour
\item Redhat Entreprise Advanced Server
\item Redhat Entreprise Server
\item Redhat Entreprise Linux WorkStation
\end{itemize}
Depuis quelques mois, Redhat ne fournit plus directement de versions gratuites. Cette tâche incombe désormais à un groupe de développeurs annexes qui maintient la distribution Fedora. Fedora est une version gratuite de Redhat, qui permet également aux développeurs Redhat de "tester" certaines évolutions à grande échelle avant que celles-ci soient intégrées.\\
L'installation de logiciels peut être réalisée de plusieurs façons~:
\begin{itemize}
\item via les sources, en les compilant
\item via un RPM
\item via \textit{yum}, un système qui ressemble fortement à apt pour les utilisateurs de Debian
\end{itemize}
Les mises à jour sont assurées sur Fedora par \textit{yum}, ainsi que part \textit{uptodate} comme c'est le cas sur Redhat (utilisation texte ou graphique).\\
La sécurité pour la distribution Redhat est gérée via la page \url{https://www.redhat.com/security/updates/}, où toutes les mises à jour sont disponibles. Des RPMs sont disponibles.
~\\
\subsection{Mandriva}
\url{http://www.mandrakelinux.com/}\\
\url{http://www.mandrivalinux.com/fr/fdoc.php3}\\
\url{http://www.mandrivalinux.com/fr/ftp.php3}\\
\url{http://fr.wikipedia.org/wiki/Mandriva_Linux}\\
~\\
Mandriva est le produit d'une entreprise française, MandrakeSoft, créée en 1998. Grâce à une croissance rapide et de nombreux soutiens, la société MandrakeSoft compte plus de 120 salariés et est cotée en bourse. Elle impose sa distribution comme l'une des plus répandues dans le monde. Accessible dans plus de 50 langues, Mandriva est une distribution conviviale et accessible aux débutants. Initialement appelée Mandrake, elle fût rebaptisée Mandriva en 2005 (suite à des problèmes judiciaires concernant le nom et au mariage de MandrakeSoft avec Conectiva, une distribution Linux venant d'Amérique Latine).\\
Les versions actuelles~:
Il existe de très nombreuses versions et
Quelques principes : \\
Les versions "Free" ne contiennent que des logiciels libres, et sont téléchargeables gratuitement.\\
Les versions "Entreprise" sont, bien qu'Open Source, payantes et bénéficient d'un support spécial par Mandriva. La plupart permettent une inter-opérabilité entre les plates-formes Linux, Windows et Mac.\\
Quelques exemples :\\
\begin{itemize}
\item Mandriva Free : C'est tout un système complet livré avec tous les programmes qui peut être téléchargé gratuitement et librement distribuable, et gravé sur un DVD-ROM ou sur 3 CD-ROM.
\item Mandriva Powerpack : La version en boîte (Powerpack) est payante et fournie avec des manuels imprimés, pour aider les utilisateurs à découvrir le système. Elle inclut également le droit à des services, comme de l'assistance technique.
\item Mandriva One : version "Live CD" utilisable sans rien installer
\item Mandriva Flash : version portable autobootable vendue sur une clé USB
\item Multi Network Firewall (MNF) : version spéciale pour les machines de type routeur/firewall
\end{itemize}
Pour les problèmes de sécurité, Mandriva regroupe les informations sur \url{http://www.mandriva.com/security/}, et les utilisateurs bénéficient d'une grande réactivité. Ainsi, une liste de diffusion et un flux RSS sont disponibles pour se tenir informé.
\subsection{Gentoo}
\url{http://www.gentoo.org/}\\
\url{http://www.gentoo.org/doc/fr/handbook/index.xml}\\
\url{http://www.gentoo.org/doc/fr/gentoo-x86-quickinstall.xml}\\
~\\
Gentoo est une distribution "orientée source". A l'image des systèmes BSD dont elle dérive, l'utilisateur compile son système et ses logiciels. Cependant, il existe également des paquetages binaires disponibles, afin d'éviter cette phase de compilation.\\
Gentoo a été originairement conçu pour fonctionner sur architecture x86 uniquement. Mais, elle a été portée sur de nombreuses autres architectures en raison de sa haute portabilité. L'installation se fait à partir d'un CD Live et une documentation d'installation et d'utilisation très complète est disponible. Notez qu'il existe un outil appelé Catalyst permettant de faire ses propres distributions basées sur Gentoo.\\
La distribution est très orientée compilation avec un système de "flags" interne, qui permettent d'utiliser certaines caractéristiques majeures, comme X (le serveur graphique), une version précise du compilateur, ou encore le support de tel ou tel protocole dans tous les logiciels installés. La compilation est omniprésente et des outils comme DistCC sont très utilisés afin d'en réduire les coûts. Cette distribution est basée sur le langage Python, utilisé dans la plupart des scripts inhérents à la distribution (démarrage, installation du réseau etc.)\\
Vous pouvez prendre connaissance des failles de sécurité et des éventuels problèmes apparaissant sur la distribution depuis \url{http://www.gentoo.org/security/en/index.xml}. La distribution est également axée sur la sécurité avec un certain nombre de mécanismes intégrés par défaut, et des ouvrages relatifs à la sécurité qui ont été réalisés par l'équipe (Gentoo Security Handbook). Les utilisateurs peuvent également prendre compte des changements oeuvrés par mail (gentoo-announce@gentoo.org).
\subsection{Slackware}
\url{http://www.slackware.org/}\\
\url{http://www.trustonme.net/didactels/91.html}\\
~\\
Cette distribution historique et simple a été créée, et est toujours maintenue par Patrick Volkerding (depuis 1993). Elle ne repose que sur peu d'outils de configuration automatisés, les outils traditionnels étant privilégiés. Les deux objectifs principaux sont la simplicité d'utilisation et la rapidité.
Le système de packages est géré grâce aux \textit{slacktools}, remplaçants des \textit{pkgtools} de Slackware. Ils ont pu bénéficier constamment d'améliorations, comme la gestion des dépendances etc. Le système de packaging RPM peut également être utilisé facilement afin d'utiliser des packages plus généralistes.\\
Contrairement à des distributions comme Debian, la compilation du noyau se fait de manière traditionnelle. Rappel~:
\begin{verbatim}
# make menuconfig
# make dep
# make bzImage
# make modules
# make modules_install
\end{verbatim}
Cependant, même si la distribution est relativement à jour, les personnes qui y contribuent sont peu nombreuses, et certaines améliorations peuvent mettre du temps à être incorporées. Le projet Slackware a pour but de rester le plus Unix-like possible.\\
En cas de problème de sécurité, une liste de diffusion dédiée est accessible sur \url{http://www.slackware.org/security/}. Les mises à jour sont faites sous forme de packages à installer.
\subsection{Suse}
\url{http://www.novell.com/linux/suse/}\\
\url{http://www.novell.com/documentation/suse93/pdfdoc/user93-screen/user93-screen.pdf}\\
Suse est une société allemande qui appartient désormais au groupe Novell. La distribution du même nom est basée sur Slackware et le système de paquets RPM de Redhat. La configuration peut être facilement réalisée par le Centre de Control YAST, qui est passé, depuis plus d'un an sous licence GPL.
Vu l'orientation de Novell sur le monde des réseaux, le rachat de Suse a marqué l'intégration de nombreux protocoles réseau etc.\\
Novell propose actuellement plusieurs versions~:
\begin{itemize}
\item SUSE LINUX Professional : version professionnelle principalement mise en avant par Novell
\item Novell Linux Desktop : version orientée poste de travail
\item SUSE LINUX Enterprise Server : version spéciale pour les entreprises (certifiée par exemple pour les machines IBM Xseries ou le logiciel Oracle)
\end{itemize}
Novell propose également de nombreux produits ou services basés sur Linux. On notera des sortes de packages comprenant une distribution Linux et des services~:
\begin{itemize}
\item Novell Linux Small Business Suite : basée sur Novell Linux Desktop
\item Novell Open Enterprise Server : basée sur SUSE LINUX Enterprise Server
\end{itemize}
~\\
~\\
Pour les problèmes de sécurité, Suse dispose d'un service en ligne \\
(à l'adresse \url {http://www.novell.com/linux/security/securitysupport.html}). ~\\
Une liste des failles ayant affecté Suse est disponible à la même adresse de façon textuelle, ou en flux RSS à l'adresse (\url{http://www.novell.com/linux/security/suse\_security.xml}).
\subsection{Debian}
Le projet Debian a été lancé en août 1993 par Ian Murdock. Debian est alors une nouvelle distribution produite de façon ouverte, dans l'esprit de Linux et de GNU. Debian a la réputation d'être soigneusement et consciencieusement mise en place, maintenue et supportée. Cela a commencé par la constitution d'un petit groupe très soudé de hackers (codeurs) de logiciels libres. Graduellement, le groupe s'est agrandi pour devenir une vaste communauté de développeurs et d'utilisateurs bien organisée\footnote{\url{http://www.debian.org/intro/organization}}. Le projet Debian est basé sur un contrat social\footnote{\url{http://www.debian.org/social\_contract.fr.html}}, des directives définissant les logiciels libres, DFSG - Debian Free Software Guidelines\footnote{\url{http://www.debian.org/social\_contract\#guidelines}} et une constitution\footnote{\url{http://www.debian.org/devel/constitution}} définissant l'organisation du projet.
Organisés de façon démocratique, le leader, le comité technique et le secrétaire ainsi que chaque contributeur Debian possèdent un rôle bien défini (responsable de paquets, de projets, etc.). Ainsi Debian n'est pas soumis à des exigences commerciales et se permet d'avoir un avenir serein. Aujourd'hui, on compte près d'un millier de développeurs Debian répartis dans le monde entier\footnote{\url{http://www.debian.org/devel/developers.loc}}, des dizaines de milliers de paquets\footnote{\url{http://www.debian.org/distrib/packages}}, le support de plusieurs
architectures\footnote{\url{http://www.debian.org/ports/}} ainsi que des versions utilisant un noyau différent de Linux (GNU/Hurd ou FreeBSD).
\textit{Lien~:} \url{http://www.debian.org/doc/manuals/project-history/} \\
Les versions~:\\
Debian propose trois ou quatre versions de distributions aux utilisateurs. \\
La distribution "stable" contient la dernière distribution officiellement sortie de Debian. Il s'agit de la dernière production de Debian qu'il est recommandé d'utiliser.\\
La distribution "testing" contient des paquets en attente d'entrée dans la distribution "stable". Elle contient donc des versions assez récentes des logiciels mais moins bien surveillés par les développeurs Debian.\\
En pratique, la distribution "testing" passe par une période de gel (freeze) où son évolution est figée et seules les corrections de bogues ou mises-à-jours mineures sont acceptées (on parle parfois de distribution "frozen"). Après de minutieuses vérifications, la version "testing gelée" peut remplacer la version stable. \\
\\
La troisième distribution est appelée "unstable". C'est celle sur laquelle se concentre les activités de développement. Elle est utilisée par "les développeurs et par ceux qui aiment vivre sur le fil" car c'est une sorte de laboratoire destiné à tester et corriger les bogues des paquets. Son nom Sid (nom de l'enfant qui casse les jouets dans \textit{Toys Story}) signifie officieusement : Still In Development.\\
\\
Les nouveaux paquets des développeurs arrivent en effet directement en unstable après inspection et validation des ftpmasters (les personnes responsables des mises en ligne sur le serveur FTP principal). Chaque mise en ligne est répercutée sur les miroirs en moins de 24h (on peut retouver les nouveaux paquets des développeurs directement dans le répertoire Incoming\footnote{\url{http://incoming.debian.org/}}. Les paquets de la version "unstable" remplissant certains critères (absence de bogues critiques, durée supérieure à 10 jours dans "unstable", support de toutes les architectures et dépendances toutes satisfaites) basculent dans la distribution "testing".\\
\\
Dernière distribution plus particulière, il s'agit de la version "experimental" : il s'agit d'une archive mise à la disposition par des développeurs pour avoir des retours d'utilisateurs expérimentés sur des modifications importantes des logiciels (la version "experimental" n'est pas une distribution complète). Cette étape est indépendante du processus de validation des paquets Debian.
On se rend donc compte des précautions qui entourent le statut des paquets Debian. En contrepartie, ce processus prend du temps et les versions de paquets de la distribution "stable" ont souvent du retard par rapport aux dernières versions des logiciels.
Voici le tableau des noms de distribution Debian (tirés du Film Toy Story)~:
\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
- & 0.01->1.1 & août 1993->juin 1996 & - \\
\hline
Buzz & 1.1 & juin 1996 & Le ranger de l'espace \\
\hline
Rex & 1.2 & décembre 1996 & le tyrannosaure \\
\hline
Bo & 1.3 & juillet 1997 & La bergère \\
\hline
Hamm & 2.0 & juillet 1998 & Le cochon-tirelire \\
\hline
Slink & 2.1 & mars 1999 & Le chien à ressort \\
\hline
Potato & 2.2 & août 2000 & Monsieur Patate \\
\hline
Woody & 3.0 & mai 2002 & Le cow-boy \\
\hline
Sarge & 3.1 & juin 2005 & Le chef des soldats \\
\hline
Etch & 4.0 & avril 2007 & L'écran magique \\
\hline
Lenny & 5.0 & mars 2009 & La paire de jumelles \\
\hline
Squeeze & 6.0 & ? & L'extraterrestre à trois yeux\\
\hline
Sid & - & toujours unstable & L'enfant qui casse les jouets \\
\hline
\end{tabular}
\end{center}
% http://kernel-handbook.alioth.debian.org/

288
support/mysql.tex Normal file
View file

@ -0,0 +1,288 @@
% Copyright (c) 2004-2010 Evolix <info@evolix.fr>
% Permission is granted to copy, distribute and/or modify this document
% under the terms of the GNU Free Documentation License, Version 1.2
% or any later version published by the Free Software Foundation;
% with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
% A copy of the license is included at http://www.gcolpart.com/howto/fdl.html
\chapter{MySQL}
~\\
Lien~: \url{http://www.mysql.com/}
~\\
\section{Présentation}
~\\
MySQL est un serveur de base de données relationnelles SQL (Structured Query Language) multi-thread et multi-utilisateur. MySQL est soumis à la licence GPL ( GNU General Public License) ou à une licence commerciale distribuée par l'entreprise Mysql AB (fondée par les développeurs de MySQL).\\
~\\
\section{Installation}
\subsection{À partir des sources}
~\\
Il est bien sûr possible de compiler MySQL à partir des sources. Cela permet de compiler uniquement avec les options que l'on a besoin et d'obtenir des binaires pour sa machine. On rappelle la procédure~:\\
~\\
\texttt{
./configure [options]\\
make\\
make install\\
}
~\\
\subsection{Par paquet}
~\\
Dans la plupart des cas, on utilisera des paquets pour installer MySQL.\\
\emph{Paquets principaux~:}\\
~\\
\textbf{mysql-common~:} fichiers communs pour MySQL\\
\textbf{php5-mysql~:} module MySQL pour PHP\\
~\\
\emph{Dépendances directes~:}\\
~\\
libc6 : librairies "GNU C"\\
libmysqlclient10 : librairie client mysql\\
zlib1g : librairies de compression gzip\\
php4-common : fichiers courants pour php4\\
\section{Administration}
On note bien que les utilisateurs MySQL n'ont rien à voir avec des utilisateurs UNIX.
~\\
La première fois, en root, taper~:\\
~\\
\texttt{\# mysql}\\
~\\
On obtient alors un message ressemblant à~:
\begin{verbatim}
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 133 to server version: 3.23.49-log
Type 'help;' or '\h' for help. Type '\c' to clear the buffer.
mysql>
\end{verbatim}
~\\
Vous êtes donc connecté à votre serveur MySQL.\\
Déconnectez vous rapidement~:\\
~\\
\begin{verbatim}
mysql> quit
Bye
\end{verbatim}
~\\
On retrouve la main en ligne de commande.\\
Il faut ABSOLUMENT mettre un mot de passe à root (ou bien lui supprimer les droits, voir ci-après)~:\\
\texttt{\# mysqladmin password "motdepasse"}\\
~\\
On peut maintenant se connecter a la base mysql en root sous~:
\begin{verbatim}
#mysql -p
Enter password:*****
mysql>
\end{verbatim}
Il est conseillé de créer un utilisateur MySQL nommé adminmysql avec
tous les droits pour éviter d'utiliser root.\\
La gestion des permissions des utilisateurs (en fonction de l'hôte de
connexion) se trouve donc dans la table "user" de la base mysql.
\begin{verbatim}
| Host | char(60) binary
| User | char(16) binary
| Password | char(16) binary
| Select_priv | enum('N','Y')
| Insert_priv | enum('N','Y')
| Update_priv | enum('N','Y')
| Delete_priv | enum('N','Y')
| Create_priv | enum('N','Y')
| Drop_priv | enum('N','Y')
| Reload_priv | enum('N','Y')
| Shutdown_priv | enum('N','Y')
| Process_priv | enum('N','Y')
| File_priv | enum('N','Y')
| Grant_priv | enum('N','Y')
| References_priv | enum('N','Y')
| Index_priv | enum('N','Y')
| Alter_priv | enum('N','Y')
\end{verbatim}
La gestion des droits des utilisateurs sur des bases de données est
opérée dans la table db~:
\begin{verbatim}
| Host | char(60) binary
| Db | char(64) binary
| User | char(16) binary
| Select_priv | enum('N','Y')
| Insert_priv | enum('N','Y')
| Update_priv | enum('N','Y')
| Delete_priv | enum('N','Y')
| Create_priv | enum('N','Y')
| Drop_priv | enum('N','Y')
| Grant_priv | enum('N','Y')
| References_priv | enum('N','Y')
| Index_priv | enum('N','Y')
| Alter_priv | enum('N','Y')
\end{verbatim}
D'autres tables (host, tables\_priv, columns\_priv) permettent d'ajuster plus finement les droits...\\
~\\
Donc pour créer un utilisateur \texttt{adminmysql} qui a tous les
droits, on se connecte avec un utilisateur qui a les droits nécessaires
~:\\
\begin{verbatim}
mysql> use mysql
mysql> GRANT ALL PRIVILEGES ON *.* TO adminmysql@localhost
-> IDENTIFIED BY 'mot2passe' WITH GRANT OPTION;}
\end{verbatim}
~\\
On vérifie~:
\begin{verbatim}
mysql> select * from user where User='adminmysql';}\\
\end{verbatim}
~\\
On pourrait même insérer des utilisateurs "manuellement"~:
\begin{verbatim}
INSERT INTO user VALUES ('localhost','login',password('motdepasse'),
'N','N','N','N','N','N','N','N','N','N','N','N','N','N');
\end{verbatim}
~\\
Lors d'interventions sur ces tables de gestion des droits MySQL, on pensera à lancer la commande~:
\begin{verbatim}
mysql> FLUSH PRIVILEGES;
\end{verbatim}
Ou encore effacer des utilisateurs~:
\begin{verbatim}
mysql> delete from user where Host='vilain';}
\end{verbatim}
~\\
On effacera les entrées que l'on ne désire pas dans cette table en fonction de sa politique de sécurité. On notera sous Debian la présence d'un utilisateur \texttt{debian-sys-maint} qui sert à certains scripts Debian~: il ne doit pas être supprimé~! Au niveau sécurité, le mot de passe est généré à l'installation (stocké dans \texttt{/etc/mysql/debian.cnf}) par la commande~:
\begin{verbatim}
perl -e 'print map{("a".."z","A".."Z",0..9)[int(rand(62))]}(1..16)'
\end{verbatim}
~\\
Notons qu'il est bien sûr primordial d'interdire la lecture du fichier
\texttt{/etc/mysql/debian.cnf} Bref, pour administrer notre base MySQL,
on peut désormais éviter de se connecter en root et faire:\\
~\\
\begin{verbatim}
# mysql -u adminmysql -p
Enter password:*****
mysql>
\end{verbatim}
~\\
Souvent la principale action à faire par un administreur MySQL est de créer une base de données et un utilisateur ayant tous les droits dessus. Ceci est assez courant pour faire une page en PHP/Mysql ou intégrer un logiciel "tout fait" (forum, chat, etc.)\\
Pour faire cela, nous allons donc faire en tant qu'adminmysql~:\\
~\\
\begin{verbatim}
mysql> create database forum;
mysql> grant all privileges on forum.* to moderateur@localhost
mysql> identified by 'mot_de_passe_du_moderateur';
\end{verbatim}
~\\
Pour créer un utilisateur en lecture seule sur une base donnée~:
\begin{verbatim}
mysql> INSERT INTO user (Host,User,Password) VALUES('localhost','readprod',PASSWORD('xxx'))
mysql> insert into db (Host,Db,User,Select_priv) values ('localhost','production','readprod','Y')
\end{verbatim}
\section{Sauvegarde}
~\\
Il existe diverses méthodes de sauvegarde. On peut par exemple sauvegarder le répertoire contenant les bases : /var/lib/mysql par défaut sous Debian. Il existe également plusieurs outils dont le plus utilisé est le programme \texttt{mysqldump}\footnote{\url{http://www.nexen.net/docs/mysql/annotee/mysqldump.php}}\\
~\\
Sauvegarde d'une base :\\
\begin{verbatim}
$ mysqldump --opt BASE -u mysqladmin -p > database.sql
$ mysql -u mysqladmin -p BASE < database.sql
\end{verbatim}
Sauvegarde générale~:\\
\begin{verbatim}
$ mysqldump --opt --all-databases -u mysqladmin -p > all_databases.sql
$ mysql -u mysqladmin -p < all\_databases.sql
\end{verbatim}
\textit{Lien~:}
\url{http://www.nexen.net/docs/mysql/annotee/backup.php}\\
~\\
\section{Base de programmation}
~\\
Voici quelques commandes SQL de base~:
~\\
\begin{verbatim}
mysql> use essai ;
\end{verbatim}
-> utiliser la base de données essai
\begin{verbatim}
mysql> create table test (nom type [options],..);
\end{verbatim}
-> créer une table nommé test\\
~\\
\textbf{Exemple : }
\begin{verbatim}
CREATE TABLE clients_tbl (id INT not null AUTO_INCREMENT, prenom VARCHAR
(50) not null , nom VARCHAR (50) not null , ne_le DATE not null ,
ville VARCHAR (90) not null , enfants INT not null , PRIMARY KEY (id))
\end{verbatim}
\begin{verbatim}
mysql> alter table test add nom type [-options];
\end{verbatim}
-> ajouter un champ à une table
\begin{verbatim}
mysql> alter table test drop nom;
\end{verbatim}
-> effacer un champ à une table
\begin{verbatim}
mysql> desc test;
\end{verbatim}
-> décrire la table test
\begin{verbatim}
mysql> insert into test values ('a','b',...);
\end{verbatim}
-> remplir la base de donnée
\begin{verbatim}
mysql> select * from test;
\end{verbatim}
-> sortir tous les champs de la table test
\begin{verbatim}
mysql> delete from teste where (condition)
\end{verbatim}
-> effacer des données
\begin{verbatim}
mysql> delete from test;
\end{verbatim}
-> effacer toutes les données de test
\begin{verbatim}
mysql> drop table test ;
\end{verbatim}
-> effacer la table test
~\\
\textit{Liens~:}\\
\url{http://nexen.net/docs/mysql/}\\
\url{http://www.mysql.com/}\\
~\\
\section{Autres SGBD libres}
~\\
Il existe PostGreSQL\footnote{\url{http://www.postgresql.org/}}, moins
répandu que MySQL sur le web, mais qui propose certaines fonctionnalités
plus avancées (on le cite parfois en tant qu'alternative à
Oracle\footnote{\url{http://www.oracle.com/}}).
SQLite\footnote{\url{http://www.sqlite.org/}} est un autre système de
gestion de base données libre. SQLite est très léger et stocke ses bases
dans des fichiers binaires, il est intéressant (plus rapide, moins
lourd que les autres SGBD, etc.) pour des applications n'opérant que de
simples requêtes (select, insert etc.).
\newpage

92
support/nfs.tex Normal file
View file

@ -0,0 +1,92 @@
% Copyright (c) 2004-2010 Evolix <info@evolix.fr>
% Permission is granted to copy, distribute and/or modify this document
% under the terms of the GNU Free Documentation License, Version 1.2
% or any later version published by the Free Software Foundation;
% with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
% A copy of the license is included at http://www.gcolpart.com/howto/fdl.html
\section{NFS}
\subsection{Présentation}
NFS signifie \textit{Network File System}. Ce protocole permet de partager des systèmes de fichiers en réseau, rendant ainsi leurs utilisations transparentes, comme si ceux-ci étaient présent localement.\\
La procédure est la suivante~:
\subsection{Mise en place}
\begin{itemize}
\item La machine hôte du système de fichiers doit dreeser des autorisations selon un certain nombre de critères (adresses ip de la machine cible, droits etc.); ceci est réalisé via le fichier "exports".\\
\item La machine cible monte le dit système de fichiers afin de pouvoir le lire / écrire, en indiquant ou celui-ci se trouve (hôte source) et quel est le point de montage
\end{itemize}
\subsection{Caractéristiques techniques}
Le protocole NFS est basé sur la communication RPC (Remore Procedure Call). Un système NFS se compose de plusieurs éléments~:
\begin{itemize}
\item le serveur nfsd qui va permettre de recevoir les requêtes RCP des clients et les gérer
\item le démon mountd qui met à disposition les système de fichiers et gère les points de montage
\item le client nfs qui va faire une demande d'accès au système de fichier
\item éventuellement, un démon rwhod gérant les résultats collectés par who
\item le démon "portmapper" qui fait la conversion entre le numéro de port utilisé par RPC et le numéro de port utilisé par DARPA
\end{itemize}
~\\
Le système NFS utilise un certains nombres de ports, voici les principaux~:
\begin{itemize}
\item portmap : \textit{111/tcp, 111/udp}
\item nfs : \textit{2049/tcp, 2049/udp}
\item mountd : \textit{872/udp, 872/tcp, 875/udp, 875/tcp}
\end{itemize}
~\\
Les paquets réseau utilisés par NFS peuvent dans certains cas être quelque peu spéciaux. Par exemple, les serveurs NFS ont tendance à envoyer des paquets avec le bit DF (Don't Fragment) à 1, et ce même pour des paquets en réalités fragmentés; ceux-ci sont en général supprimés par le premier firewall intermédiaire rencontré.
\subsection{Exemple de mise en place}
Tout d'abord, nous devons ajouter sur la machine serveur un enregistrement du système de fichiers qui va être mis à disposition. On ajoutera par exemple dans /etc/exports :
\begin{verbatim}
/home/debian -alldirs -network 192.168.1.0 -mask 255.255.255.0
\end{verbatim}
D'autres options sont également très utilisées, comme "root-squash" qui permet de différencier le root de la cible et le root de la source, ou RW / RO qui permettent de spécifier les droits à utiliser sur les systèmes de fichiers partagés par NFS.\\
Lancer à présent les services suivants : portmap - nfsd - mountd.\\
Pour la partie client, il faut à présent indiquer à notre hôte ce que l'on veut monter, en l'occurrence notre système de fichiers /home/debian. Pour cela, ajoutons au fichier /etc/fstab une ligne semblable à :
\begin{verbatim}
serveur_nfs:/home/debian /home/debian_client nfs rw 0 0
\end{verbatim}
Il est à noter que le serveur apparaissant sous le nom "serveur\_nfs" doit posséder un enregistrement DNS; vous pouvez celà-dit également spécifier l'IP, à votre convenance.\\
Celà-dit, même si la version 4 de NFS est jugée plus sure, ce type de services peut s'avérer dangereux, pour le serveur comme pour le client. Il peut donc être judicieux de mettre en place un système de restrictions basé sur TCP Wrappers. Par exemple~:\\
Dans le fichier /etc/hosts.deny, on refuse tout par défaut~:
\begin{verbatim}
portmap:ALL
lockd:ALL
mountd:ALL
rquotad:ALL
statd:ALL
\end{verbatim}
Ceci signifie que l'on refuse par défaut (un peu à la manière d'un firewall) tout ce qui touche au RPC et à NFS. Puis, on dresse une liste d'autorisation, dans le fichier /etc/hosts.allow~:
\begin{verbatim}
portmap:192.168.1.1
lockd:192.168.1.1
mountd:192.168.1.1
rquotad:192.168.1.1
statd:192.168.1.1
\end{verbatim}
Enfin, afin de vous assurez du bon fonctionnement de votre système NFS,
vous pouvez utiliser la commande 'rpcinfo' afin de détecter
d'éventuelles anomalies au niveau du fonctionnement RPC. Le montage des
volumes NFS peut être réalisé de façon automatique par des démons comme
\textit{amd} et \textit{autofs}.

113
support/noyau.tex Normal file
View file

@ -0,0 +1,113 @@
% Copyright (c) 2004-2010 Evolix <info@evolix.fr>
% Permission is granted to copy, distribute and/or modify this document
% under the terms of the GNU Free Documentation License, Version 1.2
% or any later version published by the Free Software Foundation;
% with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
% A copy of the license is included at http://www.gcolpart.com/howto/fdl.html
\section{Le noyau Linux}
\subsection{Présentation}
~\\
Andrew Tanenbaum, professeur, développa en 1985 Minix, un système d'exploitation minimal inspiré du système UNIX Time-Sharing System version 7. Destiné à enseigner le concept des systèmes d'exploitations, Minix fut la source d'inspiration de Linus Torvalds, un étudiant finlandais, qui développa un nouveau système d'exploitation baptisé Linux. Complètement ré-écrit (principalement en langage C), Linux fut tout d'abord développé pour les ordinateurs de type i386. Linus Torvalds choisit la licence GPL pour son développement et rapidement, grâce à Internet, il reçut l'aide de plusieurs informaticiens. L'explosion des réseaux et d'Internet a largement favorisé le développement collaboratif de Linux, au point que certains le considèrent comme le premier produit d'Internet. Linux est généralement compilé avec GCC et plus accompagné d'outils provenant du projet GNU afin de fournir un système d'exploitation utilisable. C'est pourquoi on a tendance à qualifier ce système d'exploitation de "GNU/Linux" \footnote{\url{http://www.gnu.org/gnu/why-gnu-linux.fr.html}} \\
La première version de Linux sortit en 1991, la version 1.0 sortit en 1993 et la version 2.0 sortit en 1996. Aujourd'hui, Linux supporte plusieurs architectures (Alpha, MIPS, SPARC, PPC, ...) et compte plusieurs millions de lignes de code. On peut télécharger Linux sur le site \url{http://www.kernel.org}. Sa branche stable actuelle est la 2.6.x \\
~\\
x.y.z \\
~\\
x désigne la branche (numéro de version majeure), y complète le numéro de version et z est le numéro de release (c'est-à-dire le nombre de publications de cette version). Si y est pair, il s'agit d'une version stable, si y est impair il s'agit d'une version en cours de développement. \\
Depuis la version 2.6.11, la numérotation a un peu changé avec l'introduction d'un quatrième chiffre indiquant des changements mineurs de versions (quelques patches peu conséquents). \\
Des suffixes tels que preN ou rcN (prépatches), bkN (snapshots), acN (patches d'Alan Cox) ou mmN (patches d'Andrew Morton) indiquent des versions particulières du noyau. \\
On peut connaître la version actuelle grâce à la commande \texttt{uname} qui affiche des informations concernant la machine et le système d'exploitation sur lequel il est invoqué. \\
~\\
Exemple : \\
\texttt{
\$ uname -r \\
2.6.10-rc2laptop221104} \\
~\\
%Multi-utilisateurs \\
%Principes utilisateurs/groupes \\
%Processus \\
%noyau monolithique != micro noyau \\
%approche modulaire \\
%système de fichiers (définitions POSIX d'un fichier) \\
%droits d'accès \\
%mode User/mode Kernel \\
~\\
Liens:\\
\url{http://www.kernelnewbies.org/}\\
\url{http://www.bertolinux.com/}\\
\subsection{Compilation}
~\\
Sous Debian, le noyau compilé se trouve dans le répertoire /boot sous le nom vmlinuz-x.y.z
Les sources du noyau se trouvent dans le répertoire /usr/src/linux-x.y.z (ou kernel-source-x.y.z).
Historiquement on retrouve un lien /usr/src/linux pointant vers le répertoire des sources du noyau.
On trouve également les modules dans /lib/modules/x.y.z, les entêtes dans /usr/src et les tables de symboles\footnote{\url{http://www.dirac.org/linux/system.map/}} du noyau dans system.map-x.y.z (souvent dans le répertoire /boot )
~\\
~\\
Une fois l'installation de Linux terminée, on procédera éventuellement (surtout sur un serveur) à la compilation d'un noyau adapté aux besoins de la machine. On privilégiera un noyau débarrassé des modules inutiles~: toutes les options strictement nécessaires devront être compilées en dur (sauf exception).\\
On va donc récupérer les sources du noyau Linux. la procédure la plus classique est de prendre le noyau sur le site officiel \url{http://www.kernel.org/}. On prendra garde à bien vérifier l'intégrité des sources téléchargées~: \\
~\\
\begin{verbatim}
$ wget http://kernel.org/pub/linux/kernel/v2.6/linux-2.6.z.tar.bz2.sign
$ gpg --keyserver wwwkeys.pgp.net --recv-keys 0x517D0F0E
$ gpg --verify linux-2.6.z.tar.bz2.sign linux-2.6.z.tar.bz2
\end{verbatim}
~\\
La recompilation dite classique d'un noyau consiste à vérifier les dépendances (\texttt{dep}), nettoyer les sources (\texttt{clean}), compiler le noyau en lui-même (\texttt{bzImage}), puis les modules (\texttt{modules}) et les installer (\texttt{modules\_install}) :\\
~\\
\begin{itemize}
\item[\texttt{make dep}] vérifie les dépendances\\
\item[\texttt{make clean}] fait un peu le ménage\\
\item[\texttt{make bzImage}] compile le noyau\\
\item[\texttt{make modules}] compile les modules\\
\end{itemize}
~\\
\textit{makes modules\_install}
~\\
\textit{cp arch/i386/boot/bzImage /boot/vmlinuz-new}\\
Avec Debian, il existe les sources Debian du noyau Linux. Il s'agit des sources originales patchées par Debian. On téléchargera ces sources grâce à APT~: \\
~\\
\texttt{apt-cache search kernel-source*} \\
~\\
Lorsque l'on veut patcher les sources du noyau, il faudra éviter d'appliquer des patches incompatibles. C'est pourquoi il peut être préférable de patcher à partir des sources originales. Il existe de nombreux patches pour le noyau Linux. Pour un serveur, on s'intéressera au patches de sécurité grsecurity\footnote{\url{http://www.grsecurity.net/}} proposant un certain nombre de fonctionnalités. Voici la procédure pour l'installer~: \\
~\\
%http://www.cgsecurity.org/Articles/2-MISC/Protections-2/
~\\
\texttt{\$ tar -jxvf linux-2.6.z.tar.bz2}\\
\texttt{\$ patch -p0 < grsecurity-2.0-2.6.z.patch}\\
~\\
La phase la plus délicate est en réalité le choix des options du noyau. En effet, il faut lire attentivement les explications de chaque option pour déterminer si on doit l'activer pour notre machine. Pour lancer le choix des options du noyau, on fera:\\
~\\
\texttt{cd linux-2.6.z.tar.bz2}\\
\texttt{make menuconfig}\\
~\\
On pourra également utiliser \texttt{make config} mais son utilisation est moins aisée.
Le choix des options est stocké dans le fichier \texttt{.config}.
En cas de changement de sources (par exemple en cas de changement de version du noyau), on peut réutiliser ce fichier \texttt{.config} en ne choisissant que les nouvelles options. Pour cela on le transférera à la racine des nouvelles sources et on lancera la commande~:\\
~\\
\texttt{make oldconfig}\\
~\\
~\\
Debian propose des outils pour compiler simplement. La commande \texttt{make-kpkg} permet de construire des paquets Debian contenant un noyau compilé prêt à être installé. On procédera ainsi :\\
~\\
\texttt{
make-kpkg clean\\
make-kpkg kernel\_image kernel\_headers kernel\_source kernel\_doc\\
dpkg -i ../kernel-*-2.6.z.xxx.deb\\
}
~\\
Les options de \texttt{make-kpkg} permettent de spécifier un nom particulier pour le noyau (-~-append-to-version), de compiler avec initrd (-~-initrd), de compiler avec des modules (-~-added-modules), etc.
~\\
~\\

1202
support/openldap.tex Normal file
View file

@ -0,0 +1,1202 @@
% Copyright (c) 2004-2010 Evolix <info@evolix.fr>
% Permission is granted to copy, distribute and/or modify this document
% under the terms of the GNU Free Documentation License, Version 1.2
% or any later version published by the Free Software Foundation;
% with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
% A copy of the license is included at http://www.gcolpart.com/howto/fdl.html
\chapter{Les annuaires}
~\\
\section{Les services d'annuaire en général}
~\\
\subsection{Définitions}
\begin{itemize}
\item{\textbf{Annuaire}} :Définition (Larousse) : \textsc{Annuaire n.m. (lat. annuus, annuel). Ouvrage publié chaque année, donnant la liste des membres
d'une profession, des abonnés à un service, etc. Annuaire du téléphone.}\\
Exemples : Annuaire téléphonique (pages jaunes, pages blanches), Guide Michelin (guide rouge, etc.),
\item{\textbf{Annuaire électronique}}: Définition : \textsc{ Possibilité de mise-à-jour directement pour la consultation en ligne.}\\
Exemples : pagesjaunes.fr, DMOZ (Open Directory Project), Listes des utilisateurs sur un ordinateur (fichier /etc/passwd sous Unix)
\item{\textbf{Service d'annuaire}}: Définition : \textsc{ Service réseau, Architecture client/serveur}\\
Exemples : Annuaire des développeurs Debian, Annuaires dans les universités françaises,
\end{itemize}
~\\
Note : en anglais, annuaire se dit "directory".
%\subsection{Annuaires distribués}
%Dans les cas où l'on doit stocker une grande quantité d'informations, une base centralisée est non raisonable.
%TODO
%éviter la duplication des données
%Répartition en fonction du temps de réponse => accès simple et rapide
%\textit{Exemples : état civil, Annuaire distribué des adresses de l'Internet (DNS)}
\subsection{Exemples}
%Mettre des schémas DNS (voir Oreilly Bind) :
%Déléguation d'autorité
\subsubsection{DNS}
Le service DNS (Domain Name System) permet la conversion de noms de domaine en adresses IP (et inversement). On parlera de "nom pleinement qualifié" pour désigner un nom de domaine complet (typiquement sousdomaine.domaine.tld).\\
Il est plus facile pour l'être humain de retenir des noms que des numéros : il a donc été décidé d'associer des noms de domaine aux adresses IP. Au départ, un simple fichier HOSTS.TXT rassemblait les correspondances entre les adresses IP et les noms. Mais rapidement, ce système est devenu ingérable et il fut décidé d'opter pour une base de données distribuées en arbre (similaire au système de fichier UNIX) : la racine est gérée par l'ICANN\footnote{\url{http://www.icann.org/}} et les sous-domaines de la racine (TLD) sont délégués à des organismes : par exemple, chaque pays se voit confier un TLD (fr pour la France, us pour les États-Unis, uk pour la Grande-Bretagne, etc.). Ces organismes permettent ensuite à certaines sociétés, sous certaines conditions, de revendre des sous-domaines. À chaque sous-domaine acheté est associé un ou plusieurs serveurs DNS maître. Il est conseillé d'utiliser un serveur maître primaire et un serveur maître secondaire (ou serveur esclave) qui se synchronise sur le serveur primaire.\\
\textbf{Serveur DNS}\\
Un serveur DNS est (souvent) maître pour un certain nombre de noms de domaines, c'est-à-dire qu'il a autorité sur plusieurs zones. Il peut ainsi résoudre un certains nombres de demandes (il contient les informations grâce à des fichiers) ou déléguer des sous-zones à d'autres serveurs de domaine. Le serveur répond donc aux requêtes où il a autorité (en répondant directement ou en redirigeant vers le serveur ayant autorité) ou bien se redirige vers un serveur "racine" capable lui-même de rediriger vers les serveurs appropriés.\\
Au niveau réseau, un serveur DNS écoute sur le port 53 en TCP et UDP.\\
\textbf{Resolvers DNS}\\
Un résolver, ou client DNS, peut formuler deux types de demandes à un serveur DNS~:
\begin{itemize}
\item{les demandes en mode récursif} qui demandent une résolution complète au serveur DNS, l'obligeant à faire lui-même les requêtes pour apporter la réponse
\item{les demandes en mode itératif} qui demandent une réponse sans générer de requête de la part du serveur (sera donc sovent redirigé vers un serveur racine ou délégué)
\end{itemize}
\textit{Exemple de résolution "classique"}\\
Le résolveur adresse une requête en mode récursif : le serveur local envoie une requête en mode itératif à un serveur de nom faisant autorité sur la demande. Il essaiera le serveur le plus à même de répondre. Dans le pire des cas il contactera un serveur "racine" et suivra les références jusqu'à obtenir une réponse complète (généralement par le serveur de nom s'occupant du réseau où se trouve la machine).\\
Une fois la réponse trouvée, le serveur local envoie la réponse au résolveur.\\
Attention, il faut noter que les applications ou les systèmes ont souvent leur propre cache DNS.\\
~\\
\textit{Types d'enregistrement}\\
Bien que le principal but soit de convertir un nom de domaine en adresse IP, il existe différents types d'enregistrement au niveau d'un serveur DNS. L'enregistrement principal est l'enregistrement A qui associe directement un nom de domaine à une adresse IP mais il enexiste d'autres : l'enregistrement CNAME (qui lie un nom de domaine vers un autre nom de domaine), MX (qui permet de spécifier plusieurs serveurs SMTP avec différentes priorités), NS (qui spécifie les serveurs de noms), TXT (qui permet d'avoir un champ texte), PTR (pour les enregistrements invers), etc. Il existe également des enregistrements pour IPv6 où il faut à priori utiliser les enregistrements AAAA (il peut exister également des enregistrements A6).\\
~\\
\textit{Résolution inverse}\\
La résolution d'une adresse en nom n'est pas triviale car le processus de résolution devrait connaître à peu près toutes les branches de l'arbre pour pouvoir répondre, (sans compter que plusieurs noms pointent souvent vers la même adresse). L'idée a donc été de développée un sous-domaine pour les adresses. Ce sous-domaine est in-addr.arpa et peut contenir toutes les adresse IP existantes (elles sont inversées afin de partir des feuilles jusqu'à la racine). Ainsi, pour qu'une adresse IP fasse l'objet d'une résolution inverse, elle doit avoir un enregistrement dans ce sous-domaine.\\
~\\
\textbf{Mémoire cache et durée de vie}\\
En plus des différents mécanismes de résolution, l'utilisation d'une mémoire-cache accélère efficacement ces résolutions. En effet, lorsqu'un serveur de nom effectue une requête récursive il obtient de nombreuses informations (résolutions complètes, serveurs faisant autorité, etc.). Il va donc stocker ces informations afin de pouvoir répondre plus rapidement à de prochaines requêtes utilisant ces informations, et ainsi éviter d'interroger de nouveau les serveurs concernés. Il conserve en fait ces données pendant un temps fixé par le serveur DNS où il a été cherché ses données. Les serveurs DNS ayant des données qui varient fréquemment adapteront donc cette durée appelée TTL (Time To Live).\\
~\\
\textit{Les outils}\\
L'outil "historique" pour provoquer une résolution DNS est \textit{nsloookup}.
Sous Unix, on trouvera les outils \textit{host} et \textit{dig}.\\
~\\
Exemple d'une requête avec dig~:\\
\begin{verbatim}
$ dig @192.168.1.4 cmi.univ-mrs.fr +norecurse +notcp \
+noquestion +noauthority +noadditional MX
; <<>> DiG 9.3.1 <<>> @192.168.1.4 cmi.univ-mrs.fr
+norecurse +notcp +noquestion +noauthority +noadditional MX
; (1 server found)
;; global options: printcmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 4914
;; flags: qr ra; QUERY: 1, ANSWER: 1, AUTHORITY: 3, ADDITIONAL: 2
;; ANSWER section:
cmi.univ-mrs.fr. 86236 IN MX 10 gyptis.univ-mrs.fr.
;; Query time: 6 msec
;; SERVER: 192.168.1.4#53(192.168.1.4)
;; WHEN: Sun Nov 6 19:56:15 2005
;; MSG SIZE rcvd: 157
\end{verbatim}
\subsubsection{Arborescence des systèmes de fichiers Unix}
schémas avec /bin, /boot, /etc, /usr, /var, etc.
Avantages de la répartition en répertoires :
- Nombre de fichiers limités par répertoires
- Performance (accès plus rapide, recherche optimisée, etc.)
\subsubsection{Gestion des utilisateurs}
On peut voir les fichiers qui stocke les utilisateurs et des renseignements
sur eux (et même leurs mots de passe) comme un annuaire~:
Extrait d'un fichier /etc/passwd~:
\begin{verbatim}
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
bin:x:2:2:bin:/bin:/bin/sh
sys:x:3:3:sys:/dev:/bin/sh
\end{verbatim}
NIS/NIS+ est un service standard Unix qui permet de partager
des fichiers/annuaires pour toutes les machines d'un réseau :
\begin{verbatim}
/etc/passwd
/etc/group
/etc/hosts
/etc/aliases
/etc/protocols
/etc/services
\end{verbatim}
LDAP/Active Directory
\section{Protocole LDAP}
\subsection{Historique}
X.500, standard promulgué par l'OSI\footnote{International Organization for Standardization} et l'ITU-T\footnote{International Telecommunication Union-Telecommunication Standardization Sector}, définit :
- DAP (Directory Access protocol) : protocole de communication DUA<->DSA
- DSP (Directory System Protocol) : protocole de communication entre DSAs
- DISP (Directory Information Shadowing Protocol) : protocole de synchronisation/réplication entre DSAs
- DOP (Directory Operational Bindings Management Protocol) : protocole de gestion de liaison opérationnelle d'annuaire
DIB (Directory Information Base) : objets, classes d'objet, OID
DIT (Directory Information Tree) : noeud, feuille, alias, DN, RDN,
Modèles clients (DUA) / serveurs (DSA) : connexion, opération, réplication, droits, authentification
% Schémas d'après http://www.sysium.com/ldap.html
% http://sec.cs.kent.ac.uk/x500book/
Ces protocoles standards et ouverts ont été normalisés au début des années 1990.
S'appuyant sur des couches réseaux aujourd'hui peu répandues (modèle OSI), on
ne retrouve directement ces protocoles que dans des applications spécifiques
(armée, gouvernement, etc.). Néanmoins, ces protocoles ont posés les fondements
de toutes les applications d'annuaires modernes.
LDAP est dérivé du protocole DAP X.500, c'est-à-dire le protocole de communication entre un DUA et DSA.
Il s'agit d'une version simplifiée (d'où l'appelation "Light") principalement tirée du fait
qu'elle s'appuye sur la couche réseau TCP/IP, version simplifiée et répandue du modèle réseau d'OSI.
C'est l'IETF (Internet Engineering Task Force) qui centralise les travaux sur LDAP et publie les
spécifications dans des RFCs. La dernière version de LDAP est la version 3.
\subsection{Vocabulaire}
\textbf{Schéma}\\
Un schéma est une définition de classes d'objets, d'attributs et leur syntaxe. Chaque serveur utilisant un schéma spécifique ou des extensions doit l'enregistrer notamment pour obtenir un OID.\\
Exemple de définition d'attributs~:
\begin{verbatim}
attributetype ( 1.3.6.1.4.1.18413.21.3.10 NAME 'postfixTransport'
DESC 'transport for Postfix'
EQUALITY caseExactIA5Match
SYNTAX 1.3.6.1.4.1.1466.115.121.1.26{20} SINGLE-VALUE )
attributetype ( 1.3.6.1.4.1.18413.21.3.20 NAME 'isActive'
DESC 'an account is active or not'
EQUALITY booleanMatch
SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 SINGLE-VALUE )
\end{verbatim}
SYNTAX (1.3.6.1.4.1.1466.115.121.1.x)~:
\begin{verbatim}
7 = Boolean
8 = Certificat
15 = Directory String
26 = IA5 String
27 = INTEGER
50 = Telephone Number
\end{verbatim}
EQUALITY :
\begin{verbatim}
telephoneNumberMatch
integerMatch
booleanMatch
caseExactIA5Match
caseIgnoreIA5Match
\end{verbatim}
\textit{Liens~:}\\
\url{http://www.openldap.org/doc/admin22/schema.html}\\
\url{http://www.iana.org/cgi-bin/enterprise.pl}\\
\url{http://www.rfc-editor.org/rfc/rfc2252.txt}\\
EQUALITY type
SYNTAX type
\textbf{Objectclass}\\
Les classes d'objet, définies dans un schéma par un nom et OID (Object IDentifier), modélisent des objets définissant un certain nombres d'attributs obligatoires ou facultatifs. Elles peuvent être de plusieurs types~:\\
- structurelle çad correspondant à la description d'objets basiques~: personnes, groupes, etc.
- auxiliaire càd correspondant à des informations complémentaires à des objets de classe "structure"
- abstraite càd désignant des objets basiques de LDAP comme 'top' ou 'alias'
Les ObjectClass forment une hiérarchie. Prenons l'exemple de la classe d'objet "person" : elle est définie en tant que "SUP top STRUCTURAL", c'est à dire que c'est une classe structurelle en dessous de la classe abstraite 'top'. L'ObjectClass 'top' est toujours tout en haut. En pratique, il n'est pas nécessaire de le préciser mais il sera toujours là (même si il n'apparait pas). Les classes abstraites sont implicitement là~!\\
\textbf{OID (Object IDentifier)}\\
Un OID est une séquence de nombres entiers séparés par des points normalisée dans la RFC 2256. L'OID doit être unique afin de permettre une compatibilité entre les applications. C'est l'IANA\footnote{Internet Assigned Numbers Authority} qui est responsable de leur attribution et chaque entreprise peut obtenir un OID.\\
\textit{Lien~:} \url{http://www.isi.edu/cgi-bin/iana/enterprise.pl}\\
\textbf{attribut}\\
Les attributs, définis dans un schéma, sont rattachés à une classe d'objet. Un attribut définit une certaine syntaxe et des contraintes pour des données~: on peut rapprocher l'attribut LDAP du type de données d'une base de données.\\
\textbf{entrée (ou objet)}\\
Il s'agit d'un ensemble de données entrées formant un noeud dans l'arbre. Elle est définit de manière unique par un DN. Elle contient un ou plusieurs attributs. Une donnée est rattachée à un attribut. On peut avoir plusieurs valeurs pour un attribut.\\
un objet doit être identifié de manière unique
son adresse permet de retrouver l'objet
un objet peut avoir plusieurs noms
\textbf{DN (Distinguish Name)}\\
Le DN est une suite de valeurs (\textit{code = valeur}, où \textit{code} est l'un des attributs de l'entrée et \textit{valeur} est la valeur associée à l'attribut dans l'entrée) séparées par des virgules. L'ordre est important : on remonte l'arbre (le suffixe se trouve donc à gauche). Le DN définit une entrée unique pour un annuaire LDAP. Exemple~: \textit{cn=Manager,dc=evolix,dc=net}\\
\textbf{RDN (Relative DN)}\\
%(on remonte vers le suffixe)
\textbf{suffixe}\\
Il s'agit du DN du domaine. Il est souvent calqué sur un nom de domaine appartenant à la structure. Exemple : \textit{dc=evolix,dc=net}\\
\textbf{CN (Common Name)}\\
Il s'agit simplement d'un attribut (obligatoire) appartenant à la classe d'objet person. Il est souvent utilisé comme premier code dans le DN d'une entrée correspiondant à une personne. Mais l'on peut tout aussi bien utiliser un autre attribut (uid est également souvent utilisé).\\
DIT
Un DSA est un serveur de l'architecture LDAP/X.500
Un DUA est un client LDAP/X.500
\subsection{Protocole d'accès}
Capture de trame LDAP
Commentaires sur le protocole.
\subsection{RFCs à propos de LDAP}
RFC 1777 : LDAPv2
RFC 2251 : LDAPv3
RFC 2252 : syntaxe des attributs
RFC 2254 : filtres de recherche LDAP
RFC 2255 : format des URLs LDAP
\subsection{Principes des schémas LDAP}
attributs
Syntaxe attributs
Classes d'objects
Arborescence des classes d'objet
\subsection{Format LDIF}
Ldap Data Interchange Format
RFC 2849
Représentation sous forme de fichier texte des données
présentes dans un annuaire.
Syntaxe pour gérer des ajouts, modifications, suppressions.
\subsubsection{Les modèles LDAP}
modèle = services offerts par un serveur LDAP
La RFC 2251 définit deux modèles :
\subsubsection{Modèle protocole}
\subsubsection{Modèle données}
Néanmoins, certains ouvrages présentent quatres modèles :
\subsubsection{Modèle d'information}
\subsubsection{Modèle de nommage}
\subsubsection{Modèle fonctionnel}
\subsubsection{Modèle de sécurité}
\subsection{Annuaires LDAP vs Bases de données}
\subsubsection{Accès en lecture (consultation)}
\subsubsection{Modèle hiérachique (arborescence)}
Pour stocker un grand nombre de données et pouvoir y accéder de façon optimisée,
il faut séparer les données. Les séparer dans plusieurs branches du même niveau
revient à les répartir dans différentes tables. Mais si l'on prend en considération
que le nombre de branches est important, il devient nécessaire d'également séparer ces
branches. On entre donc dans un modèle hierarchique impossible à avoir avec une base
de données classique (pas de hiérarchie entre les tables).
\subsubsection{Possibilité d'une modèle distribué}
\subsubsection{Sécurité (authentification, gestion des droits)}
\subsubsection{Orientée objet}
\subsubsection{etc.}
\subsection{Vue du marché LDAP}
\subsubsection{Logiciels serveurs LDAP}
OpenLDAP
MS Active Directory
% http://mi.cnrs-orleans.fr/Security/Win2k/ActiveDirectory/ActiveDirectory1.htm
Novell eDirectory
etc.
\subsubsection{Logiciels compatibles LDAP}
Microsoft Outlook
Apache
ProFTPD
Applications WEB
\subsubsection{Logiciels clients LDAP}
Il existe plusieurs logiciels clients pour visualiser, insérer, modifier, supprimer, etc. des données issues d'un annuaire LDAP~:
\begin{itemize}
\item \textbf{LDAP Browser/Editor} logiciel graphique en Java permettant
de visualiser, modifier et rechercher aisément. Import et export au
format LDIF sont pratiques.\\
\textit{Lien~:} \url{http://www-unix.mcs.anl.gov/~gawor/ldap/}
\item \textbf{PhpLDAPadmin} interface web en PHP permettant d'effectuer de nombreuses opérations aisément.\\
\textit{Lien~:} \url{http://phpldapadmin.sourceforge.net/}
\end{itemize}
Voir aussi les clients proprios (notam. Microsoft)
\section{Champs d'applications des annuaires LDAP}
\subsection{Service d'authentification}
\subsubsection{L'authentification avec LDAP}
simple\_bind
simple\_bind\_s
\subsubsection{Utilisation dans un logiciel}
\subsubsection{Exemple avec Windows/Active Directory}
\subsubsection{Exemple avec Linux/libnss}
\subsubsection{Exemple avec Apache}
\subsubsection{Autres exemples}
\subsubsection{Utilisation avec SASL}
\subsubsection{Un pas vers la SSO}
\subsection{Service de stockage d'informations}
\subsubsection{Informations stockées avec LDAP}
\subsubsection{Utilisation dans un logiciel}
\subsubsection{Stockage de profils}
\subsubsection{Contrôle d'accès aux données}
\subsubsection{Exemple avec un carnet d'adresses}
\subsubsection{LDAP et les langages de programmation}
%\section{Méta-annuaire LDAP}
%Annuaire d'annuaire
\section{Architecture et mise en place}
%http://www.sysium.com/fr/offres-ldap/annuaire-ldap/demarche-ldap.html
\subsection{Concevoir un cahier des charges}
Respect des conventions
Lister applications
Lister contenu
\subsubsection{Audit de l'existant}
\subsubsection{Expression des besoins}
\subsubsection{Définition du contenu et architecture}
\subsubsection{Choix techniques}
\subsubsection{Ajout de schémas personnalisés}
Applications clients
Utiliser schémas existants
Étendre ou ajouter des schémas
\subsubsection{Politique de sécurité}
ACLs
\subsubsection{Test et recette}
Vérifications
Benchmarks
\subsection{Utilisation et administration}
\subsubsection{Gestion des données}
\subsubsection{Logiciels client LDAP}
\subsubsection{Import/export données}
\subsubsection{Utilisation avec SSL/TLS}
\subsubsection{Réplication}
\subsubsection{Sauvegarde}
\section{Application pratique}
\subsection{Mise en place d'un annuaire LDAP}
\subsubsection{Installation}
\subsubsection{Configuration}
\subsubsection{Gestion des droits}
\subsubsection{Installation des schémas}
\subsubsection{Sécurité}
\subsection{Utilisation d'un annuaire LDAP}
\subsubsection{Installation des outils nécessaires}
\subsubsection{Configuration}
\subsubsection{Écriture des fichiers au format LDIF}
\subsubsection{Ajout/modification/suppression données}
\subsubsection{Recherche de données}
%\subsection{Utilisation avec TLS}
\subsubsection{Focus sur l'authentification LDAP}
\newpage
\section{OpenLDAP}
~\\
\subsection{Présentation}
~\\
LDAP (Lightweight Directory Access Protocol) est un protocole pour accéder à un service d'annuaire. Les annuaires permettent de partager des informations, telles que des coordonnées d'entités ou personnes ou encore des données système. Un annuaire est une base de données spécifique structurée dans une arborescence hiérarchique. Un annuaire est censé être largement plus performant en consultation qu'un système de gestion de bases de données classique. LDAP peut servir d'annuaire pour gérer des coordonnées, pour servir des applications (SMTP, Groupware, etc.) ou pour gérer l'authentification (UNIX, Apache, IMAP, etc.)\\
~\\
\textit{Liens~:}\\
\url{http://www-sop.inria.fr/semir/personnel/Laurent.Mirtain/ldap-livre.html}\\
\url{http://www.cru.fr/ldap/}\\
\url{http://www.quesaco.org/astuces.php?targt=ldap}\\
\url{http://www.fefe.de/tinyldap/}\\
\url{http://www.commentcamarche.net/ldap/}\\
\url{http://www.lifl.fr/~boulet/formation/syst-dist/exposes2003-2004/ldap/}\\
http://www.computerbooksonline.com/chapters/ldapchap.htm
http://www.editions-eyrolles.com/Livre/9782212115048/annuaires-ldap
http://yolinux.com/TUTORIALS/LinuxTutorialLDAP.html
\subsection{Installation}
\subsubsection{À partir des sources}
~\\
On peut utiliser la méthode classique de recompilation à partir des sources~:
\begin{verbatim}
$ ./configure [options]
$ make depend
$ make
# make install
\end{verbatim}
\subsubsection{Par paquets}
~\\
Sous Debian, les paquets principaux à installer sont~:
~\\
\textbf{slapd} : serveur OpenLDAP\\
\textbf{libldap} : librairies OpenLDAP\\
\textbf{ldap-utils} : outils OpenLDAP\\
~\\
\emph{Dépendances Debian~:}
\begin{center}
\begin{tabular}{|c|c|}
\hline
libc6 :& librairies "GNU C"\\
\hline
libdb4.2 :& librairies "Berkeley v4.2 Database"\\
\hline
libgcrypt11 :& librairies cryptographiques LGPL\\
\hline
libgnutls11 :& librairies GNU TLS\\
\hline
libgpg-error0 :& librairie pour erreurs/messages composants GnuPG\\
\hline
libiodbc2 :& gestion pilote iODBC\\
\hline
libltdl3 :& librairie libltdl (wrapper dlopen pour GNU libtool)\\
\hline
libsasl2 :& librairies SASL v2\\
\hline
libslp1 :& librairies OpenSLP\\
\hline
libwrap0 :& librairies TCP wrapper de Wietse Venema\\
\hline
zlib1g :& librairies de compression gzip\\
\hline
perl :& fameux language interprêté de Larry Wall\\
\hline
\end{tabular}
\end{center}
~\\
\subsection{Configuration}
~\\
Le répertoire \textit{/etc/ldap/schema/} contient les schémas LDAP disponibles.\\
~\\
Certains schémas sont présents par défaut.\\
Il est aussi possible d'en ajouter ou d'en définir manuellement.\\
~\\
\textit{Lien~:} \url{http://www.openldap.org/doc/admin22/schema.html}\\
~\\
\texttt{ldap.conf} est le fichier de configuration pour toutes les applications clientes faisant appel aux bibliothèques OpenLDAP (dans le paquet Debian libldap2). Parmi celles-ci se trouvent, non exhaustivement, Sendmail, Pine, Balsa, Evolution, Gnome Meeting, etc. Voici un exemple de ce fichier~:\\
\begin{verbatim}
BASE dc=evolix,dc=net
URI 127.0.0.1
\end{verbatim}
~\\
\texttt{slapd.conf} est le fichier de configuration pour le démon slapd~:\\
\begin{verbatim}
#modules
modulepath /usr/lib/ldap
moduleload back_bdb
backend bdb
#schemas
include /etc/ldap/schema/core.schema
include /etc/ldap/schema/cosine.schema
include /etc/ldap/schema/nis.schema
include /etc/ldap/schema/inetorgperson.schema
include /etc/ldap/schema/misc.schema
#options
schemacheck on
pidfile /var/run/slapd.pid
argsfile /var/run/slapd.args
replogfile /var/lib/ldap/replog
loglevel 0
#base
database bdb
suffix "dc=evolix,dc=net"
directory "/var/lib/ldap"
index objectClass eq
lastmod on
\end{verbatim}
Les données LDAP sont dans le répertoire \texttt{/var/lib/ldap/} sous Debian~:\\
\begin{verbatim}
# ls /var/lib/ldap/
__db.001 __db.003 __db.005 dn2id.bdb log.0000000001
__db.002 __db.004 DB_CONFIG id2entry.bdb objectClass.bdb
\end{verbatim}
\subsection{Gestion des droits}
Pour gérer les droits d'accès à l'annuaire LDAP, on écrit des règles dites ACL (Access Control List) dans le fichier de configuration pour le démon slapd \textit{slapd.conf}. Voici un exemple~:\\
\begin{verbatim}
access to attribute=userPassword
by dn="cn=admin3,dc=evolix,dc=net" write
by anonymous auth
by self write
by * none
access to dn.children="ou=Clients,dc=evolix,dc=net"
by dn.regex="cn=admin,ou=Clients,dc=evolix,dc=net" write
by dn.children="ou=People,dc=evolix,dc=net" write
by users none
by * none
access to *
by dn.regex="cn=admin,dc=evolix,dc=net" write
by users read
by * none
# Administrateur "en dur" (voir slappasswd)
rootdn "cn=admin2,dc=evolix,dc=net"
rootpw {SSHA}ez1NjoyNPknjuKrORzXpem16h/tGgee7
\end{verbatim}
Remarquons qu'on peut utiliser un administrateur "en dur" (\texttt{rootdn} dans le fichier \texttt{slapd.conf}) qui aura alors un accès à toutes les ressources (les lignes lui attribuant des droits sont inutiles). Mais on peut tout à fait utiliser un utilisateur LDAP classique~!
~\\
Pour écrire des règles ACL, on précise donc une entité LDAP et ensuite on précise des droits pour des entités LDAP~:
\begin{verbatim}
access to dn.<scope-style>=<DN> attrs=[attributs]
by <entité LDAP> <droit LDAP>
\end{verbatim}
Lorsque l'on fait une opération sur une certaine entité de l'annuaire LDAP, les droits sont déterminés par le premier entité LDAP rencontré. Ainsi, on précisera toujours les droits par défaut à la fin.\\
~\\
Exemple typique d'une règle ACL~:
\begin{verbatim}
access to dn.children="ou=Clients,dc=evolix,dc=net" attrs=telephoneNumber
by dn.regex="cn=admin,ou=Clients,dc=evolix,dc=net" write
by dn.children="ou=People,dc=evolix,dc=net" write
by users read
by * none
\end{verbatim}
Droits LDAP~:
\begin{verbatim}
none =0 no access
auth =x needed to bind
compare =cx needed to compare
search =scx needed to apply search filters
read =rscx needed to read search results
write =wrscx needed to modify/rename
\end{verbatim}
Entités LDAP~:
\begin{verbatim}
* All, including anonymous and authenticated users
anonymous Anonymous (non-authenticated) users
users Authenticated users
self User associated with target entry
dn[.<basic-style>]=<regex> Users matching a regular expression
dn.<scope-style>=<DN> Users within scope of a DN
\end{verbatim}
\begin{verbatim}
dn[.<basic-style>]= dn.regex, dn.exact
dn.<scope-style> = dn.base, dn.one, dn.subtree, dn.children
\end{verbatim}
On peut utiliser une liste d'attributs en ajoutant attr=<attributs>\\
On peut utiliser un filtre en ajoutant filter=<filtre>\\
Exemple~:
\begin{verbatim}
to dn.one="ou=People,dc=evolix,dc=net" filter=(gidNumber=2000)
\end{verbatim}
Attention la syntaxe du fichier \texttt{slapd.conf} est importante~!
Par exemple, il ne faut pas insérer de commentaires dans les règles ACL.
Ainsi l'exemple suivant est non valable~:
\begin{verbatim}
access to *
# commentaires
by * none
\end{verbatim}
\textit{Lien~:}
\url{http://www.openldap.org/doc/admin22/slapdconfig.html\#Access\%20Control}
\subsection{Utilisation}
On crée le domaine et éventuellement son administrateur (si non présent).\\
À noter que sous Debian, cette opération est automatiquement faite à l'installation (questions posées via debconf)\\
~\\
Contenu du fichier \texttt{domaine.ldif}~:\\
\begin{verbatim}
dn: dc=evolix, dc=net
objectclass: top
objectclass: dcObject
objectClass: organization
o: exemple
dc: evolix
description: LDAP Evolix
dn: cn=admin,dc=evolix,dc=net
objectclass: organizationalRole
cn: admin
\end{verbatim}
\begin{verbatim}
# ldapadd -x -h solaris -D "cn=admin2,dc=evolix,dc=net" -W -f domaine.ldif
Enter LDAP Password:
adding new entry "dc=evolix,dc=net"
adding new entry "cn=admin2,dc=evolix,dc=net"
\end{verbatim}
~\\
On crée ensuite un annuaire.\\
~\\
\texttt{create.ldif}~:\\
\begin{verbatim}
dn: ou=annuaire,dc=evolix,dc=net
objectClass: organizationalUnit
ou: annuaire
description: Annuaire Evolix
\end{verbatim}
\begin{verbatim}
# ldapadd -x -D "cn=admin2,dc=evolix,dc=net" -W -f create.ldif
Enter LDAP Password:
adding new entry "ou=annuaire, dc=evolix, dc=net"
\end{verbatim}
~\\
\textbf{Remarque} : il est conseillé d'utiliser \texttt{slapaddd -x -D [...] fichier.ldif plutot que slapdadd < fichier.ldif} afin d'éviter des erreurs de syntaxes.\\
Éventuellement pour des fichiers LDIF importants, la deuxième méthode est plus rapide.\\
On remplit l'annuaire avec des données. Par exemple, avec le fichier \texttt{entree.ldif}~:\\
~\\
\begin{verbatim}
dn: cn=Gregory, ou=annuaire, dc=evolix, dc=net
objectClass: person
objectClass: inetOrgPerson
cn: Gregory
sn: reg
telephoneNumber: 06 98 86 00 00
\end{verbatim}
\begin{verbatim}
ldapadd -x -D "cn=admin2,dc=evolix,dc=net" -W -f entree2.ldif
\end{verbatim}
Dans cet exemple, on utilise le mot de passe "en dur" dans le fichier \texttt{slapd.conf}.\\
~\\
On peut également utiliser~:
\begin{verbatim}
# slapadd < entree.ldif
\end{verbatim}
~\\
Pour une recherche dans la table, on peut utiliser le client \texttt{ldapsearch}. Par exemple~:\\
\begin{verbatim}
$ ldapsearch -x -b "ou=annuaire,dc=evolix,dc=net" -D \
"cn=admin2,dc=evolix,dc=net" -W -h 192.168.1.5
\end{verbatim}
Quelques options disponibles~:
\begin{verbatim}
-L : renvoie les résultat au format LDIFv1
-LL : désactive les commentaires
-LLL : désactive l'affichage de la version de LDIF
-h <host> : permet de se connecter à un serveur distant
(par défaut, il s'agit de localhost)
\end{verbatim}
~\\
Pour faire des modifications en mode console, on peut utiliser un \texttt{ldapmodify}. Par exemple, prenons le fichier \texttt{modif.ldif}~:
\begin{verbatim}
dn: cn=Gregory, ou=annuaire, dc=evolix, dc=net
changetype: modify
replace: telephoneNumber
telephoneNumber: 04 98 86 00 00
\end{verbatim}
Au lieu de spécifier \texttt{remplace:}, on peut mettre \texttt{add:} (il est possible de mettre plusieurs valeurs pour le même atribut) ou \texttt{delete:} (bien sûr sans mettre de valeur pour l'attribut supprimé).\\
On peut ensuite effectuer effectivement les modifications~:
~\\
\begin{verbatim}
$ ldapmodify -x -D "cn=admin2,dc=evolix,dc=net" -W -f /tmp/modif.ldif
\end{verbatim}
On notera que diverses informations sur les changements sont retenues si l'option \texttt{lastmod on} est présente dans le fichier \texttt{slapd.conf}~: la date de modification (\texttt{modifyTimestamp}), l'auteur de la modification (\texttt{modifiersName}), etc.\\
~\\
Pour la suppression, on peut également procéder en utilisant un fichier LDIF. Par exemple, voici un fichier \texttt{suppr.ldif}~:
\begin{verbatim}
cn=Gregory, ou=annuaire, dc=evolix, dc=net
\end{verbatim}
Les modifications effectives seront faites par la commande \texttt{ldapdelete}~:
\begin{verbatim}
$ ldapdelete -x -D "cn=root,dc=evolix,dc=net" -W -f /tmp/suppr.ldif
\end{verbatim}
On peut également faire directement~:
\begin{verbatim}
$ ldapdelete -x -D "cn=admin2,dc=evolix,dc=net" -W \
"cn=Gregory,ou=annuaire, dc=evolix, dc=net"
\end{verbatim}
~\\
Bien sûr, toutes ces opérations peuvent être automatisées à l'aide Shellscripts ou bien à l'aide d'autres clients en Perl, PHP, Java... (voir ci-après)
\subsubsection{Exemples d'utilisation}
~\\
\textbf{Carnet d'adresses}\\
~\\
Pour une utilisation en tant que carnet d'adresses, on peut se connecter grâce à des clients mail comme Outlook, Mozilla-Thunderbird, etc.\\
~\\
\textbf{Comptes Unix}\\
~\\
L'utilisation en tant qu'annuaire d'utilisateurs/mots de passe peut se faire sous Linux en utilisant la librairie NSS (Name Service Switch)\footnote{\url{http://www.gnu.org/software/libc/manual/html_node/Name-Service-Switch.html}} et PAM (Pluggable Authentication Modules)\footnote{\url{http://www.kernel.org/pub/linux/libs/pam/}}.\\
~\\
Sous Debian GNU/Linux, on fera~:
\begin{verbatim}
# aptitude install ldap-utils libnss-ldap libpam-ldap
\end{verbatim}
Pour utiliser notre annuaire en plus des comptes UNIX classiques, on précisera dans le fichier \texttt{/etc/nsswitch.conf}~:
\begin{verbatim}
passwd: compat ldap
group: compat ldap
shadow: compat ldap
\end{verbatim}
~\\
On précise les paramètres de l'annuaire LDAP dans le fichier \texttt{/etc/libnss-ldap.conf}~:
\begin{verbatim}
host IP_serveur_LDAP
base dc=evolix,dc=net
ldap_version 3
#binddn cn=unix,dc=evolix,dc=net
#bindpw XXX
#rootbinddn cn=adminunix,dc=evolix,dc=net
\end{verbatim}
Attention, ces fichiers doivent être lisibles par tous les utilisateurs. Si l'on doit préciser \texttt{binddn} et \texttt{bindpw}, on prendra bien garde à ce que l'utilisateur LDAP précisé ne puisse accéder aux données LDAP utiles uniquement en lecture. Pour \texttt{root} on peut préciser un utilisateur LDAP différent grâce à la directive \texttt{rootbinddn} et le mot de passe sera stocké dans le fichier \texttt{/etc/ldap.secret} accessible en lecture uniquement à \texttt{root}.\\
On vérifiera que cela fonctionne correctement en faisant~:\\
\begin{verbatim}
$ getent passwd
\end{verbatim}
Ensuite, pour pouvoir utiliser ces données à partir d'applications, on modifie le fichier \texttt{/etc/pam\_ldap.conf} qui est de syntaxe similaire au fichier \texttt{libnss-ldap.conf}~:\\
\begin{verbatim}
host IP_serveur_LDAP
base dc=evolix,dc=net
ldap_version 3
#binddn cn=unix,dc=evolix,dc=net
#bindpw XXX
#rootbinddn cn=adminunix,dc=evolix,dc=net
pam_password crypt
\end{verbatim}
~\\
Afin d'optimiser less requêtes les plus fréquentes, on indexe les valeurs qui vont être demandées le plus souvent. Dans le fichier \texttt{slapd.conf}~:
\begin{verbatim}
index uidNumber eq
index gidNumber eq
index memberUid eq
\end{verbatim}
Et on doit ensuite le faire prendre en compte à OpenLDAP en utilisant la commande \texttt{slapindex}~:\\
\begin{verbatim}
# slapindex -f slapd.conf && /etc/init.d/slapd restart
\end{verbatim}
On peut également installer \texttt{nscd} (Name Service Cache Daemon) qui utilise un système de cache utilisateur afin d'optimiser les requêtes vers un annuaire. Notons qu'il faut prendre gare au cache de \texttt{nscd} lors de changement (on devra souvent relancer \texttt{nscd}).\\
~\\
\textbf{Postfix}\\
~\\
Les bases de données d'utilisateurs et de leurs paramètres d'un serveur de messagerie électronique peuvent être stockés dans une base de données externe et notamment un annuaire LDAP.\\
~\\
Dans le fichier \texttt{main.cf} de Postfix, on utilisera une configuration type~:\\
\begin{verbatim}
alias_maps = [autres bases] ldap:ldapbla
ldapbla_server_host = [serveur ldap]
ldapbla_search_base = [dn de base]
ldapbbla_result_attribute = [type de champs à chercher]
#ldapaliases_bind = yes
#ldapaliases_bind_dn = cn=postfix,dc=evolix,dc=net
#ldapaliases_bind_pw = XXX
ldapaliases_query_filter = (mail=%s)
ldapaliases_result_attribute = uid
ldapaliases_debuglevel = 0
\end{verbatim}
Par défaut, Postfix regarde le(s) attribut(s) \texttt{mailacceptinggeneralid} pour déterminer à qui le mail est destiné (on peut spécifier un mail "entier" ce qui permet de différencier \textit{alias@domain1.tld} de \textit{alias@domain1.tld}). Ensuite, il regarde le(s) attribut(s) \texttt{maildrop} pour déterminer à qui distribuer le mail. On change cela grâce aux directives \texttt{query\_filter} et \texttt{result\_attribute} dans Postfix.
On peut aussi préciser un nom de fichier où l'on mettra ces directives. Par exemple~:
\begin{verbatim}
alias_maps = [autres bases] ldap:/etc/postfix/ldap-aliases.cf
\end{verbatim}
Dans le fichier \texttt{/etc/postfix/ldap-aliases.cf} on mettra les mêmes directives que celles précisées ci-dessus sans le suffixe \textit{ldapbla\_}.\\
~\\
Pour notre exemple, on aura des entrées LDAP ressemblant à~:\\
\begin{verbatim}
dn: uid=pnom,[dn de base]
objectClass: inetOrgPerson
objectClass: inetLocalMailRecipient
objectClass: posixAccount
sn: Nom
givenName: Prenom Nom
mail: pnom@domain.tld
mail: prenom.nom@domain.tld
cn: Prenom Nom
displayName: Prenom Nom
uid: pnom
userPassword: XXXX
uidNumber: 1006
gidNumber: 1000
homeDirectory: /home/pnom/
\end{verbatim}
Il est aussi envisageable d'avoir des entrées correspondant uniquement à des aliases (et non rattachés à un utilisateur) et notamment préciser un alias de collecte pour un domaine (\texttt{mailacceptinggeneralid: @domain.tld}).\\
~\\
%http://archives.neohapsis.com/archives/postfix/1999-q4/1358.html
\textbf{Apache}\\
~\\
On peut utiliser l'authentification Apache avec un annuaire OpenLDAP. Il existe plusieurs modules pour utiliser LDAP avec Apache. Pour Apache2, un module \textit{mod\_auth\_ldap} est intégré par défaut\footnote{\url{http://httpd.apache.org/docs-2.0/mod/mod\_auth\_ldap.html}}. Voici un exemple de configuration~:
\begin{verbatim}
AuthName "Acces Prive"
AuthType Basic
AuthLDAPEnabled on
AuthLDAPURL ldap://127.0.0.1/ou=people,dc=evolix,dc=net?uid?one
AuthLDAPAuthoritative on
require valid-user
\end{verbatim}
\textbf{Diverses applications}\\
~\\
De nombreuses applications permettent d'utiliser une base OpenLDAP pour le stockage de données et/ou l'authentification. Typiquement, une application comme Egroupware permet l'utilisation d'une base OpenLDAP pour l'authentification des utilisateurs et pour le stockage des contacts. Plus globalement, un annuaire LDAP est souvent utilisé comme un serveur d'authentification~: toutes les applications d'une structure l'utilisent pour authentifier les utilisateurs. Centraliser l'authentification offre de nombreux avantages~: un mot de passe identique pour toutes les applications, facilité d'administration pour gérer ajout/changement, etc. Par contre, le serveur OpenLDAP est dans ce cas extrêmement critique car si il est défaillant, toutes les applications peuvent être inutilisables~! Ainsi, il peut être important d'avoir une politique de sauvegarde et de tolérance de panne.
\subsection{Utilisation avec TLS}
Afin de sécuriser les connexions entre le client et le serveur (chiffrement et authentification), on peut utiliser TLS (Transport Layer Security). TLS utilise des certificats X.509. Il peut être essentiel de ne pas transporter des données non chiffrées surtout lorsqu'un serveur OpenLDAP est utilisé en tant que serveur d'authentification. Ainsi, si on utilise LDAP en mode classique, les mots de passe circulent en clair~!\\
~\\
Pour utiliser un certificat sur le serveur OpenLDAP, il nous faut obtenir un certificat X.509 et une clé privée. Selon la politique de sécurité en place au sein de sa structure, on utilisera un certificat signé par une autorité de certification ou bien généré par une PKI (Public Key Infrastructure) interne. On peut également générer un certificat auto-signé.\\
~\\
On rappelle la procédure de génération d'un certificat auto-signé~:\\
~\\
On crée une "demande" de certificat en se basant sur des paramètres aléatoires ainsi qu'une clé privée \texttt{privkey.pem} protégée par un mot de passe~:
\begin{verbatim}
$ openssl req -new > demande.csr
\end{verbatim}
Si l'on veut supprimer ce mot de passe de protection (utile dans le cas d'un serveur), on ajoute l'argument \texttt{-out cleprivee.pem} et l'on obtient une clé privée \texttt{cleprivee.pem} non protégée~:
\begin{verbatim}
$ openssl rsa -in privkey.pem -out cleprivee.pem
\end{verbatim}
Enfin, on génère le certificat basé sur la demande et signé par la clé privée~:
\begin{verbatim}
$ openssl x509 -in demande.csr -out certificat.pem -req -signkey
cleprivee.pem -days 365
\end{verbatim}
On peut ensuite ajouter les lignes suivantes dans le fichier \texttt{slapd.conf}~:
\begin{verbatim}
TLSCertificateFile /path/to/certs/certificat.pem
TLSCertificateKeyFile /path/to/certs/cleprivee.pem
\end{verbatim}
On peut ensuite redémarrer le serveur OpenLDAP.\\
~\\
Du côté du client, il faut posséder le certificat pour pouvoir se connecter au serveur avec TLS. On veillera à utiliser un moyen sûr pour transporter le certificat serveur jusqu'au client afin d'assurer également l'authentification lors de la connexion. Pour se connecter avec le client console (paquet \textit{ldap-utils}), on crée un fichier \texttt{~/.ldaprc} qui contiendra le chemin vers le certificat serveur~:
\begin{verbatim}
TLS_CACERT /path/to/cert/certificat.pem
\end{verbatim}
On peut ensuite se connecter en utilisant l'option \texttt{-ZZ}. Par exemple~:
\begin{verbatim}
$ ldapsearch -x -b "dc=formations,dc=evolix,dc=fr" -D \
"cn=admin,dc=formations,dc=evolix,dc=fr" -LL uid -h \
ldap.formations.evolix.fr -ZZ -W
\end{verbatim}
On note qu'il est obligatoire d'utiliser le nom de domaine du serveur présent dans le certificat. Sinon la connexion en TLS est impossible~!\\
~\\
De même, on peut utiliser TLS avec des clients LDAP.\\
\newpage
\subsection{Annuaires distribués}
\subsubsection{Liens entre annuaire}
Le but est de lier différentes branches d'annuaires distincts. Les liaisons possibles sont le service referral (apparu dans la norme LDAPv3) et le chaînage de données (qui ressemble à des requêtes DNS récursives).
Pour le service referral, cela consiste à un serveur \texttt{example.com} de déléguer une branche, par exemple \texttt{dc=myref,dc=example,dc=com}, à un autre serveur, par exemple \texttt{bis.example.com}.
\texttt{example.com} comportera une entrée du type~:
\begin{verbatim}
dn: dc=myref,dc=example,dc=com
objectClass: referral
objectClass: extensibleObject
dc: myref
ref: ldap://bis.example.com/dc=myref,dc=example,dc=com
\end{verbatim}
\texttt{bis.example.com} pourra également pointer vers \texttt{example.com} pour les entrées non définies. Dans ce cas, on précisera dans le fichier \texttt{slapd.conf}~:
\begin{verbatim}
referral ldap://example.com/
\end{verbatim}
Il faut utiliser l'option \texttt{-M} pour contrôler ces informations sans "suivre" les referral. Par exemple, pour supprimer un referral~:
\begin{verbatim}
ldapdelete -M -x -D "cn=admin,dc=example,dc=com" -W "dc=myref,dc=example,dc=com"
\end{verbatim}
\subsubsection{Réplication}
Dans cette architecture, il y a un serveur OpenLDAP maître et un serveur OpenLDAP esclave. La gestion des réplications est faite grâce au daemon slurpd (Standalone LDAP Update Replication Daemon) sur le serveur OpenLDAP maître.~\\
\textit{Lien~:}
\url{http://www.openldap.org/doc/admin22/config\_repl.gif}\\
~\\
Sur le serveur maître~:\\
~\\
\texttt{slapd.conf}\\
\begin{verbatim}
replogfile /var/lib/ldap/replog
replica uri=ldap://ldap2.evolix.net:389
binddn="cn=Replicator,dc=evolix,dc=net"
bindmethod=simple credentials=secret
\end{verbatim}
~\\
Sur le serveur esclave~:\\
~\\
\texttt{slapd.conf}
\begin{verbatim}
rootdn "cn=Replicator,dc=evolix,dc=net"
rootpw {SSHA}UflDkKSi+YdiQ+5OUrM1uJsJKZDSO++W
updatedn "cn=Replicator,dc=evolix,dc=net"
updateref "ldap://ldap.evolix.net"
\end{verbatim}
Les modifications LDAP sont stockées dans le replogfile qui est vidé par slurpd. Si le serveur esclave est disponible, elles lui sont ensuite envoyés. Si aucun accès en écriture n'est possible, les modificatiosn sont rejetés et conservés dans des fichiers \texttt{.rej}. À noter que la première fois les données LDAP doivent être importés manuellement sur le serveur esclave.
\subsection{Clients OpenLDAP}
~\\
Il existe plusieurs logiciels clients pour visualiser, insérer, modifier, supprimer, etc. des données dans une base OpenLDAP~:
~\\
\begin{itemize}
\item \textbf{ldap-utils} commandes en mode console (ldapadd, ldapcompare, ldapdelete, ldapmodify, ldapmodrdn, ldappasswd, ldapsearch, ldapwhoami)
\item \textbf{LDAP Browser/Editor} logiciel graphique en Java permettant
de visualiser, modifier et rechercher aisément. Import et export au
format LDIF sont pratiques.\\
\textit{Lien~:} \url{http://www-unix.mcs.anl.gov/~gawor/ldap/}
\item \textbf{GQ} logiciel graphique en GTK permettant de visualiser aisément.\\
\textit{Lien~:} \url{http://biot.com/gq/}
\item \textbf{PhpLDAPadmin} interface web en PHP permettant d'effectuer de nombreuses opérations aisément.\\
\textit{Lien~:} \url{http://phpldapadmin.sourceforge.net/}
\end{itemize}
% voir le package Debian 'cpu'
% http://www.urec.cnrs.fr/cours/Applis/x500/
% http://www.sysium.com/ldap.html

192
support/php.tex Normal file
View file

@ -0,0 +1,192 @@
% Copyright (c) 2004-2010 Evolix <info@evolix.fr>
% Permission is granted to copy, distribute and/or modify this document
% under the terms of the GNU Free Documentation License, Version 1.2
% or any later version published by the Free Software Foundation;
% with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
% A copy of the license is included at http://www.gcolpart.com/howto/fdl.html
\chapter{PHP}
\url{http://www.php.net/} \\
\url{http://www.zend.com/} \\
\section{Présentation}
Un danois, Rasmus Lerdorf\footnote{\url{http://www.lerdorf.com/}}, décidant de mettre en valeur sa page personnelle a créé une collection de scripts en Perl/CGI appelée PHPTools (Personel Home Page Tools). Réécrit en langage C, l'outil fut renommé PHP/FI (Forms Interpreter). PHP/FI version 2 peut s'insérer sous forme de module au serveur Apache et permet d'insérer directement des instructions dans du code HTML. En 1997, plusieurs développeurs s'associent à Rasmus Lerdorf pour sortir un an plus tard PHP 3 qui intégrait de nombreuses fonctionnalités comme le support de systèmes de gestion de base de données. PHP étant cette fois un acronyme récursif de "PHP : Hypertext Preprocessor". La sortie de PHP 4 en 2000 puis de PHP 5 en 2004 apporta de nombreuses fonctionnalités supplémentaires.\\
PHP est donc un langage de programmation Open Source principalement utilisé par les développeurs web pour créer des pages dynamiques. En effet c'est un langage de script exécuté du côté serveur générant principalement du HTML. Sa syntaxe empruntée aux langages C, Java et Perl est assez simple à apprendre. \\
~\\
\section{Installation}
\subsection{Compilation}
Comme la plupart des logiciels libres et Apache, il est possible de compiler PHP à partir des sources. Cela permet de compiler uniquement avec les options que l'on a besoin et d'avoir des binaires bien adaptés à sa machine :\\
\begin{verbatim}
./configure [options]
make
make install
\end{verbatim}
\subsection{Paquets}
~\\
\textbf{Pour Debian GNU/Linux :}
~\\
\textit{Paquets principaux :}
~\\
\begin{itemize}
\item[\textbf{php5-common}] : fichiers courants pour PHP
\item[\textbf{libapache2-mod-php5}] : module mod\_php pour Apache2
\end{itemize}
~\\
\emph{Dépendances directes :}
~\\
\begin{center}
\begin{tabular}{|c|c|}
\hline
libc6 :& librairies "GNU C"\\
\hline
libbz2-1.0 :& librairie de compression bzip2\\
\hline
libdb4.2 :& librairies "Berkeley v4.2 Database"\\
\hline
libexpat1 :& librairie "XML parsing C"\\
\hline
libpcre3 :& librairie Perl 5 Compatible Regular Expression\\
\hline
libssl0.9.7 :& librairies "SSL shared"\\
\hline
zlib1g :& librairies de compression gzip\\
\hline
mime-support :& support MIME (mime.types, mailcap)\\
\hline
apache2-mpm-prefork :& implémentation "non-threaded" (similaire à Apache 1.3.x)\\
\hline
libmagic1 :& librairie pour les types de fichiers utilisant les numéros magiques\\
\hline
\end{tabular}
\end{center}
~\\
\section{Configuration}
\subsection{Fichier de configuration}
La configuration par défaut de PHP fonctionne en général assez bien. Néanmoins un certain nombre de paramètres peuvent être configurés dans le fichier nommé php.ini (sa syntaxe rappelle en effet les fichiers INI d'applications Microsoft Windows). Il est important de se familiariser avec cette configuration pour pouvoir la modifier pour des questions de sécurité ou pour certaines applications.\\
~\\
\texttt{php.ini :}
~\\
\begin{verbatim}
; activer l'interpretation du Code PHP
engine = On
; active le support des balises courtes <? ... ?>
short_open_tag = On
; quantité maximale de memoire qu'un script peut reserver
memory_limit = 8M
; ajoute des restrictions et controle sur les scripts
; http://www.php.net/manual/fr/features.safe-mode.functions.php
; obsolete
;safe_mode = On
; permet de ne changer que certaines variables d'environnement
safe_mode_allowed_env_vars = PHP_
; messages d'erreur non visibles
display_errors = Off
; duree maximale d'execution d'un script en seconde
max_execution_time = 30
; permet d'eviter l'execution de scripts distants
allow_url_fopen = Off
; ajoute des quotes pour empecher certaines injections sql
magic_quotes_gpc = On
; ne pas indiquer la presence de PHP dans entete HTTP
expose_php = Off
; enregistrer les erreurs
log_errors = On
; journal des erreurs
error_log = /var/log/php.log
; desactiver des fonctions dangereuses
disable_functions = exec, shell_exec, system, passthru, putenv, popen
; specifie si uploads possibles ou non
file_uploads = On
; la taille maximale des uploads
upload_max_filesize = 2M
; repertoire temporaire pour les uploads
upload_tmp_dir = /tmp/php/
\end{verbatim}
~\\
Lien~: \url{http://www.php.net/manual/fr/features.safe-mode.functions.php}\\
~\\
Malgré l'intégration du moteur Zend (parseur de code), certains "optimiseurs" peuvent accélérer l'exécution de script PHP en optimisant code, cache, etc.
~\\
Zend Optimizer \\
Eaccelerator \\
APC\\
~\\
Les problèmes de sécurité en relation avec PHP proviennent bien souvent d'erreurs de code. Ils concernent donc principalement les scripts du type PHP-Nuke, PHPBB2, etc. Néanmoins, PHP peut comporter des failles de sécurité. Outre l'utilisation des fonctionnalités disponibles dans la configuration de PHP, il existe des patches comme hardened-php qui permettent d'éviter certains problèmes. Le suivi des listes de sécurité et la mise-à-jour de PHP reste indispensable.\\
Liens~:\\
\url{http://www.hardened-php.net/}\\
\url{http://www.phpsecure.info}\\
~\\
\textbf{Exécution de scripts en mode de commande :}
~\\
\textit{list.php}
\begin{verbatim}
<?php echo "Hello World\n"; ?>
$ php /tmp/php.php
X-Powered-By: PHP
Content-type: text/html
bonjour
\end{verbatim}
~\\
\subsection{Utilisation avec Apache}
Module mod\_php5\\
~\\
LoadModule php5\_module /usr/lib/apache2/modules/libphp5.so\\
~\\
\texttt{
<IfModule mod\_php5.c>\\
AddType application/x-httpd-php .php .html .phtml .php5\\
AddType application/x-httpd-php-source .phps\\
</IfModule>\\
}
On vérifie avec le script PHP suivant :\\
~\\
\texttt{echo "<?php phpinfo(); ?>" > /var/www/info.php}
~\\
\section{Base de programmation}
Il existe de nombreuses extensions de PHP (MySQL, PostGreSQL, LDAP, FTP, IMAP, GD, XML, etc.) et également des bibliothèques dont la plus connue est PEAR (PHP Extension and Application Repository) qui comprend classes et librairies mais introduit également un style de codage.\\
~\\
Liens :\\
\url{http://www.nexen.net/docs/php/} \\
\url{http://pear.php.net/}\\
\url{http://pecl.php.net/}\\
\url{http://www.lephpfacile.com/manual\_pear/index.php}\\
\url{http://gtk.php.net/}\\
~\\
% open_basedir

833
support/samba.tex Normal file
View file

@ -0,0 +1,833 @@
% Copyright (c) 2004-2010 Evolix <info@evolix.fr>
% Permission is granted to copy, distribute and/or modify this document
% under the terms of the GNU Free Documentation License, Version 1.2
% or any later version published by the Free Software Foundation;
% with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
% A copy of the license is included at http://www.gcolpart.com/howto/fdl.html
\chapter{Samba}
\section{Présentation}
SAMBA est un logiciel libre qui met en oeuvre des services de type partage de fichiers ou d'imprimante pour des clients SMB/CIFS. Il permet une interopératibilité entre les serveurs Linux/Unix et les clients Microsoft Windows.\\
~\\
\textbf{SMB (\textit{Server Message Block})} est un protocole réseau pour le partage fichiers, imprimantes, ports séries entre différentes machines. Inventé à l'origine par IBM, il fut repris et largement modifié par Microsoft. Il est renommé en CIFS en 1998. \textbf{CIFS (\textit{Common Internet File System})} est le successeur du protocole réseau SMB apportant son lot de nouvelles fonctionnalités : liens, fichiers de grande taille, etc.\\
SMB/CIFS utilise depuis le début des implémentations de NetBIOS (NetBEUI, NBT). NBT (NetBIOS over TCP/IP), décrit dans les RFC 1001\footnote{http://www.ietf.org/rfc/rfc1001.txt} et 1002\footnote{http://www.ietf.org/rfc/rfc1002.txt}, est désormais utilisé sur les machines Windows 2000, XP et 2003 Server.\\
SMB/CIFS utilise l'architecture client/serveur. Ainsi le client envoie par exemple, un message d'ouverture de fichier au serveur. Le serveur vérifie que la requête est légale, que les droits sont corrects puis exécute (ou non) la requête et renvoie une notification au client. Le client, grâce à la notification, connait l'état de sa demande. Parmi les nombreuses opérations disponibles (qui diffèrent selon les versions) : File access, File and record locking, Safe file caching, File change notification, Protocol negotiation, Extended file attribute handling, Batched requests, Unicode support, etc.
%NetBIOS (Network Basic Input Output System) et ses adaptations
%Name Service
%Session Service
%Datagram Service
%NBNS (NetBIOS Name Server) -> serveur WINS
%NBDD (Netbios Datagram Distribution) -> "never worked" !?
\section{Noms NetBIOS}
Chaque serveur SMB/CIFS possède un nom NetBIOS. Les noms NetBIOS sont des noms "human readable" assignés à chaque machine. D'une longueur maximale de 15 caractères, ils peuvent contenir les caractères suivants~:
\begin{verbatim}
a-z, A-Z, 0-9 et ! @ # $ % ^ & ( ) - ' { } . ~ "
\end{verbatim}
Ce sont les noms généralement visibles dans le "voisinage réseau" des systèmes Windows; un service de résolution des noms NetBIOS, comparable au service DNS, permet l'utilisation directe de ces noms.\\
Chaque client s'annonce/recherche en "broadcast" sur son sous-réseau et/ou communique avec un serveur de noms NetBIOS (NBNS) alias serveur WINS. Ainsi on peut distinguer plusieurs modes de fonctionnement~:\\
\begin{itemize}
\item Broadcast seulement (B-Node)
\item NBNS seulement (P-Node)
\item premièrement Broadcast et NBNS seulement si aucune réponse en Broadcast (M-Node)
\item NBNS puis Broadcast uniquement si le serveur ne répond pas (H-Node)
\end{itemize}
~\\
Lien~: \url{http://www.codefx.com/CIFS\_Explained.htm}
%http://lists.nocat.net/pipermail/nocat/2004-June/005019.html
%http://www.windowsnetworking.com/kbase/WindowsTips/WindowsNT/RegistryTips/Network/TCPNetBIOSBroadcastPerformanceRegistrySettings.html
\section{Installation}
\subsection{À partir des sources}
On peut utiliser la méthode classique de recompilation à partir des sources~:
\begin{verbatim}
$ ./configure [options]
$ make
# make install
\end{verbatim}
\subsection{Par paquets}
Sous Debian, les paquets principaux à installer sont~:\\
~\\
\textbf{samba-common} : fichiers principaux pour Samba\\
\textbf{samba} : serveur SMB/CIFS\\
~\\
\emph{Quelques dépendances~:}
\begin{center}
\begin{tabular}{|c|c|}
\hline
libc6 :& librairies "GNU C"\\
\hline
libacl1 :& librairie pour les ACL (Access control list)\\
\hline
libattr1 :& librairie pour les attributs spécifiques\\
\hline
libcupsys2-gnutls10 :& librairies CUPS (Common UNIX Printing System)\\
\hline
libkrb53 :& librairies Kerberos\\
\hline
libldap2 :& librairies OpenLDAP\\
\hline
\end{tabular}
\end{center}
~\\
\section{Configuration}
On peut donc installer le logiciel Samba sur des machines Linux/Unix. Cela permet de faire passer notre machine pour un serveur SMB/CIFS sur un réseau Microsoft. Concrètement, cela offre aux machines Windows les fonctionnalités suivantes~:\\
\begin{itemize}
\item serveur de fichiers
\item partage d'imprimantes
\item serveur d'authentification
\item serveur WINS
\end{itemize}
~\\
Pour configurer Samba depuis une interface web, on peut utiliser
\texttt{swat} qui est intégré à Samba. Sous Debian, on devra installer
le paquet \texttt{swat} et activer le service grâce au superserveur
\texttt{inetd}. Pour cela, il faut décommenter une ligne dans le fichier
\texttt{/etc/inet.conf} ~:
\begin{verbatim}
# update-inetd --enable swat
\end{verbatim}
On aura donc la ligne suivante dans le fichier \texttt{/etc/inet.conf}~:
\begin{verbatim}
swat stream tcp nowait.400 root /usr/sbin/tcpd /usr/sbin/swat
\end{verbatim}
On peu également utiliser \texttt{xinetd} et on aura dans le fichier \texttt{xinet.conf}~:
\begin{verbatim}
service swat
{
port = 901
socket_type = stream
wait = no
only_from = localhost
user = root
server = /usr/sbin/swat
log_on_failure += USERID
disable = no
}
\end{verbatim}
Et l'on pourra se connecter à l'interface grâce à un navigateur web sur l'adresse \textit{http://serveur-samba:901} et en précisant son mot de passe \textit{root}. Notons que l'on peut restreindre les postes qui peuvent se connecter (notamment par \texttt{iptables}) ou encore sécuriser la connexion en utilisant \texttt{stunnel}.\\
~\\
On notera que l'utilisation de swat peut être incompatible avec
certaines configurations, sous peine de perdre une partie du fichier de
configuration \texttt{smb.conf}.\\
~\\
On peut également utiliser le module Samba de Webmin\footnote{\url{http://www.webmin.com/}} (paquet \texttt{webmin-samba}) qui permet également une configuration par interface graphique.\\
~\\
Ces interfaces de configuration ne font que modifier automatiquement le fichier de configuration principal qui est \texttt{smb.conf}. Afin de maîtriser complètement la configuration et éventuellement accéder à des options non disponibles depuis une interface graphique, on éditera \texttt{smb.conf} pour y spécifier les options qui nous conviennent.
\subsection{Serveur de fichiers}
Pour une utilisation en serveur de fichiers avec authentification, on utilisera la configuration suivante~:
\begin{verbatim}
[global]
workgroup: NOM_DOMAINE
netbios name: NOM_MACHINE
server string: Mon ptit serveur samba
security = user
guest account = nobody
[public]
comment = Partage public
path = /samba/tmp
public = yes
browseable = yes
writable = yes
\end{verbatim}
Pour ne pas avoir d'authentification, il suffira de changer l'option "security = user" (orienté authentification) en "security = share" (orienté partage public). Une autre option disponible est "security = domain" qui s'utilise si le serveur Samba est client d'un autre contrôleur de domaine.\\
\textbf{Remarque~:} en mode USER, un mot de passe sera demandé depuis Windows pour tous les partages (même "guest ok"). On peut éviter cela en utilisant l'option "map to guest". Notez que cette option n'est pas nécessaire pour les clients "smblient" qui n'auront pas besoin de mot de passe en mode USER pour les partages publics~!\\
Il reste ensuite à gérer les droits en se servant des droits UNIX et des options relatives aux droits pour les partages (public, writeable, read only, create mode, write list, etc.) Bien noter que les droits UNIX sont prioritaires sur les droits Samba.
\subsection{Contrôleur de domaine}
L'utilisation de Samba en tant que contrôleur de domaine permet de centraliser les authentifications pour les ouvertures de session Windows. Il peut également permettre de stocker les profils utilisateurs.\\
Pour gérer uniquement les authentifications pour les sessions, on utilisera la configuration suivante~:\\
\begin{verbatim}
[global]
workgroup = SAMBATEST2
netbios name = MACHINE2
server string = bla
security = user
guest account = nobody
domain logons = yes
preferred master = yes
logon path =
logon home =
\end{verbatim}
Attention, il faut ajouter chaque machine que l'on veut joindre au domaine (voir plus bas).\\
~\\
On gérera donc les utilisateurs directement sur le serveur Samba (voir plus bas). On pourra bien sûr utiliser en plus des partages de fichiers, sachant que l'authentification de session sera utilisée pour accéder à ces partages (donc pas de login ni mot de passe à retaper).\\
Note~: un message d'avertissement peut-être affiché lors de la première connexion d'un utilisateur. Il signale simplement qu'aucun répertoire utilisateur n'est présent localement et qu'il va en créer un.\\
Pour gérer le stockage des profils utilisateurs, on ajoutera des partages pour stocker ces répertoires. Attention, la gestion des profils pour Windows 9x/Me diffère de NT/200x/XP. On utilisera la configuration suivante~:\\
\begin{verbatim}
[global]
workgroup = SAMBATEST2
netbios name = MACHINE2
server string = bla
security = user
guest account = nobody
domain logons = yes
preferred master = yes
logon path = \\%L\ntprofiles
logon home = \\%L\9xprofiles
logon script = %U.bat
[netlogon]
comment = Repertoires scripts
path = /samba/netlogon
browseable = No
[9xprofiles]
comment = Profils Windows 9x
path = /samba/9xprofiles/%U
browseable = No
read only = No
[ntprofiles]
comment = Profils Windows NT
path = /samba/ntprofiles/%U
browseable = No
read only = No
\end{verbatim}
On pourra lancer un script à la connexion d'un utilisateur avec l'option "logon script". Ce script peut même être différent selon les utilisateurs (par exemple en le nommant "\%U.bat")
\section{Gestion des utilisateurs}
%NTLM : http://davenport.sourceforge.net/ntlm.html
%=> en gros, client envoie son mot de passe au serveur pour s'authentifier
%NTLM remplacé par Kerberos depuis Windows 2000 (mais toujours présent)
%http://www.microsoft.com/windows2000/techinfo/howitworks/security/kerberos.asp
%http://www.windowsitlibrary.com/Content/617/06/1.html
La gestion des utilisateurs au niveau de Samba peut se faire de différentes façons~: fichier smbpasswd, stockage TDB, serveur MySQL, annuaire LDAP, NIS+, etc. On spécifie ce choix grâce à l'option "passdb backend" qui permet ainsi respectivement smbpasswd, tdbsam, mysql, ldapsam, nisplussam. Par défaut, c'est smbpasswd.\\
~\\
On pourra administrer la base de données d'utilisateurs avec la commande "pedit" (uniquement accessible à root) ou "smbpasswd" (semblable à la fameuse commande "passwd")~.\\
Exemples~:
\begin{verbatim}
# smbpasswd -a user
# pdbedit -L -v user
\end{verbatim}
\subsection{Utilisation avec smbpasswd ou tdbsam}
Les utilisateurs SAMBA doivent être des utilisateurs UNIX si l'on choisit l'option smbpasswd (par défaut) ou tdbsam. Ils pourront ainsi avoir un mot de passe différent du compte UNIX pour Samba.\\
Avec smbpasswd, ils seront stockés dans un fichier de mots de passe ressemblant à \textit{/etc/passwd}.\\
~\\
Exemple de fichier \texttt{smbpasswd}~:
\begin{verbatim}
nobody:65534:NO PASSWORDXXXXXXXXXXXXXXXXXXXXX:
NO PASSWORDXXXXXXXXXXXXXXXXXXXXX:[NU ]:LCT-00000000:
Administrator2:0:01FC5A6BE7BC6929AAD3B435B51404EE:
0CB6948805F797BF2A82807973B89537:[U ]:LCT-42B1A64E:
\end{verbatim}
Avec tdbsam, il s'agira d'un fichier TDB (Trivial DataBase), c'est à dire un fichier binaire qui stocke les données. Sous Debian ce fichier est passdb.tdb dans le répertoire \texttt{/var/lib/samba/}\\
~\\
On gérera les utilisateurs grâce à la commande \texttt{smbpasswd}.
Ainsi, \texttt{smbpasswd -a user} ajoute l'utilisateur user à la base d'utilisateurs Samba. La commande \texttt{smbpasswd -d user} désactive l'utilisateur user; \textbf{-e} réactive ou encore \textbf{-n} met un mot de passe nul (si c'est possible grâce à l'option \textit{null passwords = yes}).
\subsection{Gestion des machines}
Toute machine devant être intégrée au domaine doit être ajoutée. La machine sera gérée comme un utilisateur spécial~: elle sera donc stockée de la même façon que les utilisateurs. Il suffit tout simplement de préciser qu'il s'agit d'une machine.\\
Si l'on gère les utilisateurs avec smbpasswd ou tdbsam, on pourra ajouter un groupe UNIX spécifique au système.\\
Exemple d'ajout d'un machine pour une authentification smbpasswd ou tdbsam~:
\begin{verbatim}
# addgroup pcwin
# adduser --ingroup pcwin --shell /dev/false --no-create-home \
--force-badname nom_client$
# smbpasswd -m -a nom_client$
\end{verbatim}
\subsection{Utilisation avec OpenLDAP}
~\\
Sur le serveur OpenLDAP, il faut ajouter un schéma spécifique. Ainsi dans le fichier \texttt{slapd.conf}~:
\begin{verbatim}
include /etc/ldap/schema/samba.schema
index cn pres,sub,eq
index sn pres,sub,eq
## required to support pdb_getsampwnam
index uid pres,sub,eq
## required to support pdb_getsambapwrid()
index displayName pres,sub,eq
index sambaSID eq
index sambaPrimaryGroupSID eq
index sambaDomainName eq
index default sub
\end{verbatim}
On n'oublie pas de lancer \texttt{slapindex} et de relancer OpenLDAP.
\begin{verbatim}
# slapindex -f slapd.conf && /etc/init.d/slapd restart
\end{verbatim}
Notons que sous Debian, le schema \texttt{samba.schema} se trouve dans le paquet \textit{samba-doc}
Sur le serveur Samba, il faut avoir un fichier \texttt{smb.conf} ressemblant à~:
\begin{verbatim}
passdb backend = ldapsam:ldap://127.0.0.1
ldap admin dn = "cn=Manager,dc=evolix,dc=net"
ldap suffix = dc=evolix,dc=net
ldap filter = (uid=%u)
ldap delete dn = no
ldap user suffix = ou=People
ldap group suffix = ou=Groups
ldap machine suffix = ou=Computers
ldap passwd sync = yes
obey pam restrictions = no
\end{verbatim}
Si l'on utilise un utilisateur LDAP pour se connecter au serveur OpenLDAP, on stocke son mot de passe de la façon suivante~:
\begin{verbatim}
# smbpasswd -w <pass-bind-LDAP>
\end{verbatim}
Il faut maintenant stocker les données Samba (utilisateurs, groupes, machines) sur le serveur OpenLDAP. Il est notamment important de connaître le "Domain SID" du serveur Samba. On l'obtient en faisant~:
\begin{verbatim}
# net rpc info
\end{verbatim}
~\\
(ou \texttt{net getlocalsid})
~\\
Dans un premier temps, on va créer les branches LDAP qui vont accueillir les données Samba. On crée donc un fichier \texttt{create.ldif}~:
\begin{verbatim}
dn: ou=People,dc=evolix,dc=net
objectclass: top
objectclass: organizationalUnit
ou: People
dn: ou=Groups,dc=evolix,dc=net
objectclass: top
objectclass: organizationalUnit
ou: Groups
dn: ou=Computers,dc=evolix,dc=net
objectclass: top
objectclass: organizationalUnit
ou: Computers
\end{verbatim}
Voici les données pour avoir un groupe UNIX et Samba dans l'annuaire LDAP :\\
\texttt{groups.ldif}~:
\begin{verbatim}
dn: cn=Domain Admins, ou=Groups, dc=evolix, dc=net
sambaSID: S-1-5-21-982778770-3942000634-2231700997-512
gidNumber: 512
displayName: Domain Admins
sambaGroupType: 2
memberUid: Administrator
memberUid: Administrator2
description: Netbios Domain Administrators
objectClass: posixGroup
objectClass: sambaGroupMapping
cn: Domain Admins
\end{verbatim}
Ensuite, voici les données pour avoir un utilisateur UNIX et Samba dans l'annuaire LDAP :\\
\texttt{user.ldif}~:
\begin{verbatim}
dn: uid=user, ou=People, dc=evolix, dc=net
sambaLMPassword: 01FC5A6BE7BC6929AAD3B435B51404EE
sambaPrimaryGroupSID: S-1-5-21-982778770-3942000634-2231700997-513
displayName: System User
sambaLogonScript: user.cmd
objectClass: inetOrgPerson
objectClass: posixAccount
objectClass: sambaSamAccount
objectClass: shadowAccount
objectClass: top
userPassword:: e1NTSEF9ZzJENnA1MWdGdHN3M3JwcWpXeDFLTEM2OS9veU5UY3U=
sambaLogonTime: 0
sambaHomeDrive: H:
uid: user
uidNumber: 1001
cn: user
sambaLogoffTime: 2147483647
sambaPwdLastSet: 1118938985
sambaAcctFlags: [U]
loginShell: /bin/bash
sambaProfilePath: \\%L\profiles\user
gidNumber: 1000
sambaPwdMustChange: 1127492585
sambaNTPassword: 0CB6948805F797BF2A82807973B89537
sambaPwdCanChange: 0
gecos: System User
sambaSID: S-1-5-21-982778770-3942000634-2231700997-7002
description: System User
homeDirectory: /home/user
sambaKickoffTime: 2147483647
sn: user
sambaHomePath: \\%L\homes\user
\end{verbatim}
Enfin voici les données pour avoir une machine UNIX et Samba dans l'annuaire LDAP.\\
\texttt{pc.ldif}~:
\begin{verbatim}
dn: uid=my-pc$, ou=Computers, dc=evolix, dc=net
sambaPrimaryGroupSID: S-1-5-21-982778770-3942000634-2231700997-2201
displayName: MY-PC$
objectClass: top
objectClass: inetOrgPerson
objectClass: posixAccount
objectClass: sambaSamAccount
uid: my-pc$
uidNumber: 1000
cn: my-pc$
sambaPwdLastSet: 1120480412
loginShell: /bin/false
sambaAcctFlags: [W ]
gidNumber: 600
sambaPwdMustChange: 2147483647
sambaPwdCanChange: 1120480412
sambaNTPassword: 1429C7104734306334FA33DD43642F60
gecos: Computer
sambaSID: S-1-5-21-982778770-3942000634-2231700997-3000
description: Computer
homeDirectory: /dev/null
sn: my-pc$
\end{verbatim}
Pour gérer cela de façon plus conviviale, on peut utiliser \texttt{smbldap-tools}, un ensemble de scripts qui permet d'initialiser et administrer les utilisateurs, groupes et machines. Les fichiers de configuration sont \texttt{smbldap.conf} et \texttt{smbldap\_bind.conf}.\\
\texttt{smbldap.conf}~:
\begin{verbatim}
SID="MON-SID"
suffix="dc=evolix,dc=net"
usersdn="ou=People,${suffix}"
computersdn="ou=Computers,${suffix}"
groupsdn="ou=Groups,${suffix}"
[...]
\end{verbatim}
\texttt{smbldap\_bind.conf}~:
\begin{verbatim}
masterDN="cn=Manager,dc=evolix,dc=net"
masterPw="XXX"
\end{verbatim}
On peut ensuite faire fontionner le script d'initialisation~:
\begin{verbatim}
# smbldap-populate
\end{verbatim}
Ce script crée un certain nombre d'utilisateurs (Administrator, nobody), de groupes (Administrators, Backup Operaters, Domain Admins, Domain Guests, Domain Users, Print Operators, Replicators) et de branches (Computers, Groups, Idmap, People, sambaDomainName).\\
~\\
Pour ajouter un utilisateur et vérifier ses données~:\\
~\\
\begin{verbatim}
# smbldap-useradd -a user
# smbldap-usershow user
\end{verbatim}
Un certain nombre d'options sont facultatives et permettent d'ajouter des précisions par rapport aux directives du fichier \texttt{smb.conf}~: \textit{userSmbHome} pour \texttt{logon home}, \textit{userProfile} pour \texttt{logon path}, \textit{userScript} pour \texttt{logon script} et \textit{userHomeDrive} pour \texttt{logon drive}.\\
~\\
Ajout d'une machine~:
\begin{verbatim}
# smbldap-useradd -w my-pc2$
\end{verbatim}
Ajout d'un groupe~:
\begin{verbatim}
# smbldap-groupadd -a group
\end{verbatim}
\section{Intégration des clients Windows}
\subsection{Windows 98}
Mettre "Ouvrir la session sur un domaine Windows NT" dans la boîte "Client pour les réseaux Microsoft".\\
~\\
La modification d'une clé de la base de registre peut parfois être nécessaire~:
\begin{verbatim}
REGEDIT4
[HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\VxD\VNETSUP]
"EnablePlainTextPassword" = dword:00000001
\end{verbatim}
\subsection{Windows NT 4}
Il faut parfois modifier la clé de la base de registre suivante~:
\begin{verbatim}
REGEDIT4
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Rdr\Parameters]
"EnablePlainTextPassword" = dword:00000001
\end{verbatim}
\subsection{Windows 2000}
Selon les cas, une clé de la base de registre peut devoir être changée~:
\begin{verbatim}
REGEDIT4
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet001\Services\LanmanWorkstation\Parameters]
"EnablePlainTextPassword" = dword:00000001
\end{verbatim}
Modifier le domaine puis mettre login/passwd d'un utilisateur avec l'UID UNIX égal à 0.\\
\subsection{Windows XP}
Notons tout d'abord que la version \textit{Home edition} ne permet pas de se joindre à un domaine. Ensuite, l'intégration se passe comme avec \textit{Windows 2000} à l'exception près que la modification de la clé de la base de registre soit souvent être modifiée.\\
~\\
Pour Windows XP SP1, une clé de la base de registre doit parfois être modifiée~:
\begin{verbatim}
REGEDIT4
[HKEY_LOCAL_MACHINE\SYSTEM\ControlSet001\Services\Netlogon\Parameters]
"requiresignorseal" = dword:00000000
\end{verbatim}
D'autres clés doivent éventuellement être modifiées mais la nécessité semble aléatoire selon les installations de Windows.\\
\textit{Lien~:}
\url{http://www.gcolpart.com/howto/samba.php4}\\
\section{Options avancées de Samba}
\subsection{section [global]}
\begin{verbatim}
# nom du domaine
workgroup = SAMBATEST
# nom NetBIOS
netbios name = MASTER
# aliases NetBIOS
netbios aliases = BOSS
# NT Description
server string = %h server (Samba %v)
# serveur WINS
wins support = yes
time server = yes
;wins server = w.x.y.z
dns proxy = no
name resolve order = wins host lmhosts bcast
;disable netbios = yes
# logs
log file = /var/log/samba/log.%m
max log size = 1000
log level = 2
; syslog only = no
syslog = 0
panic action = /usr/share/samba/panic-action %d
# authentification
security = user
passdb backend = tdbsam
null passwords = no
obey pam restrictions = no
encrypt passwords = true
guest account = nobody
invalid users = root
# PDC
# local master server (sinon elections)
local master = yes
# niveau pour les "master elections"
os level = 33
# domain master server (ne pas utiliser si déjà NT DC)
domain master = yes
# serveur auth pour clients Win95
domain logons = yes
# force an election on startup
preferred master = yes
# serveur WINS
wins support = Yes
# NT time server
time server = Yes
logon path = \\%L\ntprofiles
logon home = \\%L\9xprofiles
logon script = %U.cmd
# réseau
socket address = 192.168.2.34
socket options = TCP_NODELAY
SO_RCVBUF=8192 SO_SNDBUF=8192
;hosts allow = 192.168.0. EXCEPT 192.168.0.35
;hosts deny = ALL
# partage
preserve case = yes
short preserve case = yes
case sensitive = no
;acl compatibility = Auto
;nt acl support = yes
veto files = /*Security*/*.tmp/*root*/
\end{verbatim}
\subsection{section [partage]}
Options disponibles pour un partage~:
\begin{verbatim}
[partage]
path = /bla/bla
browseable = no
guest ok = no
read only = yes
writeable = no
read list = @smbgroup
write list = root
valid users = @sambausers @smbgroup root
;invalid users =
only user = no
admin users =
;force user = nobody
;force group =
;create mode = 774
;directory mode = 2774
create mask =
directory mask =
security mask =
force create mode =
force directory mode =
force directory security mode =
force security mode =
hide unreadable = yes
hide unwriteable files = yes
;nt acl support =
;inherit permissions = yes
;inherit owner = yes
;inherit acls = yes
case sensitive
default case
short preserve case
fake oplocks
dos filetimes
dos filetime resolution
veto files
hide dot files
hide files
\end{verbatim}
Voici différents partages~:\\
~\\
\textbf{partage public}
\begin{verbatim}
[public]
path = /samba/public
browseable = yes
writeable = yes
create mode = 777
directory mode = 777
\end{verbatim}
\textbf{partage pour un groupe}
\begin{verbatim}
[groupe]
path = /samba/groupe
browseable = yes
writeable = yes
create mode = 770
directory mode = 770
\end{verbatim}
\textbf{partage uniquement accessible à un utilisateur en lecture}
\begin{verbatim}
[backup]
path = /home
browseable = no
writable = no
admin users = backup
valid users = backup
\end{verbatim}
\section{Clients SMB/CIFS pour Unix/Linux}
%\url{http://jcifs.samba.org/}
Une machine Unix/Linux peut aussi se comporter en tant que client SMB/CIFS. Le serveur pourrait aussi bien être un serveur Samba qu'une machine Windows. Sous Linux, cela se fait en utilisant conjointement le module SMBFS du noyau (éventuellement téléchargeable séparamment) et des outils supplémentaires (il en existe plusieurs) que nous allons passer en revue ci-dessous~:
~\\
\textbf{Paquet samba (ou samba-common)}
\begin{verbatim}
/usr/bin/smbclient : client SMB/CIFS FTP-like
/usr/bin/smbtar : backup de partages SMB/CIFS
/usr/bin/rpcclient : outil pour exécuter des fonctions MS-RPC
/usr/bin/smbspool : client d'imprimante SMB
/usr/bin/smbtree : navigateur SMB/CIGS en mode texte
/usr/bin/smbcacls : manipulation des ACLs
/usr/bin/smbcquotas : manipulation des quotas
/usr/bin/net : outil d'aministration de serveurs SMB/CIFS distants
\end{verbatim}
\textbf{Utilisation}~:
~\\
Lister les partages disponibles~:
\begin{verbatim}
# smbclient -L MY-PC -U Administrateur
\end{verbatim}
Connexion à un partage~:
\begin{verbatim}
# smbclient //MY-PC/blabla -U Administrateur
\end{verbatim}
On peut utiliser des commandes FTP comme ls, cd, lcd, get, put, etc.\\
~\\
Si il s'agit d'une imprimante, on peut imprimer un fichier Postscript en
utilisant la commande :
\begin{verbatim}
> print fichier.ps
\end{verbatim}
Changement de mot de passe~:
\begin{verbatim}
# smbpasswd -r MY-PC -U Administrateur
\end{verbatim}
Sauvegarde et restauration de partage Windows~:
\begin{verbatim}
# smbtar -v -s MY-PC -x "blabla" -u Administrateur -p pass
# smbtar -v -r -s MY-PC -x "blabla" -u Administrateur -p pass
\end{verbatim}
Lister utilisateurs, groupes, heure distante, reboot, etc~:
\begin{verbatim}
# /usr/bin/net -I 192.168.4.109 -U Administrateur user
# /usr/bin/net -I 192.168.4.109 -U Administrateur group
# /usr/bin/net -I 192.168.4.109 -U Administrateur time
# /usr/bin/net -I 192.168.4.109 -U Administrateur rpc SHUTDOWN
\end{verbatim}
\textbf{Paquet smbfs}
\begin{itemize}
\item /sbin/mount.cifs : monter les partages CIFS
\item /usr/bin/smbmount : monter les partages SMB
\item /usr/bin/smbumount : démontage partages SMB
\item /usr/bin/smbmnt : outil d'aide pour les montages SMB
\end{itemize}
~\\
\textbf{Utilisation}~:
\begin{verbatim}
# mount -t smbfs //MY-PC/blabla /mnt/partage -o username=Administrateur
# umount /mnt/partage
# smbmount //MY-PC/blabla /mnt/partage
# smbumount /mnt/partage
\end{verbatim}
D'autres outils, notamment des outils graphiques utilisant les commandes précédentes, permettent de faire un certain nombre de manipulations avec un serveur SMB/CIFS.\\
\begin{itemize}
\item xsmbrowser (smbclient) : client graphique
\item linneighborhood (smbclient ou smbfs) : client graphique
\item komba2 (smbclient ou smbfs) : client KDE graphique
\item smb4k (smbclient ou smbfs) : client KDE graphique
\item tksmb (smbclient ou smbfs) : client graphique en Tk
\item jags (smbclient ou smbfs) : client graphique en GTK
\end{itemize}
~\\
Il existe également un certain nombre d'outils associés à Samba~:\\
\begin{itemize}
\item smbc (libsmbclient) : commande en mode texte
\item smbget (libsmbclient) : outil Wget-like
\item smb2www (smbclient) : client permetant l'accès depuis une
application tierce
\item smb-nat (outil) : outil de sécurité pour serveur SMB/CIFS
\end{itemize}
%\url{http://people.via.ecp.fr/~alexis/formation-linux/samba.html}

945
support/securite.tex Normal file
View file

@ -0,0 +1,945 @@
% Copyright (c) 2004-2010 Evolix <info@evolix.fr>
% Permission is granted to copy, distribute and/or modify this document
% under the terms of the GNU Free Documentation License, Version 1.2
% or any later version published by the Free Software Foundation;
% with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
% A copy of the license is included at http://www.gcolpart.com/howto/fdl.html
\chapter{Administration Système et Sécurité}
La sécurité informatique englobe non seulement la sécurité réseau pour se prémunir d'attaque locale ou extérieure, mais également la sécurité physique, la gestion des utilisateurs, des droits, des journaux et des sauvegardes.\\
\section{Sécurité physique}
\textbf{Au niveau des infrastructures} \\
~\\
Même si les gens ont plutôt tendance à l'oublier, la sécurité physique de la machine est très importante. Il est nécessaire qu'un disque dur ne soit pas en évidence, prêt à être volé avec toutes les informations qu'il contient. Il est important que l'alimentation d'un serveur soit protégée, et qu'il ne suffise pas juste au pirate de débrancher le cordon à la prise pour que des dizaines de couches de sécurité logicielles soient anéanties.\\
\textbf{Au niveau de l'utilisation} \\
~\\
Lorsque vous tapez un mot de passe, il n'est pas superflu de vous assurer que personne ne soit penché ou dessus de votre épaule, ou qu'aucun élément d'écoute a été rajouté (keylogger logiciel ou physique).
\section{Sécurité au démarrage}
\textbf{Au niveau du BIOS} \\
~\\
Une première méthode de sécurisation consiste à autoriser uniquement le disque dur à démarrer. Il faut aussi définir un mot de passe au niveau du BIOS empêchant de changer les paramètres de ce dernier pour un démarrage sur un autre périphérique dans l'espoir de pouvoir ensuite avec différents outils accéder aux données du disque dur.\\
Il est également possible d'avoir des protections complexes, comme une authentification mutuelle entre le BIOS et le disque, mais ces protections sont rarement mises en place.\\
\textbf{Au niveau du Boot Loader}\\
~\\
\emph{Lilo}\\
Le fichier de configuration principal est lilo.conf (\textit{/etc/lilo.conf})\\
Dans ce fichier la possibilité est donnée de mettre en place un mot de passe par l'ajout de la ligne : \texttt{password = motdepasse}.
A remarquer que contrairement à grub que l'on va décrire, une modification de lilo.conf pour être prise en compte doit être suivie de la commande \texttt{\#lilo} exécutée en tant que root.\\
~\\
\emph{Grub}\\
De même que précedemment il est possible avec grub d'ajouter un mot de passe qui peut même être crypté~:\\
\\
Lancer le shell GRUB~:\\
~\\
\texttt{\# grub}\\
\texttt{grub> md5crypt}\\
~\\
entrez votre mot de passe :\\
\\
Password: *********\\
Encrypted: {\small{\$1\$gxRBf0\$pe0rH7/nG9KPJLvc.XV7V.}}\\
~\\
puis, copiez le mot de passe crypté dans votre fichier de configuration \texttt{/boot/grub/menu.lst}~:
\begin{verbatim}
password --md5 $1$gxRBf0$pe0rH7/nG9KPJLvc.XV7V.
\end{verbatim}
L'argument password peut être utilisé pour restreindre certaines entrées; dans ce cas il est inséré juste sous la ligne "title" à démarrer. \\
~\\
Dans le fichier \textit{/etc/inittab} permet à un utilisateur physique de redémarrer la machine. Vous pouvez donc supprimer cette ligne~:\\
\texttt{ca:12345:ctrlaltdel:/sbin/shutdown -t1 -a -r now}
~\\
Pour demander à init (le processus d'initialisation) de réexaminer \texttt{/etc/inittab}, faire~:\\
\texttt{\# init q} \\
~\\
Néanmoins, malgré toutes ces protections possibles, il faut considérer qu'avoir un accès physique à une machine permet d'en faire ce que l'on veut. C'est pourquoi on se contente souvent des protections basiques comme fermer la salle des machines à clé, mettre en place des cadenas sur les boitiers ou encore avoir un système de vidéosurveillance. \\
\section{Authentification}
Le fichier \texttt{/etc/passwd} contient la liste des utilisateurs avec le mot de passe chiffré. Ainsi lors de la procédure d'authentification d'un utilisateur, le système teste si le chiffrement du mot de passe entré correspond au mot de passe chiffré (\texttt{/etc/passwd} est accessible en lecture aux utilisateurs). Il est souhaitable d'utiliser l'algorithme de chiffrement MD5 pour chiffrer les mots de passe. Il est également conseillé d'utiliser l'authentification shadow. Avec cette authentification, les mots de passe du fichier /etc/passwd sont remplacés par 'x' et sont stockés dans le fichier \texttt{/etc/shadow}, inaccessible en lecture aux utilisateurs. D'autres méthodes d'authentification locale existent comme sous OpenBSD\footnote{\url{http://openbsd.org/}} mais l'utilisation de la méthode shadow est répandue sur les distributions Linux. Il faut bien avoir conscience que cela repose sur la solidité de l'algorithme de chiffrement\footnote{\url{http://evolix.org/man/crypt.html}}.\\
Le fichier \texttt{/etc/group} stocke la liste des groupes, c'est-à-dire des entités regroupant plusieurs utilisateurs et permettant de donner à ce groupe d'utilisateurs les mêmes droits sur des fichiers. Un utilisateur peut connaître les groupes auxquels il appartient en tapant la commande \texttt{groups} ou encore \texttt{id}.\\
Le fichier /etc/adduser.conf contient les valeurs par défaut pour les programmes \textit{adduser} \textit{addgroup} \textit{deluser} et \textit{delgroup}. Chaque option est de la forme option = valeur. Les simples ou doubles guillemets sont autorisés autour de la valeur. Les lignes de commentaires doivent avoir un caractère dièse (\#) au début de la ligne.\\
~\\
Exemple~:\\
\texttt{
DSHELL=/bin/bash\\
DHOME=/home\\
SKEL=/etc/skel\\
QUOTAUSER="forquota"\\
DIR\_MODE=0755\\
}\\
~\\
Le répertoire /etc/skel/ contient le profil par défaut qui sera copié dans le répertoire personnel d'un nouvel utilisateur. Il contient souvent les fichiers .bashrc, .bash\_profile, etc. Pour configurer un profil pour les utilisateurs, on ajoutera des fichiers dans /etc/skel (par exemple des boites à mail, paramètres pour certaines applications, etc.)\\
~\\
La gestion des utilisateurs se fait grâce aux commandes adduser et addgroup. Notez bien que les commandes useradd, groupadd, userdel et groupdel ont une syntaxe différente et n'utilisent pas forcément les mêmes configurations.\\
~\\
Exemple~:\\
\begin{verbatim}
# addgroup --gid 107 student}
# adduser --home /home/jean --shell /bin/bash
--uid 1057 --ingroup student jean
\end{verbatim}
~\\
L'utilisation d'un mot de passe aléatoire contenant des lettres majuscules et minuscules, des chiffres et des caractères spéciaux (au total plus de 8 caractères) est fortement recommandée.\\
Toute trace écrite devra être bannie si possible surtout pour un administrateur - c'est son boulot ;) - à l'exception d'endroits sécurisés (coffre-fort, banque, etc.) accessibles par des supérieurs hiérarchiques. Une procédure en cas d'accident corporel de l'administrateur pourra être mise en place.\\
~\\
Pour les mots de passe utilisateurs, il peut être utile d'empêcher les mots de passe trop simples (cracklib) et de faire tourner des crackeurs de mots de passe afin de vérifier en permanence qu'aucun utilisateur n'a un mot de passe trop simple etc.\\
~\\
Voici quelques programmes de génération de mot de passe aléatoire disponibles sous Debian~:\\
\texttt{otp} \texttt{apg} \texttt{makepasswd} \texttt{pwgen}\\
~\\
Il existe également des outils pour tenter de cracker les mots de passe. L'un des plus connu est le programme \texttt{john} qu'il est intéressant de faire tourner régulièrement afin de détecter si des utilisateurs ont des mots de passe trop simples.
~\\
\section{Quotas}
Il est souvent intéressant de définir des quotas~:\\
~\\
\emph{Configuration du noyau :} CONFIG\_QUOTA \\
~\\
Ajoutez les options \textit{usrquota} et \textit{grpquota} pour les partitions concernées dans le fichier \textit{/etc/fstab}~:\\
{\small \texttt{/dev/hdc8 /home ext3 rw,nosuid,nodev,exec,nouser,auto,async,usrquota,grpquota 0 2}}\\
~\\
\texttt{\# touch /home/aquota.user /home/aquota.group}\\
\texttt{\# chmod 600 /home/aquota.* \&\& chown root:root /home/aquota.*}\\
\texttt{\# mount -v -o remount /home}\\
\texttt{\# aptitude install quota quotatool -> warnquota}\\
\texttt{\# update-rc.d -f quotarpc remove}\\
\texttt{\# quotacheck -auvg}\\
\texttt{\# quotaon -auvg}\\
~\\
On peut maintenant créer un utilisateur qui va servir d'exemple pour les quotas des autres utilisateurs~:\\
\begin{verbatim}
# adduser --home /dev/null --shell /bin/false --ingroup nogroup --disabled-password forquota
# edquota -u forquota
\end{verbatim}
~\\
La taille d'un "block" est habituellement de 1024 octets sous Linux. Elle peut varier selon les options des systèmes de fichiers.\\
~\\
%\begin{verbatim}
%dumpe2fs /dev/myvol1-home |grep "Block size"
%\end{verbatim}
Les inodes représentent le nombre maximum de fichiers ou de répertoires que l'on pourra créer.\\
%http://lea-linux.org/admin/admin_fs/quotas.html
%http://www.enel.ucalgary.ca/People/Norman/enel315_winter1997/disk_quotas/
~\\
On pourra également définir le délai (grace period) qui définit le temps au-delà duquel la limie douce devient limite dure. On change ce délai avec la commande :\\
\texttt{\# edquota -t}\\
~\\
On peut ensuite appliquer les quotas à chaque utilisateur par la commande :\\
\texttt{\# edquota -p forquota USER}\\
~\\
On peut utiliser le fichier adduser.conf pour imposer un quota lors de la création de l'utilisateur [voir plus haut].
~\\
D'autres commandes intéressantes permettent de vérifier le bon fonctionnement des quotas (quotacheck), d'envoyer des messages d'avertissement aux utilisateurs dépassant la limite douce (warnquota) et de générer des statistiques:\\
\texttt{\# repquota -ugva}\\
~\\
Note :\\
Attention, l'utilitaire dd semble mal gérer les quotas.
Liens : \\
\url{http://www.freenix.fr/unix/linux/HOWTO/mini/Quota.html}\\
\url{http://linux.developpez.com/cours/securedeb/?page=page5\#L5.4}
\section{Gestion des droits}
Il faut maintenant définir la politique de gestion des droits de la machine, c'est-à-dire se poser la question "Qui a le droit de faire quoi~?" \\
Définissons tout d'abord les droits au niveau des données utilisateurs. Les droits par défaut sont gérés par la directive \texttt{umask}. On mettra donc, selon sa politique, dans le fichier \textit{/etc/profile} (et dans login.defs pour gérer lors de la création de l'utilisateur) :\\
~\\
\textit{umask 022} : pour que les données utilisateurs soient visibles par tous les utilisateurs\\
~\\
\textit{umask 027} : pour que les données d'un utilisateur soient visibles entre eux par les utilisateurs du même groupe\\
~\\
\textit{umask 077} : pour que seul l'utilisateur puisse lire ses fichiers par défaut\\
~\\
Il faut ensuite gérer les droits sur les périphériques. Les différents périphériques appartiennent souvent à un groupe (cdrom, audio, video, etc.) et on peut gérer les droits en ajoutant ou non les utilisateurs à ces groupes. On ne détaillera pas trop cette procédure car elle est surtout valable dans le cas où il s'agit de postes de travail accessible physiquement aux utilisateurs.\\
~\\
Il faut également penser à mettre des protections sur les répertoires et partitions accessibles à l'utilisateur (on traitera le cas des journaux systèmes à part : voir par la suite). Ces protections ne sont pas infaillibles mais constituent un premier rempart dans le cas d'attaques d'un utilisateur inexpérimenté (souvent appelés script-kiddy). Voici un exemple de protection que l'on peut mettre dans le fichier \textit{/etc/fstab}~:\\
~\\
\begin{verbatim}
/dev/sda8 /tmp ext3 defaults,nodev,nosuid,noexec,usrquota,grpquota 0 2
# disques amovibles
/dev/fd0 /mnt/fd0 ext2 defaults,users,nodev,nosuid,noexec 0 0
/dev/fd0 /mnt/floppy vfat defaults,users,nodev,nosuid,noexec 0 0
/dev/hdc /mnt/cdrom iso9660 ro,users,nodev,nosuid,noexec 0 0
\end{verbatim}
Remarque~: certains paquets (screen, PostgreSQL, etc.) nécessitent d'exécuter un script dans \textit{/tmp/}. On fera donc~:
\begin{verbatim}
# mount -o exec,remount /tmp
\end{verbatim}
Avant d'installer des paquets, puis on refera~:
\begin{verbatim}
# mount -o remount /tmp
\end{verbatim}
Plus généralement on peut vérifier ce que peut voir un utilisateur par les commandes~:
\begin{verbatim}
$ find / -type f -a -perm +006 2>/dev/null}
$ find / -type d -a -perm +007 2>/dev/null}
\end{verbatim}
On prendra garde par exemple aux données sensibles des fichiers de configuration ou des scripts (notamment des données web). On peut par exemple voir les fichiers du répertoire /etc non visibles par un utilisateur~:
\begin{verbatim}
# find /etc -type f -a -perm 600 -a -uid 0
\end{verbatim}
\section{Gestion de l'authentification}
Nous savons comment fonctionne la procédure d'authentification [voir plus haut] mais au-delà de l'authentification, il est nécessaire d'imposer des restrictions au niveau de la procédure de login pour éviter des désagréments. Pour cela on dispose de plusieurs moyens de restreindre les accès et imposer d'autres paramètres.\\
~\\
Commençons par le fichier \texttt{/etc/login.defs} qui définit les paramètres d'authentification. Certains paramètres sont notamment importants~:
\begin{verbatim}
# delai minimum entre deux tentatives de login
FAIL_DELAY 10
# journaliser les tentatives ratées
FAILLOG_ENAB yes
# retenir les identifiants iconnus essayés
LOG_UNKFAIL_ENAB yes
# retenir les tentatives réussies
LOG_OK_LOGINS yes
# delai maximim pour authentification
LOGIN_TIMEOUT 60
\end{verbatim}
Le fichier \texttt{/etc/securetty} contient la liste des terminaux sur lesquels la connexion de 'root' est autorisée. Il est conseillé de mettre ce fichier vide afin de désactiver le login de 'root'. Seul 'su' permettra donc de devenir superutilisateur. Faire donc~:
\begin{verbatim}
# sed -e 's/^/#/' /etc/securetty > /tmp/sed
# mv /tmp/sed /etc/securetty
\end{verbatim}
~\\
\textbf{Linux-PAM}
~\\
La plupart des distributions Linux utilisent l'authentification PAM par défaut.\\
De nombreuses applications utilisent l'authentification PAM et notamment login, su qui sont assez importantes...\\
On vérifiera qu'une application utilise l'authentification PAM grâce à \texttt{ldd}\\
Ex~:
\begin{verbatim}
ldd $(which su)
\end{verbatim}
\textit{Lien~:}
\url{http://www.kernel.org/pub/linux/libs/pam/}\\
~\\
La configuration se passe dans le répertoire \texttt{/etc/pam.d/}\\
Si ce répertoire est absent, la configuration pourra avoir lieu dans un fichier unique: \texttt{/etc/ldap.conf} (ignoré sinon)\\
Chaque application est configurée dans un fichier portant son nom.\\
Le répertoire \texttt{/etc/security/} contient des fichiers de configuration sécurité pour PAM.\\
~\\
Le comportement par défaut est dans le fichier \texttt{/etc/pam.d/other}
La syntaxe des fichiers est constituée de lignes telles que :
"type" "niveau" "module" "arguments"\\
~\\
"type" peut être :\\
\begin{itemize}
\item[\textbf{auth}] : authentification
\item[\textbf{account}] : vérification des types de services autorisés
\item[\textbf{session}] : tâches à effectuer avant/après l'accès
\item[\textbf{password}] : mécanismes d'authentification
\end{itemize}
~\\
"niveau" peut être :\\
\begin{itemize}
\item[\textbf{required}] : le succès à cette étape est nécessaire
\item[\textbf{requisite}] : le succès est nécessaire et l'accès est refusé en cas d'erreur
\item[\textbf{sufficient}] : le succès à cette étape suffit
\item[\textbf{optional}] : l'accès pourra être refusé en fonction d'autres paramètres
\end{itemize}
~\\
"module":\\
(Ils se trouvent par défaut dans le répertoire /lib/security/)\\
\begin{itemize}
\item[\textbf{pam\_access.so}] : restriction d'accès avec le fichier access.conf\\
\end{itemize}
~\\
Le fichier \texttt{access.conf} permet de gérer les permissions de login (si activé dans PAM) selon la syntaxe suivante :\\
~\\
~[*] permission : users : origins
~\\
~[*] = + (accès permis) ou - (accès refusé)\\
~\\
\textbf{Exemples :}
~\\
\begin{itemize}
\item[\textit{-:mechant pasbeau:ALL}] -> les comptes mechant et pasbeau ne peuvent pas se loguer
~\\
\item[\textit{-:ALL EXCEPT admin:ALL EXCEPT LOCAL}] -> seuls admin peut se loguer à distance\\
~\\
Sur un serveur où seuls les administrateurs peuvent se connecter :
~\\
\item[\textit{-:ALL EXCEPT admin admin2:LOCAL}]
~\\
\item[\textit{pam\_deny.so}] : interdiction d'accès
~\\
\item[\textit{pam\_env.so}] : utilise les variables d'environnement de pam\_env.conf en plus du fichier /etc/environment
~\\
\item[\textit{pam\_filter.so}] : utiliser divers filtres
~\\
\item[\textit{pam\_ftp.so}] : avoir un accès de type FTP anonyme
~\\
\item[\textit{pam\_group.so}] : utilise group.conf pour imposer des restrictions selon le groupe
~\\
\item[\textit{pam\_issue.so}] : pour afficher /etc/issue lors d'un login
~\\
\item[\textit{ pam\_lastlog.so}] : donne des informations sur la dernière connexion de l'utilisateur
~\\
\item[\textit{ pam\_ldap.so}] : module pour l'authentification LDAP
~\\
\item[\textit{ pam\_limits.so }]: restrictions particulières avec le fichier limits.conf
~\\
\end{itemize}
~\\
Le fichier limits.conf permet d'imposer des limites diverses sur les groupes ou les identifiants :\\
~\\
Structure: "qui" "type" "quoi" "combien"\\
~\\
\begin{itemize}
\item[\textbf{qui}] = compte, @groupe, *
~\\
\item[\textbf{type}] = soft (soft limits) ou hard (hard limits)
~\\
\item[\textbf{quoi}] = core, data, fsize, memlock, nofile, rss, stack, cpu, nproc, as, maxlogins, priority, locks
\end{itemize}
~\\
\textbf{Exemples }:\\
\begin{verbatim}
ftpusers - maxlogins 3
@invite hard cpu 5
@users hard data 10000
\end{verbatim}
~\\
\begin{itemize}
\item[\textit{pam\_listfile.so}] : permet d'autoriser ou non d'après une liste
~\\
\item[\textit{pam\_mail.so}] : pour indiquer si de nouveaux mails sont arrivés
~\\
login session optional pam\_mail.so dir=~/Maildir/
~\\
~\\
\item[\textit{pam\_mkhomedir.so}] : pour créer le home des utilisateurs authentifiés (pratique pour les utilisateur NIS ou LDAP)
~\\
\texttt{session required pam\_mkhomedir.so skel=/etc/skel/ umask=022}\\
~\\
\item[\textit{pam\_nologin.so}] : empécher tout login ! = root si le fichier /etc/nologin existe
~\\
\item[\textit{pam\_permit.so}] : autoriser l'accès (dangereux)
~\\
\item[\textit{pam\_rootok.so}] : autoriser si l'utilisateur est root (id=0)
~\\
\item[\textit{pam\_securetty.so}] : permettre l'accès de root seulement si le PAM\_TTY figure dans le fichier \texttt{/etc/securetty}
~\\
\item[\textit{pam\_shells.so}] : permettre l'accès si le shell de l'utilisateur est listé dans le fichier \texttt{/etc/shells}
~\\
\item[\textit{pam\_tally.so}] : permet de bloquer les tentatives au bout d'un certain nombre d'échecs
~\\
\texttt{account required /lib/security/pam\_tally.so per\_user deny=5}\\
~\\
\item[\textit{pam\_time.so}] : permet de restreindre certains services selon le temps d'après le fichier time.conf
~\\
\texttt{games ; * ; !waster ; Wd0000-2400 | Wk1800-0800}\\
~\\
\item[\textit{pam\_unix.so}] : module standard d'authentification Unix
~\\
\item[\textit{pam\_userdb.so}] : module d'authentification sur une Berkeley DB
~\\
\texttt{auth sufficient pam\_userdb.so icase db=/etc/id.db}\\
~\\
\item[\textit{pam\_warn.so}] : journalise certains paramètres pour syslog
~\\
\item[\textit{pam\_wheel.so}] : permettre l'accès root uniquement au membre de whell (gid=0)
~\\
\item[\textit{pam\_cracklib.so}] : vérifie que le mot de passe répond à certains critères (taille, simplicité)
~\\
\texttt{password required pam\_crackedlib.so type=Evolix retry=0 minlen=8}\\
\texttt{dcredit=2 ucredit=2 lcredit=2 ocredit=1}\\
\texttt{password required pam\_pwdb.so use\_authtok nullok md5}\\
\end{itemize}
~\\
Lien: \url{http://perso.wanadoo.fr/alexandre.vidal/pam/}
~\\
On rappelle que pour avoir des renseignements sur l'utilisateur actuellement connecté, on fera~:\\
\textit{ \# whoami}\\
\textit{ \# id}\\
~\\
On peut également avoir divers renseignements sur les utilisateurs~:\\
~\\
\textit{ \# who} : donne les utilisateurs actuellement connectés\\
\textit{ \# last} : donne les dernières connections grâce à fichier wtmp\\
\textit{ \# w.procs} : donne les utilisateurs actuellement connectés et des renseignements complémentaires\\
~\\
\section{Droits sur les applications}
On peut également restreindre les droits sur certaines applications dangereuses.\\
Exemple :\\
\begin{verbatim}
chmod o-x /usr/bin/nmap
chmod -s /bin/ping
\end{verbatim}
On pourra autoriser l'utilisation de n'importe quel programme (même des programmes administrateurs) grâce au logiciel sudo\footnote{\url{http://www.courtesan.com/sudo/}}. Son fichier de configuration est \textbf{/etc/sudoers}. Voici un exemple~: \\
~\\
\texttt{User\_Alias STAFF=jo,zette\\
Cmnd\_Alias NET=/bin/ping,/usr/bin/traceroute,/usr/bin/nmap\\
~\\
root ALL=(ALL) ALL\\
STAFF ALL=(ALL) NET\\
}\\
~\\
\textit{ \# /etc/init.d/sudo restart}
~\\
~\\
Quand on parle de sécurité informatique, de nombreuses personnes pensent uniquement à la sécurité réseau. Ceci est sûrement provoqué par les médiatiques affaires de piratage informatique. Il reste néanmoins vrai que des précautions sont à prendre en terme de sécurité réseau pour éviter les mauvaises surprises.\\
~\\
Au niveau d'un serveur, il est préférable d'opter pour une configuration réseau statique. En effet dépendre d'un tiers (serveur DHCP) pour des paramètres aussi essentiels que les paramètres réseau n'est pas prudent. Dans le cas où l'on voudrait quand même avoir un configuration par DHCP, il faudra au minimum une authentification par adresse MAC.
~\\
Tout d'abord, parlons de quelques outils réseau dont nous allons nous servir par la suite :\\
~\\
\begin{itemize}
\item[\textbf{netstat :}] netstat -a -u
\item[\textbf{lsof :}] lsof -i 4
\item[\textbf{tcpdump :}] tcpdump -X -i eth2 port 22 > log\_ssh
\item[\textbf{nmap :}] http://www.insecure.org/nmap/ nmap -O -P0 192.168.23.27
\item[\textbf{hping :}] outil générateur de paquet réseau
\item[\textbf{scapy :}] outil de manipulation de paquets
\item[\textbf{arping :}] arping -a -S 192.168.3.12 -c 3 -i wlan0 192.168.54.22
\item[\textbf{dsniff :}] dsniff -i eth1
\end{itemize}
~\\
On va donc commencer par contrôler les services réseau ouverts sur la machine et les fermer si nécessaires~:\\
~\\
Sur un système installé depuis peu, on trouve souvent ces services ouverts :\\
~\\
\texttt{\# nmap localhost}
\texttt{
9/tcp~~~open~~discard\\
13/tcp~~open~~daytime\\
37/tcp~~open~~time\\
111/tcp~open~~rpcbind\\
113/tcp~open~~auth\\
}
~\\
discard, daytime et time sont démarrés par inetd\\
~\\
Inetd est historiquement un "super-serveur" permettant de configurer plusieurs services. Pour désactiver les services précédents on procédera à la commande suivante :\\
\begin{verbatim}
# update-inetd --disable discard,daytime,time,ident
\end{verbatim}
\begin{verbatim}
WARNING!!!!!! /etc/inetd.conf contains multiple entries for
the `discard' service. You're about to disable these entries.
Do you want to continue? [n] y
\end{verbatim}
~\\
\textbf{Le super-démon} \\
~\\
Si vous avez l'intention d'utiliser le serveur Inetd, il est préférable d'utiliser Xinetd\footnote{\url{http://www.xinetd.org/}}, qui remplace Inetd en offrant des fonctionnalités plus complètes notamment en terme de sécurité. Pour installer Xinetd, on installera le paquet xinetd tout simplement. Voici un exemple du fichier de configuration xinetd.conf~:
\begin{verbatim}
service imap3
{
socket_type = stream
protocol = tcp
wait = no
user = root
passenv =
server = /usr/bin/tcpd
server_args = /usr/sbin/imapd
}
\end{verbatim}
~\\
On fermera également le port 111 en supprimant le programme portmap (utile pour NIS ou NFS notamment):\\
\begin{verbatim}
# aptitude purge portmap
\end{verbatim}
~\\
On supprimera tous les services inutiles.\\
On vérifie les services TCP ouverts par~:\\
~\\
\texttt{
\# nmap localhost\\
\# netstat -a -t\\
}
~\\
Et les services UDP par~:\\
~\\
\texttt{
\# nmap -sU localhost\\
\# netstat -a -u\\
}
~\\
On peut vérifier quels sont les processus qui ouvrent les ports par :\\
~\\
\texttt{
\# lsof -i 4\\
\# lsof -i 6\\
}
~\\
~\\
{\small{Note : dans le cas où l'on utilise une configuration réseau par DHCP, on ne s'étonnera pas de trouver le port 68 ouvert en UDP.}}
:\\
\section{Sécurité applicative}
\textbf{Firewall}
~\\
Sous Linux, il existe un programme puissant qui permet d'avoir des règles de firewall complexes. Ce programme se nomme (depuis le noyau Linux 2.4.x) Netfilter/IPTables\footnote{\url{http://www.netfilter.org/}}. Il permet d'écrire des règles en ligne de commande, et donc le lancement de règles se fait souvent sous forme de script.\\
~\\
Un script détaillé se trouve en annexe à titre d'exemple.\\
~\\
%TODO
%Fire-Starter : http://www.fs-security.com/
%http://qtables.radom.org/index.php
\textbf{Détection d'intrusion}
~\\
Au-delà des précautions prises, il faut avoir conscience des diverses possibilités d'intrusion et d'attaque. Dans le but de détecter et prévenir ce type de danger, il existe des programmes de détections d'intrusion (IDS) qui permettent d'obtenir des rapports de trafic, des alertes et éventuellement des réactions dynamiques.\\
Les logiciels Prelude\footnote{\url{http://www.prelude-ids.org/}} et Snort\footnote{\url{http://www.snort.org/}} sont les IDS libres les plus connus. \\
Ils peuvent être couplés avec une base de données (MySQL, PostGreSQL) et respectivement avec les logiciels Piwi et ACID (Analysis Console for Intrusion Databases)\footnote{\url{http://acidlab.sourceforge.net/}} pour obtenir les rapports par une interface web.\\
~\\
Il existe un autre type de logiciels de sécurité : le \textit{pot de miel}. Il s'agit de serveur (ou serveur virtuel) laissé sous surveillance étroite sur un réseau et dont le rôle est d'être attaqué et compromis afin d'étudier le comportement et les outils des pirates.\\
Le programme libre le plus connu est honeyd\footnote{\url{http://www.honeyd.org/}} mais il existe d'autres implémentations (tinyhoneypot\footnote{\url{http://www.alpinista.org/thp/}}, etc.) D'autres programmes moins élaborés permettent de surveiller des actions d'utilisateurs:\\
~\\
TTYSnoop\footnote{\url{http://freshmeat.net/projects/ttysnoop/}} permet de dériver des terminaux de connexion, \\
Snoopy\footnote{\url{http://sourceforge.net/projects/snoopylogger/}} pour intercepter les commandes sur le système, \\
~\\
%TODO
%port-sentry
%ScanLogd : http://www.openwall.com/scanlogd/
%debian package AIDE
On citera également les nombreux outils qui permettent d'écouter et d'analyser le trafic réseau:\\
~\\
\texttt{tcpdump, ethereal, dsniff, sniffit\footnote{\url{http://reptile.rug.ac.be/~coder/sniffit/sniffit.html}}, ngrep, hunt, tcpick}\\
\texttt{nast, karpski, vnstat, ndiff, etc.} \\
~\\
\textbf{Piratage ?}
~\\
On peut vérifier l'intégrité du système grâce à des outils de détection des rootkits : Chkrootkit\footnote{\url{http://www.chkrootkit.org/}} :\\ ou Rootkit Hunter\footnote{\url{http://www.rootkit.nl/projects/rootkit\_hunter.html}}\\
~\\
% voir script checksecurity (Debian package)
\section{OpenSSH}
SSH signifie Secure SHell (Shell sécurisé). Le protocole SSH est en cours de standardisation par l'IETF\footnote{\url{http://www.ietf.org/html.charters/secsh-charter.html}}. Les outils du protocole SSH sont utilisés par un nombre croissant de personnes. Ils sont destinés à sécuriser le login à distance, sécuriser les transferts de fichiers et sécuriser les TCP/IP et X11 forwardings. Il peut automatiquement chiffrer, authentifier et compresser des données transmises.\\
~\\
La principale implémentation du protocole est OpenSSH\footnote{\url{http://www.openssh.org}}. OpenSSH est une version libre de la suite d'outils du protocole SSH. De nombreux utilisateurs de telnet, rlogin, ftp et autres programmes identiques ne réalisent pas que leur mot de passe et leurs données sont transmis de façon non chiffrée. OpenSSH chiffre tout le trafic (mots de passe inclus) de façon à déjouer les écoutes réseau, les prises de contrôle de connexion, et autres attaques. De plus, OpenSSH fournit toute une palette de possibilités de tunnel et de méthodes d'authentification. OpenSSH \textbf{doit} être utilisé à la place de telnet et autres logiciels non-sûrs.\\
Pour la plupart de ses fonctionnalités cryptographiques, OpenSSH s'appuie sur la bibliothèque OpenSSL. La suite logicielle OpenSSH inclue les programmes ssh qui remplace telnet et rlogin, scp qui remplace rcp, et sftp qui remplace ftp. De plus sshd, la partie serveur, est inclus ainsi que d'autres utilitaires tels que ssh-add, ssh-agent, ssh-keygen, ssh-keysign, ssh-keyscan, et sftp-server. OpenSSH supporte les protocoles SSH 1.3, 1.5 et 2.0. Intéressons nous à sa configuration, qui se trouve dans le fichier \textit{sshd\_config} :\\
\begin{verbatim}
Protocol 2
LoginGraceTime 30
PermitRootLogin no
AllowUsers moi admin
ClientAliveInterval 15
ClientAliveCountMax 45
\end{verbatim}
~\\
On peut également imposer des restrictions supplémentaires dans le fichier pam.d/ssh :\\
\begin{verbatim}
auth required pam_listfile.so sense=allow onerr=fail
item=user file=/etc/loginusers
\end{verbatim}
~\\
Si des utilisateurs normaux sont destinés à utiliser SSH, il peut être intéressant de l'installer dans une prison Chroot. Voici quelques liens qui expliquent cette mise en place~: \\
Liens : \\
{\small
\url{http://chrootssh.sourceforge.net/index.php} \\
\url{http://www.debian.org/doc/manuals/securing-debian-howto/ap-chroot-ssh-env.fr.html} \\
\url{http://vince.kerneled.org/files/ssh\_chroot.txt} \\
}
~\\
\section{Transfert de fichiers}
~\\
Le transfert de fichiers par le protocole FTP fait circuler identifiants, mot de passe et données en clair sur le réseau. Il est vraiment préférable d'utiliser scp ou sftp, du projet OpenSSH, qui permet de transférer des fichiers de façon plus sécurisée. Mais dans certains cas, notamment dans le cas de serveur web mutualisé, il est de coutume d'offrir un accès FTP. Il faut donc prendre quelques précautions. Par exemple, avec le serveur ProFTPD\footnote{\url{http://www.proftpd.org/}}, certaines directives du fichier de configuration \textit{proftpd.conf} sont importantes : \\
\begin{verbatim}
DefaultRoot ~
DenyFilter \*.*/
\end{verbatim}
On pourra également utiliser PAM pour limiter l'accès selon les utilisateurs. Dans le fichier \textit{/etc/pam.d/proftpd}~: \\
auth required pam\_listfile.so item=user sense=deny file=/etc/ftpusers onerr=succeed
~\\
On aura donc un fichier \textit{/etc/ftpusers} qui spécifiera les identifiants ne pouvant pas utiliser les services FTP (on pourrait faire l'inverse aussi). \\
~\\
Dans le but de chiffrer les connexions FTP, on peut également utiliser une couche SSL. Les serveurs Pure-FTP\footnote{\url{http://www.pureftpd.org/}} ou linux-ftpd-ssl\footnote{\url{http://freshmeat.net/projects/linux-ftpd-ssl/}} permettent cela. Il faut bien noter qu'il faut utiliser un programme client capable de l'utiliser (mais c'est le cas de plus en plus de clients). \\
\section{Isoler les services}
~\\
\textit{Chroot} \\
Chroot est un utilitaire permettant d'emprisonner un service dans une arborescence limitée. Cela permet de limiter l'accès aux services offerts et éviter d'avoir un accès complet au système en cas de failles logiciel. Sous Debian, il existe quelques services tournant dans une prison Chroot par défaut (Postfix notamment) mais si l'on veut emprisonner des services comme Bind, Apache, serveur FTP, OpenSSH, il faudra créer la prison Chroot manuellement. Le script makejail\footnote{\url{http://www.floc.net/makejail/}} permet d'aider à la création de prisons Chroot à l'aide de fichiers de configuration. On notera que les systèmes *BSD (notamment OpenBSD\footnote{\url{http://www.openbsd.org/}}) sont en avance pour les services d'emprisonnement. De nombreux services sont ainsi emprisonnés par défaut. \\
~\\
D'autres programmes permettent d'émuler plusieurs systèmes sur une seule machine :\\
\textit{Vserver} \\
Linux-VServer est projet libre proposant un patch pour le noyau Linux ainsi qu'un ensemble d'outils pour permettre de lancer plusieurs distributions Linux au dessus d'un seul noyau et partager les ressources. \\
Lien : \url{http://www.linux-vserver.org/}\\
~\\
\textit{UML} \\
UML (User Mode Linux) est un projet libre permettant de lancer plusieurs noyaux Linux comme un simple programme (en mode utilisateur donc) ce qui permet d'avoir des machines virtuelles Linux. Le contenu du disque du système virtuel est stocké dans un seul fichier. \\
Lien : \url{http://user-mode-linux.sourceforge.net/}
~\\
\textit{Vmware} \\
Vmware est un programme propriétaire plutôt réputé permettant de lancer plusieurs machines virtuelles (MS-Windows, Linux, *BSD) Il existe une version Workstation permettant de lancer des machines virtuelles comme des applications et une version Serveur permettant de lancer à distance des machines virtuelles sur un serveur. \\
Lien : \url{http://www.vmware.com/}
~\\
~\\
"Nous ne cacherons pas les problèmes. Nous garderons toujours notre base de données des rapports de bogues ouverte au public. Les rapports que les utilisateurs remplissent en ligne seront immédiatement visibles par les autres." extrait du Contrat social Debian\\
~\\
Comme pour la plupart des logiciels, la politique de sécurité de Debian est d'avoir une gestion transparente des failles et des bogues. Plusieurs études ont montré que cette politique était la plus efficace en terme de sécurité. Néanmoins, cela a pour conséquence pour l'administrateur d'avoir une réactivité accrue pour faire le nécessaire dès qu'un problème est annoncé. Il existe donc une équipe de sécurité Debian qui est chargée de publier des paquets corrigés pour la version stable de Debian dès qu'un problème est découvert. Pour pouvoir profiter de ces paquets mis à jour, il faut avoir la ligne suivante dans son fichier \textit{sources.list}~:\
~\\
\texttt{deb http://security.debian.org/ stable/updates main contrib non-free}
~\\
Le minimum est de s'abonner à la liste de diffusion debian-security-announce. Mais pour aller plus loin, il est conseillé de suivre de près les listes de diffusion des logiciels utilisés en production et également des listes traitant de sécurité notamment la liste Bugtraq\footnote{\url{http://www.securityfocus.com/archive/1}}. \\
~\\
\section{Gestion des Journaux}
Les journaux sont des fichiers qui contiennent des informations d'activité datée. Ils sont essentiels pour un serveur pour de nombreuses raisons : vérifier des actions passées, générer des statistiques, déboguer un programme. La vérification des actions passées est notamment importante en cas de problème (piratage, service défectueux). La justice oblige également à conserver certains journaux pendant une certaine durée. Un flou concerne ce qu'il faut réellement conserver (apparemment seules les informations d'entêtes mais pas le contenu en lui-même) et la durée (cela varie entre 3 mois, 1 an et 3 ans si l'on se base sur les lois françaises ou européennes). Des décrets d'application devraient éclaircir ces points dans les prochains mois.\\
~\\
Sous Debian, les journaux se trouvent généralement dans le répertoire \textit{/var/log}. On va distinguer les journaux systèmes et les journaux applicatifs. Les journaux systèmes sont gérés par le démon SYSLOG\footnote{\url{ftp://ftp.rfc-editor.org/in-notes/rfc3164.txt}}. Sa configuration se trouve dans le fichier \textit{syslog.conf}. Voici quelques ligne extraites de ce fichier~:
\begin{verbatim}
daemon.* -/var/log/daemon.log
kern.* -/var/log/kern.log
mail.* -/var/log/mail.log
*.=debug;auth,authpriv.none;news.none;mail.none -/var/log/debug
*.emerg *
*.*;auth,authpriv.none /dev/tty8
\end{verbatim}
Voici les fichiers pincipaux générés par SYSLOG : \\
~\\
\begin{itemize}
\item[\textbf{auth.log :}] authentification système (login, su, getty)
\item[\textbf{daemon.log :}] relatif aux daemons
\item[\textbf{mail.* :}] messages relatifs aux mails
\item[\textbf{kern.log :}] messages générés par le noyau
\item[\textbf{user.log :}] message généré par des programmes utilisateur
\item[\textbf{debug :}] messages de bogues
\item[\textbf{messages :}] messages d'info
\item[\textbf{syslog :}] tous les messages
\end{itemize}
~\\
~\\
Les journaux applicatifs sont générés par chaque application. Ils sont souvent dans un répertoire du nom de l'application situé dans \textit{/var/log}.\\
~\\
L'un des points essentiels est la rotation des journaux, c'est-à-dire l'action de fermer le journal actuel (et éventuellement le compresser) et d'en ouvrir un autre. Il existe actuellement deux programmes qui se chargent d'effectuer ce travail. Le script \texttt{savelog} (un outil Debian) et le programme \texttt{logrotate}. Par défaut \texttt{savelog} gère les journaux système et \texttt{logrotate} gère les journaux applicatifs (apache, mysql, ppp, etc.).\\
Logrotate est exécuté tous les jours (cron.daily) \\
Savelog est exécuté tous les jours (crond.daily) pour syslog notamment.\\
Savelog est exécuté toutes les semaines (crond.weekly) pour les autres journaux système.\\
~\\
L'option "-d" de savelog permet d'utiliser la date lors de la rotation des journaux et de ne pas les effacer. On pourra donc ajouter ses propres règles dans les scripts cron pour faire une sauvegarde distante des journaux (éventuellement dans une base de données). Pour des serveurs dédiés (applications clés), on peut augmenter la fréquence des rotations et des sauvegardes distantes, mais également utiliser des scripts afin de détecter toutes alertes ou anomalies et les envoyer par courrier électronique ou même SMS. \\
Il existe des programmes analysant les journaux permettant de détecter des problèmes, avoir des statistiques (lire logtool prelude).\\
~\\
Il faut donc bien insister sur la nécessité de surveiller les services en production à l'aide d'outils adaptés. On dispose donc d'outils s'appuyant souvent sur le protocole SNMP (Simple Network Management Protocol) qui permet de gérer et diagnostiquer les problèmes en transférant des informations système (réseau, charge, état, etc.).
~\\
Pour exploiter ces informations, on pourra tracer des courbes MRTG\footnote{\url{http://people.ee.ethz.ch/~oetiker/webtools/mrtg/}} ou RRDtool\footnote{\url{http://people.ee.ethz.ch/~oetiker/webtools/rrdtool/}}. Ces logiciels permettent de produire des courbes totalement personnalisées pour tracer des courbes.\\
~\\
%TODO
%http://www.linpro.no/projects/munin/
%http://stat.trackfire.net/statspppd/src/
%http://people.ee.ethz.ch/~oetiker/webtools/smokeping/
\section{Monitoring}
Voyons un exemple simple qui trace des courbes en fonctions du temps de réponse de \texttt{ping}. \\
On installera les programmes snmpd et mrtg.\\
Dans \texttt{/etc/snmp/snmpd.conf}, ajouter cette ligne:\\
\textit{com2sec readonly default public}\\
Attention, bien veillez à supprimer cette ligne :\\
\textit{com2sec paranoia default public}\\
~\\
\texttt{/etc/mrtg/ping :}
~\\
\begin{verbatim}
#!/bin/sh
P=`ping -c3 -q google.fr |grep avg|cut -d" " -f4`
MIN=`echo $P|cut -d"/" -f1`
MAX=`echo $P|cut -d"/" -f2`
echo $MAX
echo $MIN
\end{verbatim}
~\\
\textit{\bf mrtg.conf :}
\begin{verbatim}
WorkDir: /var/www/mrtg
Language: French
Target[ping]: `/etc/mrtg/ping`
Options[ping]: nopercent,growright,gauge,noinfo, nobanner
MaxBytes[ping]: 10000
AbsMax[ping]: 10000
YLegend[ping]: Latence
ShortLegend[ping]: ms
Legend1[ping]: Latence max en ms
Legend2[ping]: Latence min en ms
LegendI[ping]: Latence Max:
LegendO[ping]: Latence Min:
Title[ping]: Ping sur Google
PageTop[ping]: <h1>Latence Google.fr</h1>
WithPeak[ping]:wmy
Legend4[ping]: Max de la latence min
Legend3[ping]: Max de la latence max
\end{verbatim}
~\\
Il suffit ensuite de lancer la commande :\\
\texttt{\# mrtg /etc/mrtg.conf}\\
~\\
On la placera dans un cron pour obtenir des courbes de statistiques régulières.\\
~\\
On pourra créer des courbes de statistiques en s'appuyant sur les nombreux outils disponibles sous Linux (sysstat, smartmontools, etc.)\\
~\\
Il existe de nombreux programmes évolués permettant de générer des courbes et statistiques. Citons Nagios\footnote{\url{http://www.nagios.org/}}, Cacti\footnote{\url{http://www.cacti.net/}} et Ntop\footnote{\url{http://www.ntop.org/}}. Le plus connu d'entre eux est certainement Nagios qui permet de surveiller de nombreux services (SMTP, POP3, HTTP, NNTP, PING, etc.) mais également les ressources (charge processeur, utilisation des disques, etc.). On peut visualiser les résultats, historiques des problèmes, journaux par interface web et obtenir des alertes personnalisées et écrire ses propres plugins pour des vérifications spécifiques. La mise en place de Nagios (ou d'un équivalent) pour un nombre de serveurs dépassant la dizaine est fortement conseillée.\\
~\\
Pour une surveillance système en direct, on peut utiliser GKrellM\footnote{\url{http://www.gkrellm.net/}} en mode client-serveur : chaque serveur fait tourner un serveur gkrellmd et pour surveiller tous les serveurs, on démarre les clients sur un poste de travail. On peut également sécuriser les transmissions en encapsulant le trafic dans un tunnel SSH.
~\\
\url{http://www.debian.org/doc/manuals/securing-debian-howto/index.fr.html}\\
\url{http://entreelibre.com/scastro/debian-secinst/debian-secinst.txt}\\
~\\
En informatique, on distingue les langages compilés et les langages interprétés. On peut considérer qu'un "script" est un programme écrit dans un langage interprété. Cela comprendra donc les shells (sh, csh, ksh, tcsh, bash, pdksh) les outils de manipulation de texte (sed, awk), Perl, Tcl, Ruby et Python.
~\\
~\\
La plupart de ces langages pourraient mériter une formation entière aussi nous nous concentrons sur quelques fonctionnalités intéressantes du shell :\\
~\\
\begin{itemize}
\item[\bf cut]
Utilitaire qui sélectionne des sections sur chaque ligne d'un fichier sur la sortie standard.\\
~\\
\texttt{cut -d " " -f 1 fichier}\\
~\\
\item[\bf head]
Utilitaire qui renvoie les premières parties d'un fichier sur la sortie standard.\\
\texttt{head -n 7 fichier}\\
\item[\bf tail ]
Utilitaire qui renvoie les dernières parties d'un fichier sur la sortie standard.\\
\texttt{tail -f fichier}\\
\texttt{tail -n 7 fichier}\\
\item[\bf sort ]
Utilitaire qui trie les lignes d'un fichier sur la sortie standard.\\
\texttt{sort -d fichier}\\
\item[\bf tr]
Utilitaire pour convertir ou supprimer des caractères d'un fichier sur la sortie standard.\\
\texttt{echo -e "plop\textbackslash nplop" | tr -d "\textbackslash n"}\\
\item[\bf wc]
Utilitaire qui renvoie le nombre de lignes, fichiers ou octets d'un fichier.\\
\texttt{wc -l fichier}\\
\item[\bf grep]
Utilitaire renvoyant les lignes correspondant au modèle indiqué.\\
\texttt{grep -i HtTp /etc/services}\\
\item[\bf seq]
Utilitaire renvoyant une séquence de nombres.\\
\texttt{seq 4 3 20}\\
\item[\bf for]
Boucle\\
\texttt{for i in 1 2 5; do echo \$i; done}\\
\texttt{for i in \`ls \*.php\`; do mv \$i \$(\$i\%\%.php).html; done}\\
\end{itemize}
\section{Crontab}
~\\
Cron est démon qui permet d'exécuter automatiquement des commandes ou des scripts à une date et une heure spécifiées à l'avance.\\
~\\
C'est évidemment très utile pour toutes les tâches d'aministration. Le démon cron se base sur le fichier \textit{/etc/crontab} pour lancer des actions toutes les heures (cron.hourly), tous les jours (cron.daily), toutes les semaines (cron.weekly) et tous les mois (cron.monthly). \\
~\\
Déjà, il peut être intéressant de personnaliser les paramètres du \textit{/etc/crontab} afin d'éviter l'utilisation des horaires par défaut.\\
Ensuite on peut placer des scripts (exécutables) dans les cron.*ly ou bien dans le répertoire cron.d afin de personnaliser l'horaire :
~\\
\textbf{Squelette} :
~\\
"minute" "heure" "date" "mois" "jour" "utilisateur" "commande"\\
~\\
Exemple signifiant du lundi au vendredi, toutes les 3h à la 5ème minute:\\
\texttt{5 */3 * 1-5 root ntpdate serveur-ntp\\
}
\section{Procédures de sauvegarde}
~\\
La mise en place de procédures de sauvegarde nécessite souvent un audit précis pour évaluer le juste milieu entre le niveau de sécurité et le coût.\\
Prenons quelques exemples concrets.\\
Il est impensable qu'une entreprise, même petite, doive mettre la clé sous la porte en cas de petite castrophe naturelle (tempête, foudre, incendie).\\
Des sauvegardes dans un endroit physiquement différent sont donc
obligatoires. À l'inverse, pour une petite entreprise, mettre en place
des sauvegardes sur bande rapatriée dans un coffre-fort toutes les
heures en fourgon blindé sera probablement disproportionné. Il faut donc
évaluer chaque risque et le chiffrer. Les paramètres à prendre en compte sont:\\
~\\
- les risques\\
- le coût de mise en place et le coût régulier\\
- le temps d'administration de la solution\\
- le temps de redéploiement ou de recherche\\
~\\
Il existe principalement deux types de préventions:\\
~\\
- Prévention crash matériel\\
La solution est à choisir parmi la solution RAID, les sauvegardes système (disque/bande/périphérique amovible) et sauvegarde des fichiers système.\\
~\\
- Prévention erreurs logicielles ou humaines\\
La solution est de faire des sauvegardes régulières.\\
~\\
tar est l'outil le plus utilisé pour la sauvegarde.\\
~\\
Exemple :\\
\begin{verbatim}
tar -czvps --same-owner --atime-preserve backup.tar.gz /rep/
\end{verbatim}
~\\
\emph{Table des partitions :}\\
~\\
\textit{Sauvegarde} : \texttt{dd if=/dev/hda of=NOM\_FIC bs=512 count=1}\\
~\\
\textit{Restauration} : \texttt{dd if=NOM\_FIC of=/dev/hda bs=1 count=64 skip=446 seek=446}\\
~\\
\textit{Partimage}\footnote{\url{http://www.partimage.org/}} :
~\\
\begin{itemize}
\item[Sauvegarde] : \\
\texttt{partimage -z1 -o -d save /dev/hda12 /mnt/backup/sav.partimg.gz}\\
\item[Restauration] :\\
\texttt{partimage restore /dev/hda12 /mnt/backup/sav.partimg.gz}\\
\end{itemize}
~\\
L'outil rsync\footnote{\url{http://samba.anu.edu.au/rsync/}} est très puissant car il permet de mettre à jour en local ou à distance uniquement les fichiers modifiés.\\
~\\
client rsync <-> serveur rsynd\\
~\\
\begin{verbatim}
22/tcp open ssh
873/tcp open rsync
\end{verbatim}
~\\
Options intéressantes :\\
\begin{verbatim}
-v, --verbose
\end{verbatim}
-> plus verbeux
\begin{verbatim}
-a, --archive
\end{verbatim}
-> mode archive (equivalent to -rlptgoD), ne préserve pas les liens hard
\begin{verbatim}
-r, --recursive
\end{verbatim}
-> visite récursive des répertoires
\begin{verbatim}
-l, --links
\end{verbatim}
-> copie les liens symboliques comme liens symboliques
\begin{verbatim}
-p, --perms
\end{verbatim}
-> préserve les permissions
\begin{verbatim}
-o, --owner
\end{verbatim}
-> préserve le propriétaire (root uniquement)
\begin{verbatim}
-g, --group
\end{verbatim}
-> préserve le groupe
\begin{verbatim}
-t, --times
\end{verbatim}
-> préserve les dates
\begin{verbatim}
-S, --sparse
\end{verbatim}
-> traite les fichiers à trous efficacement
\begin{verbatim}
-C, --cvs-exclude
\end{verbatim}
-> ignore automatiquement des fichiers, comme le ferait CVS
\begin{verbatim}
--delete
\end{verbatim}
-> efface les fichiers qui n'existent pas du coté expédition
\begin{verbatim}
--partial
\end{verbatim}
-> conserve les fichiers partiellement transférés
\begin{verbatim}
--progress
\end{verbatim}
-> affiche la progression
\begin{verbatim}
-z, --compress
\end{verbatim}
-> compresse les données
\begin{verbatim}
-e ssh
\end{verbatim}
-> utilise ssh
\begin{verbatim}
-D, --devices
\end{verbatim}
-> préserve les devices
~\\
L'astuce suprême consiste à utiliser des "liens hards" grâce à la commande \texttt{cp -al}\\
Un fichier est donc supprimé lorsqu'aucun lien matériel ne pointe vers lui :\\
~\\
\begin{verbatim}
mv backup.1 backup.2
cp -al backup.0 backup.1
rsync -e -a --delete source backup.0/
\end{verbatim}

141
support/squid.tex Normal file
View file

@ -0,0 +1,141 @@
% Copyright (c) 2004-2010 Evolix <info@evolix.fr>
% Permission is granted to copy, distribute and/or modify this document
% under the terms of the GNU Free Documentation License, Version 1.2
% or any later version published by the Free Software Foundation;
% with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
% A copy of the license is included at http://www.gcolpart.com/howto/fdl.html
\section{SQUID}
\subsection{Présentation}
Le logiciel Squid (\url{http://www.squid-cache.org}) est le serveur proxy le plus connu et le plus utilisé. Il permet d'opérer un filtrage sur des flux HTTP et/ou FTP en fonction du contenu qui transite ou des sites consultées. Il peut être utile pour accélérer le débit vers les pages déjà consultées (utilisation du cache) ou encore réglementer (ou protéger) la naviguation sur Internet. On peut ainsi filtrer en fonction d'extensions de fichiers, de mots clés, d'URL, etc.\\
Squid fonctionne sur toutes les plateformes UNIX, et dispose d'une communauté de développeurs mondiale. De nombreux développements annexes ont été réalisés, comme Squid-Guard ou un module Squid pour Webmin.\\
\subsection{Installation}
Squid est présent dans de nombreuses distributions Linux et systèmes
Unix en tout genre.\\
Exemple sous Debian, il suffit d'installer les packages \textit{squid -
squid-common - squid-client} et optionnelement \textit{squid-cgi}.\\
La configuration se fait via le fichier \textit{/etc/squid/squid.conf}.
\subsection{Configuration de base}
\begin{verbatim}
# Port d'écoute
http_port 80
# Taille du cache
cache_mem 16 MB
\end{verbatim}
\subsection{Gestion des restrictions}
Les restrictions sont opérées sur plusieurs points :
\begin{itemize}
\item un mécanisme d'ACL (Access Classes Lists) pour restreindre l'accès au serveur proxy
\item un mécanisme d'ACO (Access Classes Operators) qui permettent de restreindre l'accès à certaines URLs
\end{itemize}
~\\
\noindent Exemple d'ACL :
\begin{verbatim}
# on n'autorise que les machines du sous-réseau
acl CLIENTS src 192.168.1.0/255.255.255.0
http_access allow CLIENTS
http_access deny all
# ports sécurisés
acl Safe_ports port 80 443
http_access deny !Safe_ports
\end{verbatim}
~\\
\noindent Exemple d'ACO :
\begin{verbatim}
acl url_mp3 url_regex -i \.mp3$
http_access deny url_mp3
\end{verbatim}
\subsection{Authentification}
Le logiciel Squid permet de nombreux modes de fonctionnement. Entre autres, il est possible de donner lieu à une utilisation authentifiée. Seul un utilisateur doté d'un login et d'un mot de passe pourra utiliser les ressources de Squid.\\
Pour celà, il faut par exemple rajouter dans la configuration :
\begin{verbatim}
acl Users proxy_auth REQUIRED
http_access deny !Users
# choix de la méthode, exemple
authenticate_program /usr/lib/squid/ncsa_auth /usr/lib/squid/passquid
\end{verbatim}
Le choix du mode d'authentification vous appartient, vous avez en effet le choix entre :
\begin{itemize}
\item \textit{ncsa\_auth} qui utilise un fichier d'utilisateurs Squid, remplis par exemple via la commande htpasswd
\item \textit{smb\_auth} pour utiliser une base Samba
\item \textit{ldap\_auth} pour utiliser une base LDAP
\item \textit{pam\_auth} pour utiliser l'authentification PAM
\end{itemize}
~\\
\subsubsection{Exemple : ncsa\_auth}
Dans le cas de \textit{ncsa\_auth}, vous avez donc à créer votre fichier d'utilisateurs :
\begin{verbatim}
Dans squid.conf :
/usr/lib/squid/ncsa_auth
Création du fichier d'utilisateurs :
htpasswd -c /etc/squid/users utilisateur_test motdepasse_test
Ce qui donne :
utilisateur_test:QXgxhYPbn
\end{verbatim}
\subsubsection{Exemple : ldap\_auth}
La directive à utiliser afin d'activer le support LDAP est :
\begin{verbatim}
acl aclname ldap_auth (((static | dynamic) group) | username) ...
\end{verbatim}
\begin{verbatim}
Dans squid.conf :
# serveur LDAP à joindre
auth_param basic program /usr/lib/squid/squid_ldap_auth -u uid -b
ou=test,ou=evolix,o=evolix,c=fr -h ldap.evolix.fr -p 389
# paramètres
auth_param basic children 5
auth_param basic realm Squid proxy-caching web server
# temps d'authentification
auth_param basic credentialsttl 2 hours
\end{verbatim}
\subsection{Modèle distribué}
Il est également possible de "cascader" plusieurs serveurs cache. Pour se faire, le fichier de configuration squid.conf doit être configuré dans cette optique. Les différents serveurs Squid peuvent par la suite communiquer normalement ou via le protocole \textit{ICP}.\\
~\\
Exemple :
\begin{verbatim}
cache_peer_domain peer1.domaine.com pper2.domaine.com
cache_peer peer.domaine.com parent 80 7 no-query proxy-only
neighbor_type_domain peer3.domaine.com parent peer4.domaine.com
\end{verbatim}
Enfin, Squid utilise plusieurs journaux afin de rendre compte des différentes/accès qui ont été réalisés (access.log etc.).