Compte rendu TP1 : PAM (Pluggable

Authentication Modules)

Réalisé par :

- EL MOUDNI Mohamed Amine

- JABBARI Youssef
Table des matières
Table des illustrations ........................................................................................................................................ 3

I. Administration de PAM :......................................................................................................................... 4

1. Faites un schéma du fonctionnement de PAM................................................................................. 4

2. Quelles sont les familles de modules de PAM, comment cela se traduit-il dans le fichier de
configuration .................................................................................................................................................. 5

3. Configurez PAM pour que les services répondent aux exigences.................................................. 6

a. Configuration 1 : Accès à « admin » et « root » soit interdit via login ....................................... 7

b. Configuration 2 : Afficher le dernier accès (via ssh, login ou su) au moment de l'ouverture
de session ................................................................................................................................................... 7

c. Configuration 3 : L’admin soit limité à 10 process....................................................................... 8

d. Configuration 4 : Aficher le message /etc/motd en cas de succès ............................................ 9

II. Applications « PAM aware » : ...............................................................................................................11

III. Modules PAM ......................................................................................................................................14

2|Page
Table des illustrations
Figure 1 : Un modèle d'authentification clasique ................................................................................. 4
Figure 2 : Architecture PAM ........................................................................................................................ 5
Figure 3 : Création de l'utilisateur admin ................................................................................................ 7
Figure 4 : Ajouter un mot de passe pour Admin .................................................................................... 7
Figure 5 : Résultat de la première configuration ................................................................................... 7
Figure 6: Résultat de la deuxième configuration ................................................................................... 8
Figure 7: Résultat de la troisième configuration.................................................................................... 9
Figure 8 : Résultat de la troisième configuration ................................................................................10
Figure 9 : Test de l'application PAM Aware .........................................................................................13

3|Page
I. Administration de PAM :
1. Faites un schéma du fonctionnement de PAM
PAM : Pluggable Authentication Modules, est le système sous Linux qui permet de
nombreuses services et application d’authentifier les utilisateurs de manière centralisé. Initialement
développé par Sun Microsystems, il est devenu le système actuel d’authentification.

Les applications utilisent des différentes méthodes d’authentification :

connexion ftp http SGBD pop

/etc/passwd .htaccess Base de données

Figure 1 : Un modèle d'authentification clasique

Le modèle ci-dessous implique deux inconvénients majeurs de gestion :

− Comme chaque application possède sa propre méthode d'authentification, il devient

rapidement difficile de maintenir un système où de nombreux utilisateurs doivent accéder à de
nombreux services différents.
− Il n'est pas possible de s'authentifier pour un service autrement qu'en suivant la procédure
prévue par le programme.

Le système d’authentification PAM est un ensemble de bibliothèque partagées (ou modules). Pour
chaque modèle on trouve des différentes méthodes d’authentification.

Toute application communique avec le PAM pourra utiliser tous les modules pour authentifier les
utilisateurs :

4|Page
 Applications
connexion ftp http SGBD pop

PAM API
PAM
/etc/pam.d/
Pluggable Authentication Modules
PAM SPI

Login/mot anonyme deny Secure tty Autres

de passe modules

Modules PAM
Figure 2 : Architecture PAM

Les applications communiquent avec la bibliothèque PAM via l’interface de programmation

d’applications PAM (API : Application Programming Interface). Les modules PAM communiquent
avec la bibliothèque PAM via l’intermédiaire de l’interface de fournisseur de services PAM (SPI :
Service Provider Interface). Grace à cette architecture l’authentification des applications est deviens
facile et adaptés au besoin des utilisateurs, aussi la maintenance du système d’authentification est facile,
car on utilise des modules séparés est indépendants les uns les autres.

Pour créer des applications qui communiquent avec le système PAM il ne faut pas se soucier du type
d’authentifications et de l’implémentation dans le code.

2. Quelles sont les familles de modules de PAM, comment cela se traduit-il dans
le fichier de configuration

Pour faire la gestion d’authentification PAM a définit quatre familles au dite type :

5|Page
 − auth : Méthode d’authentification de l’utilisateur, généralement par une demande de
