Sécurité des Systèmes d’Exploitation

Ce laboratoire présente les concepts fondamentaux de la sécurité des systèmes d’exploitation, en mettant l’accent sur les types d’attaques, les services de sécurité, les mécanismes de contrôle d’accès et l’administration sécurisée des comptes utilisateurs. Il s’adresse aux étudiants souhaitant comprendre les vulnérabilités des systèmes Unix/Linux et Windows, ainsi que les outils et méthodes pour renforcer leur sécurité. Pour suivre ce TP, il est nécessaire d’avoir un accès à un système Unix/Linux, des droits d’administrateur, et une connaissance de base des commandes système.

Objectifs

• Identifier les différents types d’attaques internes et externes sur un système d’exploitation.
• Comprendre les services de sécurité essentiels : confidentialité, intégrité, disponibilité et responsabilité.
• Mettre en œuvre et administrer la sécurité des comptes utilisateurs sous Unix/Linux.
• Appliquer les modèles de contrôle d’accès : DAC, MAC, RBAC et DTE.
• Configurer et sécuriser les connexions et les shells utilisateurs.

Prérequis et installation

• Un système Unix/Linux avec accès root.
• Connaissances de base en administration système et en gestion des utilisateurs.
• Accès aux fichiers système : /etc/passwd, /etc/shadow, /etc/group, /etc/login.defs.
• Outils de gestion des comptes : useradd, usermod, userdel, passwd, chage, pwck, grpck.
• Connaissance des commandes shell et des permissions Unix (r, w, x).

Étape 1 : Comprendre les types d’attaques

Cette étape consiste à étudier les différentes formes d’attaques pouvant affecter un système d’exploitation, tant de l’intérieur que de l’extérieur.

• Attaques internes : chevaux de Troie, login spoofing, bombes logiques, dépassements de tampon (buffer overflow), portes dérobées (trap doors).
• Attaques externes : attaques frontales, déni de service, code mobile (cookies, scripts Java, ActiveX), virus, vers, bactéries informatiques.

Un exemple de buffer overflow est donné avec la fonction strcpy qui ne vérifie pas la taille des données copiées, ce qui peut écraser la pile et compromettre la sécurité.

void pb(char *str)
{
  char s[8];
  strcpy(s, str);
  /* risque d’écrasement de la pile */
}

Un autre exemple est le login spoofing, où un programme malveillant imite la demande de login pour récupérer les mots de passe.

Un code malveillant simple provoquant un fork infini est aussi présenté :

main(void)
{
  while(1)
    fork();
}

Cette étape vise à sensibiliser aux risques et à reconnaître les différentes formes d’attaques.

Étape 2 : Étudier les services de sécurité essentiels

Les services de sécurité sont les garanties que doit offrir un système pour protéger l’information :

• Confidentialité : l’information doit rester secrète et accessible uniquement aux sujets autorisés, que ce soit dans les fichiers, les applications ou les transmissions réseau.
• Intégrité : l’information ne peut être modifiée que par des actions volontaires d’utilisateurs autorisés.
• Disponibilité : le système doit être accessible à tout moment, sans déni ou dégradation de service, incluant la gestion des sauvegardes et la tolérance aux pannes.
• Responsabilité : les actions des utilisateurs doivent être tracées et contrôlées pour expliquer les événements (identification, authentification, audit).

Ces services sont la base pour définir des politiques de sécurité adaptées.

Étape 3 : Administration sécurisée des comptes utilisateurs

Cette étape pratique montre comment gérer les comptes utilisateurs sous Unix/Linux en respectant les règles de sécurité.

• Examiner la structure des fichiers importants :
• /etc/passwd : informations publiques sur les utilisateurs.
• /etc/shadow : mots de passe cryptés et paramètres d’expiration, accessible uniquement au super-utilisateur.
• /etc/group : gestion des groupes d’utilisateurs.
• Utiliser les commandes suivantes :

# useradd -c ouerghi -d /home/omsaid -g oms -u 500 -s /bin/sh -m -k /etc/skel omsaid
# chage -l omsaid
# chage -M 15 -W 3 omsaid
# chage -E 2004/09/03 omsaid
# passwd -l omsaid
# passwd -u omsaid

