TD/TP Authentification Java

TD/TP Authentification Java
1. Introduction à l'authentification Java
Pour autoriser l'utilisation d'une ressource, les applications doivent d'abord authentifier
l'entité qui demande l'accès à la ressource. Dans le modèle de sécurité de Java (JAAS pour
Java Authentification and Autorisation Service) , les entités qui demandent d'accéder à des
ressources sont appelés sujets. Les entités peuvent être des personnes ou bien des services.
Par exemple, pour autoriser la lecture de l'intranet, l'application doit s'assurer que c'est bien
une personne de l'entreprise, faisant partie de l'équipe des dirigeants. Les sujets sont
représentés à l'aide de la classe prédéfinie javax.security.auth.Subject.
L'authentification est le processus qui vérifie l'identité d'une entité. Elle doit être
effectuée de manière sécurisée sinon le système peut subir une attaque et laisser passer
quelqu'un de non autorisé. Lors de l'authentification, l'entité doit fournir une preuve comme
qoui elle est bien celle pour qui elle se présente. La preuve peut être la paire (login, mot de
passe), de l'information stockée sur une carte à puce, des paramètres biométriques (rétine,
voix, etc.)…
Une fois authentifié, le sujet se voit attacher des identités, appelées principaux et
représentées par la classe javax.security.Principal. Par exemple, une personne
peut avoir un principal de nom ("Pierre Martin"), ainsi qu'un principal de numéro de sécurité
sociale (017804….)
En plus des principaux, les sujets peuvent avoir des attributs de scéurité qui définissent
des droits. Un droit peut contenir de l'information permettant l'authentification, de
l'information permettant aux sujets d'effectuer des opérations, etc. Par exemple, un droit peut
contenir des clé secrètes pour le chiffremet et le ddéchiffrement de messages cryptés. Les
droits ne sont pas prédéfinis dans JAAS et peuvent être implémentés de manière arbitraire.
2. Application d'authentification
Nous vous fournissons un exemple simple de programme qui utilise l'authentification Java.
Les sources contiennent :
− SimpleAuthentificationTest.java
− Miage3Principal.java
− Miage3LoginModule.java
− miage3_jaas.config
Le fichier SimpleAuthentificationTest.java contient les classes
SimpleAuthentificationTest et Miage3CallbackHandler. La première contient la
méthode main, alors que la deuxième participe à la gestion de la procédure
d'authentification.
Le fichier Miage3Principal.java contient la classe du même nom qui définit un
type d'identité pour les utilisateurs authentifiés.
Le fichier Miage3LoginModule.java contient le traitement principal

d'authentification.
Le fichier miage3_jaas.config est un fichier de configuration qui spécifie quel type
d'authentification va être utilisé.
3. Installation et test
Effectuer les opérations suivantes :
1) Créer un répertoire chez vous du nom Auth.
2) Récupérer le code source dans le placard électronique.
3) Mettre le sources java dans Auth/src.
4) Compiler les sources en mettant les calsses dans Auth/classes
Pour la compilation, il est possible de faire ceci en ligne (en tapant la commande
javac suivie de tous les fichiers .java) ou alors utiliser un environnement comme
Eclipse. Toujours faire attention au chemins (classpath).
5) Exécuter.
En faisant attention à bien positionner votre classpath et en vous mettenat dans
Auth (sinon modifier miage3_jaas.config), exécuter
java -Djava.security.auth.login.config=miage3_jaas.config
miage3.SimpleAuthentificationTest
Tester :
− Essayer de se connecter avec le login test1 et password test2.
− Essayer de se connecter avec login testUser et password test2.
− Essayer de se connecter avec login testUser et password testPassword.
− Observer l'exécution du programme.
4. Questions et compléments
4.1 La classe contenant la méthode main est SimpleAuthentificationTest. Identifier
l'endroit dans le code qui détermine le nombre autorisés d'essais de connexion.
4.2 Regarder le code de la classe Miage3LoginModuleIdentifier la portion de code qui
effectue la vérification du nom de login et du mot de passe. Modifier le code pour
permettre à un autre utilisateur avec un autre mot de passe à se connecter. Tester.
4.3 Modifier le programme pour qu'il prenne en compte un fichier de mots de passe formatté
de la manière suivante:
user0:password0
user1:password1
...