login/mot de passe, cette méthode vérifier que l’utilisateur à le droit d’accéder au service
demander et vérifier d’autres choses comme le groupe de l’utilisateur.
− account : Des modules pour la gestion des limites d’un compte, par exemple la définition
d’un plage d’horaires pour la connexion (possible dans la journée, et non dans la nuit par
exemple)
− password : Cette famille contient des modules de modification du mot de passe, ces
modules mise en place des règles et des contraintes à la création d’un nouveau mot de
passe, par exemple le nombre minimum de caractères.
− Session : Une fois l’authentification est établie ce module est activé, il sert à faire la gestion
des sessions. Cela peut inclure par exemple monter/démonter le répertoire personnel de
l’utilisateur, journaliser la connexion/déconnexion.

Normalement il existe un fichier de configuration pour chaque application ou service qui utilisent
PAM. Ces fichiers se trouvent dans le répertoire /etc/pam.d et portent le nom du service auquel il
sont rattachés.

Une ligne dans un fichier de configuration contient trois champs, et respecte la syntaxe suivante :

<Type> <Stratégie> <Chemin et arguments du module>

→ La famille de service est incluse dans le champ Type.

→ Suivant le résultat renvoyé par le module on applique la stratégie définit dans le deuxième champ.

→ Le dernier champ contient le chemin du module suivi des arguments appropriés.

3. Configurez PAM pour que les services répondent aux exigences

Afin de faire les configurations demandées il faut ajouter un utilisateur admin et ajouter un mot de
passe pour cet utilisateur, utilisant les commandes suivantes :

6|Page
 sudo useradd admin

Figure 3 : Création de l'utilisateur admin

sudo passwd admin

Figure 4 : Ajouter un mot de passe pour Admin

a. Configuration 1 : Accès à « admin » et « root » soit interdit via login

En premier lieu on ajout la ligne suivant dans le fichier correspondant dans le tableau :

Ligne à ajouter fichier

account required pam_access.so /etc/pam.d/login

Puis en ajoute les lignes de code suivantes dans le fichier /etc/security/access.conf :

- : root : ALL
- : admin : ALL

Pour tester on essaye de s’authentifier à admin via login, grâce aux modifications quand a fait on trouve
le résultat suivant :

Figure 5 : Résultat de la première configuration

b. Configuration 2 : Afficher le dernier accès (via ssh, login ou su) au moment de

l'ouverture de session
Pour afficher le dernier accés (via ssh, login ou su) on ajoute la ligne suivante dans les
fichiers correspondants dans le tableau :

7|Page
 Ligne à ajouter fichiers
session required pam_lastlog.so nowtmp /etc/pam.d/su, /etc/pam.d/login et
/etc/pam.d/sshd

Pour tester on lance les commandes suivantes :

login (username, password)

Commandes à exécutés su (username, password)

ssh loclhost/127.0.0.1

Figure 6: Résultat de la deuxième configuration

Configuration 3 : L’admin soit limité à 10 process

Pour faire cette configuration il faut ajouter la ligne dans le fichier correspondant :

Ligne à ajouter fichier

admin hard nproc 10 /etc/security/limits.conf

8|Page
Pour tester on lance la commande suivante :

Figure 7: Résultat de la troisième configuration

Commande de test ulimit -a

Pré-condition Switcher vers l’utilisateur admin
c. Configuration 4 : Aficher le message /etc/motd en cas de succès

Pour faire cette configuration il faut ajouter la ligne dans le fichier correspondant :

Ligne à ajouter fichier

session required pam_echo.so file=/etc/motd /etc/pam.d/login

Pour tester on lance la commande suivante :

Commande de test Sudo login <utilisateur>

9|Page
Figure 8 : Résultat de la troisième configuration

10 | P a g e
II. Applications « PAM aware » :

Afin de développer des applications permettant d’utiliser les modules PAM, il faut installer la paquet
libpam0g-dev, qui contient des fichiers d’entête C et des bibliothèques de développement.

Commande pour l’installation sudo apt-get install libpam0g-dev