Ces commandes permettent respectivement de créer un compte, afficher les paramètres du mot de passe, forcer un changement de mot de passe tous les 15 jours avec avertissement 3 jours avant, fixer une date d’expiration, verrouiller et déverrouiller un compte.

Veiller à désactiver les comptes inutilisés ou invités, et limiter leur accès via un shell restreint.

Un shell restreint (/usr/bin/rsh) peut être attribué pour limiter les actions des utilisateurs suspects.

Étape 4 : Sécurisation des connexions

Cette étape détaille la sécurisation des accès au système :

• Fichiers importants :
• /etc/nologin : présence interdit la connexion des utilisateurs.
• /etc/securetty : définit les terminaux où root peut se connecter.
• /etc/usertty : restreint la connexion des utilisateurs via la commande login.
• /etc/login.defs : paramètres généraux du vieillissement des mots de passe.
• /var/log/secure : historique des connexions échouées.
• /var/log/wtmp : enregistre les connexions passées (commande last pour consulter).
• Commandes utiles :

login
last
su
pwconv
pwunconv
passwd
chage
userdel

• Configurer PAM (Pluggable Authentication Modules) via les fichiers dans /etc/pam.d/, par exemple /etc/pam.d/login :

auth required /lib/security/pam_securetty.so
auth required /lib/security/pam_pwd.so shadow nullok
auth required /lib/security/pam_nologin.so
account required /lib/security/pam_pwd.so
password required /lib/security/pam_cracklib.so
password required /lib/security/pam_pwd.so shadow nullok use_authok
session required /lib/security/pam_pwd.so

• Vérifier et modifier les droits des fichiers sensibles :

chmod 0644 /etc/passwd
lsattr /etc/passwd
chattr +i /etc/passwd
chattr -s /etc

Étape 5 : Comprendre les modèles de contrôle d’accès

Cette étape théorique présente les différents modèles de contrôle d’accès :

• Discretionary Access Control (DAC) : contrôle basé sur les permissions attribuées par le propriétaire d’un objet, très utilisé sous Unix/Linux. Les permissions sont définies pour le propriétaire (UID), le groupe (GID) et les autres, avec les droits read (r), write (w), execute (x).
• Mandatory Access Control (MAC) : contrôle basé sur des règles définies par l’administrateur, avec des niveaux de sécurité et des classifications (ex : BLP pour la confidentialité, Biba pour l’intégrité). Le propriétaire n’a pas tous les droits sur son objet.
• Role Based Access Control (RBAC) : contrôle basé sur des rôles associés à des permissions et des utilisateurs, respectant le principe du moindre privilège et la séparation des tâches.
• Domain and Type Enforcement (DTE) : chaque processus a un domaine, chaque objet un type, avec des matrices définissant les droits d’accès et les interactions entre domaines.

Exemple d’une permission Unix :

-rw-r--r-- 1 toto users 188756 Nov 11 10:05 toto.txt

où le propriétaire a les droits read et write, le groupe read, et les autres read.

Résultats attendus

• Identification claire des types d’attaques internes et externes, avec compréhension des mécanismes comme buffer overflow ou login spoofing.
• Capacité à définir et appliquer les services de sécurité : confidentialité, intégrité, disponibilité, responsabilité.
• Maîtrise de la gestion sécurisée des comptes utilisateurs, avec création, modification, verrouillage et expiration des comptes.
• Configuration correcte des fichiers système et des droits d’accès pour protéger les mots de passe et les connexions.
• Compréhension des modèles de contrôle d’accès et capacité à les distinguer dans un contexte Unix/Linux.

Pièges courants

• Ne pas protéger le fichier /etc/shadow : il doit être accessible uniquement au super-utilisateur.
• Utiliser des mots de passe faibles ou communs, facilitant les attaques par force brute.
• Oublier de verrouiller ou désactiver les comptes inactifs, qui deviennent des cibles privilégiées pour les attaques.
• Confondre les permissions Unix et ne pas vérifier les droits des fichiers sensibles, ce qui peut exposer des informations critiques.
• Mal configurer PAM, ce qui peut entraîner des failles dans l’authentification.
• Ne pas utiliser de shell restreint pour les comptes invités ou suspects, permettant l’exécution de commandes non autorisées.
• Ignorer les logs et ne pas auditer les tentatives de connexion ou les modifications système.