Indications
− Pour spécifier le nom de fichier de mots de passe, utiliser le fichier de configuration
(miage3_jaas.config) et utiliser les options. Vous pouvez vous inspirer de la
définition de l'option debug, de son traitement dans la méthode initialize dans la classe
Miage3LoginModule.
− Pour la lecture d'un fichier utiliser les classes FileReader et BufferedReader.
Pour traiter une ligne du fichier, utiliser la classe StringTokenizer.
Tester votre implémentation.
Dans le code de la methode login de la classe Miage3LoginModule, il y a la création d'un
objet de type NameCallback et d'un autre objet de type PasswordCallback. Pouvez-vous
expliquer à quoi servent-ils?
Cheminement des callbacks.
− Regarder le code de la classe Miage3CallbackHandler et trouver l'endroit
d'utilisation d'un NameCallback et d'un PasswordCallback.
Prendre la section concernant PasswordCallback et comprendre le
fonctionnement du code. A quel endroit, par exemple, récupère-t-on le mot de passe
tapé par l'utilisateur?
− Trouver l'endroit où est initilaisé Miage3CallbackHandler (il est passé en
paramètre à quoi?) Regarder la méthode login dans Miage3LoginModule et
l'appel à handle.
− Pouvez expliquer (énumérer les étapes) comment les callback sont utilisés?
4.6 Modifier le code pour rajouter un troisième callback de choix (ChoiceCallback) qui
permet de choisir ROOT ou NORMAL. Pour cela, rajouter l'instanciation de ce callback, son
traitement, ainsi qu'une fonction readChoice qui imprime les différents choix et lis celui
tapé par l'utilisateur.
4.7 Authentification d'un utilisateur. Regarder la méthode commit dans la classe
Miage3LoginContext. Quand cette méthode est-elle exécutée? Cette méthode rajoute
une identité (un principal) à l'utilisateur identifié. Modifier le code pour rajouter des identités
différentes en fonction du choix effectué (normal ou root). Pour cela, définir deux classes
Miage3NormalPrincipal et Miage3RootPrincipal qui étendent la classe
Miage3Principal.

5. Authorisation Java
Dans le modèle de sécurité de Java, des opérations peuvent être exécutées soit parce qu'elle
proviennent d'une source sûre (droits basés sur la provenance du code, code-based), soit
parce qu'elle sont demandées par des entités authentifiées (droits basés sur l'identité).
Pour utiliser l'autorisation Java, il faut fournir un fichier de configuration qui décrit les droits
qui sont donnés aux codes source ou aux entités identifiés.
Le format de ce fichier de configuration est le suivant :
grant signedBy "identité de source", codebase "provenance du code"
principal "principal_class_name", "principal_name"
principal "principal_class_name", "principal_name"
… {
permission permission_class_name "target_name",
"action", signedBy "noms";
permission permission_class_name "target_name",
"action", signedBy "noms";
…
}
6. Rajout de l'autorisation à l'application
Nous voulons différencier les utilisateurs authentifiés selon le critère NORMAL ou ROOT.
Pour les utilisateurs connectés en mode NORMAL, ceratines actions ne seront pas autorisées.
Pour les utilisateurs en mode ROOT, toutes les actions seront autorisées.
6.1 Modification des sources
1) Rajouter le fichier miage3_auth.policy. Regarder son contenu et expliquer
quels sont les droits spécifiéss.
2) Les autorisations concernent des actions, appelées des actions privéligiées. Rajouter la
classe Miage3Action (fichier Miage3Action.java) dans les sources. Cette classe
étendra la classe prédéfinie PrivilegedAction et implémentera la méthode
run(). Dans la méthode run, il faudra mettre les traitements "privilégiés" qui vont
être appelés par les utilisateurs authentifiés. D'après le fichier de configuration
miage3_auth.policy, ces traitements sont la lecture de deux proprités système et
la vérification de l'existence d'un fichier foo.txt. Pour la lecture des propriétés
système, regarder la classe System. Pour la manipulation des fichiers, regarder la
classe File.
3) Compiler : création des jars
Compilation des fichiers Java à la main
javac miage3/*.java miage3/loginpackage/*.java
miage3/identites/*.java
ou avec votre environnement
Si vous utilisez la deuxième manière, repérer bien où sont vos classes.
− Création de Miage3Test.jar contenant
miage3.Miage3Action.class
miage3.SimpleTest.class
miage3.Miage3CallbackHandler.class

jar -cfv Miage3Test.jar
<répertoire des classes>/miage3/Miage3Action.class <répertoire
des classes>/miage3/SimpleTest.class
<répertoire des classes>/miage3/Miage3CallbackHandler.class
− Création de Miage3Action.jar contenant Miage3Action.class
− Création de Miage3LM.jar contenant Miage3LoginModule.class
4) Tester.
6.2 Modification des droits.
Modifier le fichier de configuration pour qu'il donne les droits uniquement aux utilisateurs de
mode ROOT.
6.3 Rajouter une classe Miage3NormalAction qui affiche "Hello user!". Modifier le fichier
de configuration miage3_auth.policy pour donner aux utilisateurs en mode NORMAL le
droit d'évoquer le traitement dans Miage3NormalAction.
Recompiler.Tester.