Dans ce paquet il existe plusieurs fonctions de gestion d’authentification, pour les appelées on doit
inclure le fichier d’entête pam_appl.h et aussi pam_misc.h. Sinon pour gérer les opérations d’entrée
sortie on utilise le fameux fichier d’entet stdio.h

#include <stdio.h>
Fichiers d’entête #include <security/pam_appl.h>
#include <security/pam_misc.h>

On va définir les constantes pour forcer le RUSER à test et le RHOST à localhost :

Définir des constantes #define RUSER "test"

#define RHOST "localhost"

Initialiser un pointeur pour la fonction de conversation pam_conv, cette dernière est un callback défini
par l’application pour permettre une communication directe entre un module chargé et l’application.

static struct pam_conv conversation = { misc_conv, NULL }

On premier lieu on va vérifier si l’utilisateur a bien passé le nom d’utilisateur en paramètres, dans le
cas échoué on arrête le programme :

printf ("Attention! Vous avez oublié de fournir le nom

if (argc < 2) d'utilisateur.\n");
return 0 ;
printf ("Attention! L'application ne permet de prendre qu'un seul
else if (argc > 2) utilisateur.\n");
return 0 ;

Après on crée le contexte du PAM et on lance la transaction PAM avec la fonction pam_start. C’est
la première des fonctions PAM qui doit être appelée par une application. L’état de la transaction est
entièrement contenu dans la structure identifiée par ce handle, il est donc possible d’avoir plusieurs

11 | P a g e
transactions en parallèle. Mais il n’est pas possible d’utiliser le même handle pour différentes
transactions, un nouveau handle est nécessaire pour chaque nouveau contexte.

value = pam_start ("modules_service_pam" , argv[1], &conversation, &pam_h);

On vérifie après si le contexte a été bien initialisé

if (value == PAM_SUCCESS) Traitement à faire

else Affichage d’un message d’erreur

Si le contexte a été bien initialisé, on fait les traitements suivants :

Forcer le RUSER à test et le RHOST à localhost :

pam_set_item (pam_h , PAM_RUSER, RUSER);
pam_set_item (pam_h , PAM_RHOST, RHOST);

La fonction pam_set_item permet aux applications et aux modules de service PAM d’accéder aux
informations PAM de type PAM_RUSER et PAM_RHOST et autres (PAM_TTY, PAM_CONV,
etc.), et les mettre à jour.

PAM_USER : Le nom d'utilisateur de l'entité sous laquelle le service d'identité sera fourni. C'est-à-
dire qu'après authentification, PAM_USER identifie l'entité locale qui utilisera le service.

PAM_RHOST : Le nom d'hôte demandeur (le nom d'hôte de la machine à partir de laquelle l'entité
PAM_RUSER demande le service). C'est-à-dire que PAM_RUSER@PAM_RHOST identifie
l'utilisateur demandeur.

Après on demande de fournir le mot de passe de l’utilisateur passé en paramètres et essayer de

s’authentifier à l’aide de la fonction pam_authenticate.

pam_authenticate : Une fonction utilisée pour authentifier l’utilisateur. L’utilisateur est tenu de
fournir un jeton (token) d’authentification en fonction du service d’authentification, généralement un
mot de passe.

value = pam_authenticate (pam_h, 0);

12 | P a g e
Après si la valeur de pam_authenticate est vaut PAM_SUCCESS (L'utilisateur a été authentifié avec
succès), on détermine si le compte de l’utilisateur est valide pam_acct_mgmt, cette fonction vérifie
le token d’authentification et l’expiration du compte, ainsi que les restrictions d’accès.

value = pam_acct_mgmt (pam_h , 0);

Si la function retourne PAM_SUCCESS (Le jeton d'authentification a été mis à jour avec succès) on
affiche le message « welcome », sinon on affiche un message d’erreur.

Afin de tester notre code, on va le compiler avec la commande suivante :

gcc -o pam_aware_application pam_aware_application.c -lpam -lpam_misc

Avant d’exécuter l’application on doit faire la configuration suivante :

Figure 9 : Test de l'application PAM Aware

Ligne à ajouter fichier

auth required pam_unix.so
/etc/pam.d/su
account required pam_unix.so

13 | P a g e
III. Modules PAM

Comme le deuxième exercice on a besoin d’ajouter des fichiers d’entête pour utiliser des fonctions
afin de créer des modules PAM, donc pour cette raison on va inclure les fichiers suivants :

Fichiers d’entête
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <security/pam_appl.h>
#include <security/pam_misc.h>
#include <security/pam_modules.h>

Aprés on va définir quelques variables globales qu’on va les servirent dans notre aoolication :

Fichiers d’entête #define SECONDS 15

#define RHOST "localhost"

SECONDS : le délai d’attente si le résultat est faux dans notre cas 15 seconds

RHOST : le nom d’hôte dans notre cas localhost

La fonction pam_sm_setcred a pour but de modifier les références de l'utilisateur en fonction du

schéma d'autorisation correspondant. En général, un module d'authentification peut avoir accès à plus
d'informations sur un utilisateur que son jeton d'authentification. Cette fonction est utilisée pour
mettre ces informations à la disposition de l'application.

PAM_EXTERN int pam_sm_setcred (pam_handle_t *pam_h, int flags, int argc, const
char **argv)
{return PAM_SUCCESS;}

La function pam_sm_acct_mgmt a pour but de déterminer si l'utilisateur est autorisé à y accéder à

ce moment. Il est entendu que l'utilisateur a été préalablement validé par un module d'authentification.
Cette fonction vérifie d'autres éléments. Ces éléments peuvent être : l'heure ou la date, la ligne du
terminal, le nom d'hôte distant, etc. Cette fonction peut également déterminer des éléments tels que
l'expiration des mots de passe, et répondre que l'utilisateur en change avant de continuer. Pour cette
fonction il faut définir PAM_SM_ACCOUNT.

14 | P a g e
Dans un premier lieu on va récupérer l’information du RHOST pour la vérification à l’aide de la
fonction pam_get_item :

pam_get_item (pam_h, PAM_RHOST, (const void **)& rhost);

La fonction pam_get_item permet aux applications et aux modules de service PAM d'accéder aux
informations PAM dans notre cas PAM_RHOST et de les récupérer. En cas de retour réussi, rhost
contient un pointeur vers la valeur de l'élément correspondant.

Après on vérifie si rhost contient localhost :

if(rhost != NULL && strcmp (rhost, RHOST) return PAM_SUCCESS;

else return PAM_AUTH_ERR;

Après on va définir la fonction pam_sm_authenticate, qui est une implémentation du module de

service de l’interface pam_authenticate vu dans l’exercice précédent.

Dans cette fonction on va récupérer le nom de l’utilisateur avec la fonction pam_get_user :

value = pam_get_user (pam_h , &utilisateur , "Nom d’utilisateur: \n"));

Après on vérifie si l’application a pu récupérer le nom d’utilisateur :

if (value == PAM_SUCCESS) Traitement à faire

else Affichage d’un message d’erreur

Traitement 1 : Vérifier si la première lettre de l'utilisateur commence par un 'b' :

if (utilisateur[0] == 'b') Afficher le message « welcome »

else Traitement 2

15 | P a g e
Traitement 2 :

srand((unsigned) time(&t));
2.1 Générer deux nombres aléatoires modulo 20 a = rand() % 20;
b = rand() % 20;
2.2 Demander à l'utilisateur de calculer la
scanf("%d", &resultat);
multiplication et renvoyez le résultat
if (resultat == a * b) Traitement 2.3.1
2.3
Attendre 15 seconds et rendre la
Else
main à l’application
if (value == PAM_SUCCESS) Donner l'accès à l'utilisateur
2.3.1
Envoyer une erreur
else
d'authentification

Afin de tester notre code, on va le compiler avec les commandes suivantes :

gcc -fPIC -fno-stack-protector -c modules_pam.c

sudo ld -x --shared -o /lib/x86_64-linux-gnu/security/modules_pam.so modules_pam.o

Avant d’exécuter l’application on doit faire la configuration suivante :

Ligne à ajouter fichier

auth sufficient mypam.so /etc/pam.d/common-auth
account sufficient mypam.so /etc/pam.d/common-account

16 | P a g e