LINUX:SELinux-Exercice de création d'un module personnel

---

→ retour à SELinux

---

But

J'ai voulu essayer de créer à module pour une application personnelle élémentaire.

Elle est basée sur deux programmes effectuant le même type de tâche mais écrits dans deux langages différents. L'un utilisera les droits SUID et SGID. La tâche consiste à lire un fichier texte et d'en ajouter le contenu à un autre fichier.

Python

Le premier programme est écrit en Python qui est un langage interprété.

Voici la source mise dans le fichier "lireecrire.py":

---

#!/usr/bin/python3
 
def main():
  filein  = open("/gestion/data/data.in","rt")
  fileout = open("/gestion/data/data.out","at")
 
  ligne = filein.readline()
  while ligne != "":
   fileout.write(ligne)
   ligne = filein.readline()
 
  filein.close()
  fileout.close()
 
main()

---

On remarque la première ligne qui permet de lancer directement ce fichier pour autant qu'il soit exécutable.

L'interpréteur Python est normalement installé au vu du nombre de logiciels qui l'utilisent.

C

Le second programme est écrit en C; il sera compilé.

Voici la source mise dans le fichier "readwrite.c":

---

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
 
void main()
 {
 char nomfichin[50];
 char nomfichout[50];
 char ligne[500];
 FILE   *fpti;
 FILE   *fpto;
 
 strcpy(nomfichin,"/gestion/data/datac.in");
 strcpy(nomfichout,"/gestion/data/datac.out");
 
 fpti=fopen(nomfichin,"rt");
 fpto=fopen(nomfichout,"at");
 
 while(fgets(ligne, sizeof(ligne), fpti) != NULL)
  {
  fputs(ligne, fpto);
  }
 
 fclose(fpto);
 fclose(fpti);
 
 exit(0);
}

---

Les fichiers d'entrée et de sortie portent des noms différents de ceux du programme fait en Python.

On doit compiler ce programme avec la commande suivante:

cc readwrite.c -lm -o readwrite.exe

L'exécutable porte le nom "readwrite.exe".

Il faut évidemment avoir installé le nécessaire minimum pour le développement en C.

dnf install cpp

Structure

Une arborescence est créée:

• /gestion: répertoire de base
• /gestion/bin: répertoire pour les programmes
• /gestion/data: répertoire pour les données

Toute ce contenu appartient à l'utilisateur "root":

chown -R root:root /gestion

Les droits d'accès sont les suivants:

chmod  777 /gestion
chmod  777 /gestion/data
chmod  644 /gestion/data/data.in
chmod  640 /gestion/data/datac.in
chmod  755 /gestion/bin
chmod 6711 /gestion/bin/readwrite.exe
chmod  755 /gestion/bin/lireecrire.py

Tout le monde doit pouvoir lire, écrire et créer de nouveaux fichiers dans le répertoire "/gestion/data".

Le script Python doit être lisible et exécutable par tout le monde et son fichier de données doit être lisible par tous. Le fichier de données résultant appartiendra à l'utilisateur qui a lancé ce programme.

Par contre l'exécutable C a les privilèges SUID et SGID et doit pouvoir être exécuté par tous. Ce qui implique que quand un utilisateur exécute ce programme, il s'exécutera avec les droits de son propriétaire "root" et donc le fichier à lire ne nécessite pas des droits d'accès à tout le monde et le fichier résultant appartiendra à l'utilisateur "root" avec ses droits.

On crée un utilisateur classique nommé "dupont" qui appartient au groupe "users" et son espace est dans le répertoire "/home/dupont". Il rejoint les utilisateurs SELinux "user_u":

adduser dupont -g users -Z user_u
passwd dupont

On lui attribue un mot de passe.

Quand on exécute ces programmes à partir de cet utilisateur hors du contexte SELinux, tout se passe bien. Mais dès que l'on active SELinux, leur exécution est interdite.

A noter que si on transposait ces applications dans l'espace de cet utilisateur, avec SELinux actif, il n'y aurait aucun problème.

Module pour les applications

Nous allons créer un premier module destinés aux applications. On le nomme "my-gestion".

Voici le premier fichier "my-gestion.te":

---

module my-gestion 1.0;
 
require {
       attribute domain;
       attribute entry_type, exec_type, file_type;
       class file { open map read execute ioctl entrypoint lock };
       class dir { add_name write search };
       class file { append create getattr };
       type bin_t;
       class dir { open read };
}
 
# création du domain
type gestion_t, domain;
 
# création du type pour les exécutables
type gestion_exec_t, entry_type, exec_type, file_type;
allow gestion_t gestion_exec_t:file { entrypoint execute getattr ioctl lock map open read };
 
# création du type pour les données
type gestion_data_t, file_type;
# nécessaire lors de l'exécution pour l'accès aux fichiers de données
allow gestion_t gestion_data_t:dir { add_name search write open read };
allow gestion_t gestion_data_t:file { append create getattr ioctl open read };
 
# accès à python
allow gestion_t bin_t:file { execute map };

---

On crée les types "gestion_t" pour le domain (attribut: "domain"), "gestion_exe_t" (attributs: "entry_type, exec_type, file_type") pour les exécutables et "gestion_data_t" (attribut: "file_type") pour les données. Chaque attribut doit être déclaré. L'attribut "entry_type" sera utilisé dans le second module pour la "transition" des droits des exécutables.

Les règles d'accès pour les types "gestion_exec_t" et "gestion_data_t" ont été déduits des alertes et semblent logiques.

Des droits d'accès spéciaux s'ajoutent à la fin pour pouvoir avoir accès à l'interpréteur Python par l'application "lireecrire.py".

---

→ retour à SELinux

---