Microsoft France : Eric Verni Responsable relation technique dveloppeurs

Nor thwind tr ader Spcifications

Rvision 0.01

Table des matires

TABLE DES MATIRES................................................................................................................................................................................2 INTRODUCTION :...........................................................................................................................................................................................3 OBJECTIFS.......................................................................................................................................................................................................3 DFINITION FONCTIONNELLE................................................................................................................................................................4 GESTION DE LAUTHENTIFICATION ET DES AUTORISATIONS .................................................................................................5 LES SOURCES :.............................................................................................................................................................................................18 RFRENCES :..............................................................................................................................................................................................18

Introduction :
Lors des rencontres Visual Basic.NET, je vous ai prsent une application fonctionnelle, qui permettait dafficher trs simplement des donnes dans diffrents formulaires. Mon ide de dpart, tait de vous montrer quil tait possible avec Visual Basic .NET de crer des applications avec un Look and Feel la Windows XP, dutiliser de nouveaux contrles et proprits graphiques qui permettent dajouter des fonctionnalits dancrages de docking de partage de fentre et deffet de fondu enchan avec trs peu de lignes de codes Mon ide de dpart tait galement de monter que, sans penser Architecture et Programmation Oriente Objet, il tait relativement simple de concevoir une application de type MDI (Multiple Document Interface) client-serveur, alimentant des formulaires, par des donnes provenant dune base de donnes JET (Access). Pour des raisons de simplicit de dveloppement, certains de ces formulaires ont t construits laide de lassistant daccs aux donnes. Nanmoins, aujourdhui, nous sommes tous nous accorder, que cet assistant de cration de formulaire, prsente linconvnient majeur de lier trs fortement un type de fournisseur daccs aux donnes, au formulaire proprement dit. Si demain je dois changer de base de donnes, je suis oblig de modifier tous mes formulaires en fonction de la nouvelle base de donnes. Ce type de construction trs monolithique, nest pas optimale dans un contexte o lagilit dune entreprise devient primordiale, le changement devenant la rgle. Mon intention est donc de faire voluer tous les 2 ou 3 mois lapplication fonctionnelle MDI, en ajoutant des fonctionnalits, et en la rarchitecturant progressivement afin de bnficier des dernires innovations ou approches prouves par le march, et en suivant les principes du modle en couches prconis ici http://www.microsoft.com/france/msdn/technologies/technos/net/info/20030225_apparch_0.html Mon intention, nest pas de faire lapplication ultime en terme darchitecture, mais de vous prsenter une autre manire de dvelopper des applications (qui terme deviendront facilement plus volutives); de vous prsenter comment on utilise les modles de conceptions (Design pattern) qui nous faciliteront le dveloppement.

Objectifs
Les objectifs de cette dmonstration sont ambitieux et ne pourront se faire quau fil de leau Voici ce que je vous propose comme menu. Ajouter des fonctionnalits telles que : o La Scurit o La gestion des commandes o La gestion des employs, etc o Limpression Utiliser et tirer profit du modle en couches (n-tiers) Utiliser des modles de conceptions les fameux design patterns , pour rendre lapplication plus volutive. o Pouvoir changer dune base de donnes sans impact. Proposer une interface graphique, qui soit multi langage Faire voluer lapplication vers Visual Basic 2005, lorsquil sera disponible ;-) Dautres plats qui viendront sans doute en cours de route

Dfinition fonctionnelle
Tous les dveloppements commencent toujours par un recueil des besoins qui aboutit une dfinition fonctionnelle. Comme vous avez pu le constater, dans la version prsente au Tour VB, lapplication sappuie sur la fameuse base de donnes Northwind.mdb (Access), qui propose une gestion trs simplifie de vente de produits alimentaires. Ce que je me propose de faire dans cet exercice, cest de porter certaines fonctionnalits sur la plateforme .NET. Nous allons donc nous focaliser sur les tables suivantes : Clients Fournisseurs Employs Produits Commandes En terme darchitecture fonctionnelle, nous pouvons dfinir plusieurs Modules. Gestion Gestion Gestion Gestion Gestion Gestion de lauthentification et des autorisations (via des rles) des clients des fournisseurs des employs des produits de commandes

Aprs stre authentifi et avoir obtenu des autorisations, lutilisateur pourra selon les cas. 1. 2. 3. 4. 5. 6. Visualiser les donnes Rechercher les donnes Crer de nouveaux enregistrements Supprimer des enregistrements Mettre jour des enregistrements Filtrer les donnes

Filtre Commandes Clients Produits Employs

Ventes par Catgories Les 10 Meilleurs Clients Les 10 Produits les plus vendus Le meilleur Vendeur

Ventes par pays Les produits les plus chers Liste Vendeur

fonctionnalits somme toute restreinte et trs simple. Lintrt ici, nest pas de dvelopper une usine, mais de vous fournir un exemple concret de dveloppement, que vous aurez tout loisir de modifier et damliorer. Le code source est vous !

Gestion de lauthentification et des autorisations

La premire volution que je souhaite apporter mon application, est la prise en charge de la scurit. En effet, cest un sujet qui est malheureusement toujours abord en fin de dveloppement, alors quil devrait ltre ds le dbut de la conception et tout au long du cycle de dveloppement. Modliser un mcanisme dauthentification et dautorisation nest pas une sincure et plusieurs rfrences parlent sur le sujet (cf. liste des rfrences en fin darticle), je ne mtendrai donc pas. Nanmoins on a le devoir de se poser un certain nombre de questions. Quel mcanisme dautorisation dois-je utiliser ? o o Dois-je utiliser les mcanismes de la base de donnes ? Dois-je utiliser un mcanisme personnalis ?

Quel mcanisme dauthentification dois-je utiliser ? o o o o o Dois-je utiliser lauthentification Windows ? Dois-je utiliser un mcanisme personnalis ? Lidentit de lutilisateur doit-il traverser toutes les couches ? Est-ce que je dois pour excuter une tche donne me substituer lutilisateur authentifi ? Etc..

Encore une fois ces questions ne sont pas exhaustives mais peuvent nous donner un bon point de dpart pour notre stratgie dauthentification et de dautorisation.

Scnario :
Un cran permet lutilisateur de sauthentifier. Une fois fait, il reoit des autorisations qui lui serviront tout au long de ses prgrinations dans lapplication et lui permettront daccder ou pas des fonctionnalits. Les autorisations sont obtenues en fonction du rle de lutilisateur dans lentreprise. Par exemple, un simple commercial ne pourra visualiser que ses commandes, au contraire de son suprieur qui pourra voir les commandes de tous ses collaborateurs. Un simple commercial, ne pourra modifier sur la table Employs que les informations qui le concerne, mais pas les informations des autres employs, alors que le big boss Fuller Andrew aura un accs total. Il est important que linterface graphique et le code daccs aux donnes, sadaptent aux exigences de la scurit. A partir de ce scnario simple : Je peux identifier les ressources qui ont besoins dautorisations o Table Employs, gestion des commandes, etc

Choisir une stratgie dautorisation o Dans notre exemple, nous utiliserons la stratgie base sur des rles du framework .NET

Choisir une stratgie dauthentification

Comme pour la gestion des rles, nous choisirons une approche personnalise, c'est-dire que nous nallons pas utiliser lauthentification Windows.

En rsum, nous avons du travail, car nous allons implmenter tout ce beau monde la main. La bonne nouvelle, cest que, le Framework .NET nous fournis tous les lments ncessaires pour le faire.

Stratgie de gestion de lauthentification et des autorisations

Je vais mappuyer dans cet exercice sur les noms des employs et les rles contenus dans la table employs de la base de donnes Nortwind.mdb 1. Jai besoin dune mthode qui me permettra en fonction du nom de lemploy et de son mot de passe de lauthentifier. 2. Pour les rles, jai besoin dune mthode qui me permettra en fonction du nom de lemploy de retrouver les rles auxquels il appartient Vous avez peut-tre remarqu que, dans la table des employs, il ny a pas de mot de passe associ un employ. Ne sachant donc pas encore comment je vais implmenter lauthentification, ni comment dailleurs je vais retrouver les rles, je dois penser une mcanique qui va dans un premier temps me permette de me soustraire cette contrainte dimplmentation. En dautre terme, je veux pouvoir avoir toute la latitude pour tudier un systme de scurit satisfaisant. Par contre, il est important de commencer mon dveloppement et tester lapplication rapidement, afin par exemple de montrer un premier jet mon client. Il est possible galement que le systme de scurit soit dvelopp par un autre dveloppeur et quil ne soit pas encore prt. Dois-je attendre que le systme rel dauthentification et dautorisation soit prt avant de commencer mon application ? La rponse est non. Je vais donc utiliser un systme trs simple de scurit que je nomme bouchon, que je vais implmenter moi-mme et qui simulera le comportement du systme de scurit. Nanmoins, ce bouchon, je ne vais pas le dvelopper nimporte comment mais faire en sorte que lorsque le systme rel sera prt, il y ait peu dimpact voir pas du tout sur le dveloppement en cours lors de lintgration.

Les interfaces dfinissent un contrat

La premire chose qui me vient donc lesprit, est de crer deux interfaces qui dfinissent le contrat auquel devra adhrer par la suite les deux rels systmes dauthentification et dautorisation.

Public Interface IAuthentification Function Authentifier(ByVal NomUtilisateur As String, ByVal MotDePasse As String) As Boolean End Interface

Public Interface IRole Function ChargerRoles(ByVal NomUtilisateur As String) As String() End Interface Ces deux interfaces, sont disponibles dans le fichier Securite.vb du projet VBTour.Securite.vproj Remarque :

Par convention et pour des raisons de clart, on prfix les noms dinterfaces avec un I Majuscule suivi de la premire lettre en Majuscule et le reste en minuscule.

Ensuite je vais implmenter ces deux interfaces dans deux assembly VBTour.Securite.Bouchon.Authentification et VBTour.Securite.Bouchon.Role Remarque :

que

je

nomme

Pour des raisons de clart, il est de bon ton dutiliser une syntaxe dans les espaces de nom qui vous permettront de vous y retrouver comme VBTour.Securite.Bouchon

Dans ces deux assembly, il y a une classe nomme AuthentificationBouchon et RoleBouchon dfinies comme suit : Public Class AuthentificationBouchon Implements VBTour.Securite.IAuthentification End Class Et Public Class RoleBouchon Implements VBTour.Securite.IRole End Class Pour linstant la compilation ne passe pas, car les deux classes doivent imprativement implmenter les mthodes des interfaces IAuthentification et IRole. Et oui ce sont des contrats que doivent honorer ceux qui y adhrent Faisons-les voluer comme ceci. Public Class AuthentificationBouchon Implements VBTour.Securite.IAuthentification Public Function Authentifier(ByVal NomUtilisateur As String, String) As Boolean Implements IAuthentification.Authentifier End Function End Class Public Class RoleBouchon Public Function ChargerRoles(ByVal NomUtilisateur IRole.ChargerRoles End Class As String) As String() Implements ByVal MotDePasse As

Jusquici tout va bien, mais mes deux fonctions ne font pas grand-chose !!! Je vais donc ajouter mon bouchon, du code trs simple qui me permettra de simuler un systme de scurit. (Encore une fois je prcise ici, que le rel systme de scurit, est encore en cours dtude, voire le dveloppeur qui le construit nest pas encore prt). La partie implmentation de notre systme de bouchon se calquera simplement la table des employs de la base Northwind.

Dans cette table je sais que jai une liste demploys avec leurs rles reprsents par le titre

Employees
Last Name First Name Davolio Fuller Leverling Peacock Suyama King Callahan Nancy Andrew Janet Margaret Michael Robert Laura Title Sales Representative Vice President, Sales Sales Representative Sales Representative Sales Manager Sales Representative Sales Representative Inside Sales Coordinator Sales Representative

Buchanan Steven

Dodsworth Anne

Ma fonction Authentifier() sera trs simple, je nutiliserai pas de mot de passe dans mon bouchon, mais uniquement le nom de lemploy. (Pas trs scuris nest-ce pas ?)

Public Function Authentifier(ByVal NomUtilisateur As String, ByVal MotDePasse As String) As Boolean Implements IAuthentification.Authentifier 'Dans ce bouchon, je ne test pas le mot de passe Select Case NomUtilisateur.Trim.ToLower() Case "davolio", _ "fuller", _ "leverling", _ "peacock", _ "buchanan", _ "suyama", _ "king", _ "callahan", _ "dodsworth", _ "ericv" Return True Case Else Return False End Select End Function

Si le nom dutilisateur pass en paramtre est dans la liste prvu, je retourne vrai ce qui lauthentifie, sinon je retourne faux. Vous voyez ici un systme de bouchon trs simple et rapide implmenter.

De la mme manire pour la mthode ChargerRoles() Public Function ChargerRoles(ByVal NomUtilisateur IRole.ChargerRoles Select Case NomUtilisateur.Trim.ToLower() Case "fuller" Dim strRoles() As String = {"Vice President, Sales", "Sales Manager", "Sales Representative"} Return strRoles Case "callahan", "buchanan" Dim strRoles() As String = {"Sales Manager", "Sales Representative"} Return strRoles Case "davolio", "leverling", "peacock", "suyama", "king", "dodsworth" Dim strRoles() As String = {"Sales Representative"} Return strRoles Case Else Dim strRoles() As String = {""} 'Ne fait partie d'aucun rles Return strRoles End Select End Function Je recherche les rles en fonction du nom dutilisateur. A noter quun utilisateur, peut tre dans diffrents rles. En rsum, je me retrouve donc, avec trois assembly : VBTour.Securite.dll, contenant des interfaces IAuthentification et IAuthorisation mais pas dimplmentation. VBTour.Securite.Bouchon.Authentification.dll, implmentant dans la classe AuthentificationBouchon le contrat fournit par linterface IAuthentification VBTour.Securite.Bouchon.Role.dll, implmentant dans la classe RoleBouchon le contrat fournit par linterface IRole As String) As String() Implements

Jusquici nous avons fait la moiti du chemin, faisons lautre moiti. Tout dabord, posons nous les questions suivantes : Comment linterface utilisateur va utiliser nos assembly ci-dessus ? Quel mcanisme implmenter pour viter limpact dun changement de systme dauthentification et dautorisation ?

10

Fabrique ma Classe
Si je souhaite avoir accs aux mthodes Authentifier() et ChargerRoles(), la premire chose qui me viendrai lesprit, cest dajouter une rfrence aux deux assembly de bouchonnage et dimplmenter lappel comme ceci. Friend Shared Function MotDePasse as string) As Boolean IUAuthentifier(ByVal NomUtilisateur As String,ByVal

Dim objAuthentifier As New AuthentificationBouchon() If objAuthentifier.Authentifier(NomUtilisateur, "") Then Dim objRole as New RoleBouchon Dim strRoles() As String = objRole.ChargerRoles(NomUtilisateur) Code supprim pour plus de clart Return True End If Return False End Function Remarque : Vous trouverez cette mthode statique dans la classe IUSecurite.vb du projet VBTour Exemple.vbproj Je lai prfix IU (Interface Utilisateur) pour ne pas la confondre avec la mthode Authentifier() de linterface IAuthentification

Bien que cela fonctionne correctement, ny voyez-vous pas un lger problme ? Plus haut dans cet article, je vous ai dit, que je souhaitais qu chaque changement de systme dauthentification et dautorisation il ny ait pas dimpact sur le dveloppement de linterface graphique. C'est--dire que je ne sois pas oblig de la recompiler lors de lintgration. Or le fait mme dajouter une rfrence aux deux assembly et dutiliser explicitement les classes AuthentificationBouchon et RoleBouchon, ajoute un impact de taille. Jai cr sans le savoir un couplage fort entre mon interface graphique et mes deux objets. Vous me direz, il suffit que le dveloppeur du systme de scurit prvoie la mme convention de nom que moi pour les assembly et les classes et le tour est jou !!! Non, car penser ainsi induit des limites et les contextes rels peuvent dailleurs faire que les deux dveloppeurs nvoluent pas au sein de la mme structure ou organisation. Cest donc trop sujet erreur. Les seuls contrats auxquels doivent adhrer les systmes de scurit dans notre cas, sont les interfaces IAuthentification et IRole et non pas les noms, car vous pourriez faire appel par la suite diffrents fournisseurs qui ont leur propre nomenclature et ne connaissent pas la votre. Alors comment faire pour que mon Application soit faiblement couple mes objets ? En dautres termes, comment faire pour que mon application soit rellement indpendante de mon bouchon, mais pourtant quelle utilise bien son implmentation ? Nous allons utiliser un principe issu dun modle de conception dit modle crateur la fabrique de classe. Je ne vais pas dtailler ce modle ici, mais je vous encourage allez lire larticle Exploration du modle de fabrique de classe (Factory Design Pattern), article que votre serviteur a traduit. Plus simplement, lapplication cliente, va dlguer la cration des classes une fabrique et utiliser comme rfrence statique les deux interfaces IAuthentification et IRole auxquelles devront adhrer tous les systmes de scurit, qui veulent interagir avec notre application cliente.

11

Pour raliser ma fabrique, je vais implmenter une mthode qui me retournera un objet (exactement comme le fait CreateObject() dans Visual basic 6.00), puis je vais convertir cet objet laide des interfaces IAuthentification et IRole, afin dutiliser les fonctions Authentifier() et ChargerRoles(). Ce nest pas encore trs clair dans les esprits, mais un bout de code devrait rsoudre ce problme. Pour viter de rfrencer les deux assembly dans mon application cliente, je dois les charger dynamiquement. Pour cela, je vais utiliser le mcanisme dintrospection dune assembly fournit par lespace de Nom System.Reflection.

Function FabriqueLaClasse()As object Dim ass as [Assembly] ass=[Assembly].LoadFile("c:\....\VBTour.Securite.Bouchon.Authentification.dll") Dim MonType as Type =ass.GetType(VBTour.Securite.Bouchon.Authentification.AuthentificationBouchon) Return Activator.CreateInstance(monType) End Function Exemple de fabrique de classe 1. Je dclare un objet Assembly Dim ass as [Assembly] 2. Je charge lassembly Dynamiquement en fonction de son chemin daccs ass=[Assembly].LoadFile("c:\....\VBTour.Securite.Bouchon.Authentification.dll") 3. Je suis prt maintenant dclarer la classe en utilisant lobjet Type Dim monType as Type 4. Je retrouve dans lassembly le type en fonction du nom de la classe monType =ass.GetType(VBTour.Securite.Bouchon.Authentification.AuthentificationBouchon) Remarque : A Noter le nom complet de la classe dans lappel la mthode GetType() MonType

5. Puis la dernire opration est dinstancier la classe et de la retourner lappelant Return Activator.CreateInstance(monType) Voila cest fait, rien dinsurmontable, en quelques lignes de codes, nous avons construit une fabrique de classe simple et qui fonctionne. Nous pouvons donc modifier la fonction IUAuthentifier en consquence Pour mmoire, javais dclar une variable objAuthentification de type VBTour.Securite. AuthentificationBouchon.

12

Il faut dsormais la dclarer en tant que IAuthentification et dlguer sa cration notre Fabrique qui retourne un System.Object. System.Object est lanctre de tous les objets dans .NET, et ne peut connatre tous ses enfants, voire tous ses petits enfants qui viennent de natre. Il ne connat donc pas la mthode Authentifier() Cest l quinterviennent nos interfaces. Rappelez vous, ce sont des coquilles vides qui nimplmentent rien. Par contre, elles vont nous permettrent de typer lobjet pour quil prenne conscience des mthodes des interfaces. Dim objAuthentification as IAuthentification Appel de la mthode FabriqueDeClasse() et conversion explicit en IAuthentification objAuthentification = CType(FabriqueLaClasse(),VBTour.Securite.IAuthentification)

Remarque : Ce que je viens de dire nest pas tout fait vrai avec le compilateur Visual Basic.NET. En effet nous pourrions trs bien nutiliser que le type System.Object, mais dans ce cas l, le compilateur ajoute toute une mcanique pour excuter le code en mode dit Late Binding ce qui est beaucoup moins performant que la mthode que je vous propose dite EarlyBinding. Pour pouvoir bnficier du Late Binding, il faut utiliser linstruction Option Strict Off Mais si vous souhaitez, ajouter de la robustesse et de la rigueur votre code, je vous conseille fortement dans tous vos projets dutiliser lOption Strict On

Cest l o la magie opre, car je peux dsormais manipuler naturellement les mthodes de lobjet objAuthentification. Exemple : Friend Shared Function MotDePasse as string) As Boolean Dim objSecurite As object Dim objAuthentification As VBTour.Securite.IAuthentification Fabrique la classe objSecurite=FabriqueLaClasse() objAuthentification = CType(objSecurite, VBTour.Securite.IAuthentification) 'Authentification If objAuthentifier.Authentifier(NomUtilisateur, MotDePasse) Then Code supprim pour plus de clart Return True End If Return False End Function IUAuthentifier(ByVal NomUtilisateur As String,ByVal

Remarque : Pour linterface IRole, il suffit dutiliser le mme principe.

Vous retrouverez la fabrique de classe dans le projet VBTour.Fabrique.vbproj., et vous pourrez constater quelle est lgrement diffrente par rapport celle que nous venons de voir. Jai pouss le bouchon un peu plus loin (cest le cas de le dire).

13

Au lieu de coder en dur le chemin daccs une assembly, et le nom de la classe instancier, je vais chercher ces deux variables dans un fichier de configuration nomm App.config. Cette technique nous permettra de changer dassembly dynamiquement (sans recompilation), en modifiant simplement des lignes dans un fichier.

Private Shared Function FabriqueLaClasse(ByVal CheminAssembly As String, _ ByVal NomClasse As String) As Object Dim ass As [Assembly] '1) Retrouve le chemin de l'assembly dans le fichier de 'configuration Dim strCheminAssembly As String = _ ConfigurationSettings.AppSettings(CheminAssembly) '2) Charge l'assembly dynamiquement ass = [Assembly].LoadFile(strCheminAssembly) If ass Is Nothing Then strCheminAssembly)) End If '3) Retrouve dans le fichier de configuration ' la classe qui sera instancie dynamiquement Dim strClass As String = _ ConfigurationSettings.AppSettings(NomClasse) '4) instancie cette classe et retourne la Dim monType As Type monType = ass.GetType(strClass) If monType Is Nothing Then Throw New Exception(String.Format("La classe {0}, l'assembly {1}", strClass, strCheminAssembly)) End If Return Activator.CreateInstance(monType) End Function Au lieu de laisser le consommateur convertir mon objet en un type IAuthentification ou IRole, je dlgue la conversion une fonction explicite. n'existe pas dans Throw New Exception(String.Format("Fichier {0} non trouv",

Public Shared Function FabriqueLaClasseAuthentification() As IAuthentification Return CType(FabriqueLaClasse("CheminAssemblyAuthentification", "NomClasseAuthentification"), IAuthentification) End Function Public Shared Function FabriqueLaClasseRole() As IRole Return CType(FabriqueLaClasse("CheminAssemblyRole", "NomClasseRole"), IRole) End Function

14

Ma mthode IUAuthentifier() devient plus claire Friend Shared Function IUAuthentifier(ByVal NomUtilisateur As String, ByVal MotDePasse As String) As Boolean Dim objAuthentification As VBTour.Securite.IAuthentification pas de conversion, cest la function qui le fait pour moi, le code est plus lisible et explicite objAuthentification = FabriqueLaClasseAuthentification() If objAuthentification.Authentifier(NomUtilisateur, MotDePasse) Then Pas de conversion Dim objRole As VBTour.Securite.IRole objRole = FabriqueLaClasseRole() 'Retrouve les rles Dim strRoles() As String = objRole.ChargerRoles(NomUtilisateur) Return True End If End If Return False End Function

Si on regarde de plus prt la mthode FabriqueLaClasseAuthentification(), on voit quelle passe la mthode FabriqueDeClasse(), deux variables CheminAssemblyAuthentification et NomClasseAuthentification Que sont-elles et quoi servent-elles ? Ce sont des cls qui vont permettrent la mthode FabriqueDeClasse() de retrouver dans un fichier de configuration, le chemin de lassembly et le nom de la classe instancier. Pour que cela fonctionne, il suffit davoir un fichier nomm App.config avec les informations suivantes. <configuration> <appSettings> <add key="CheminAssemblyAuthentification" value="C:\scurit\VBTour.Securite.Bouchon.Authentification\bin\VBTour.Securite.Bouchon. Authentification.dll" /> <add key="NomClasseAuthentification" value="VBTour.Securite.Bouchon.Authentification.AuthentificationBouchon" /> </appSettings> </configuration>

Remarque : Cest le mme principe pour la mthode FabriqueLaClasseRole() et pour toutes les autres fabriques que nous pourrons dvelopper par la suite

Le jour o mon rel systme de scurit sera prt (dans un avenir proche), je naurais plus qu changer dans ce fichier de configuration, le chemin daccs mon Assembly, et le nom de la classe et le tour est jou. Mais attention, il faudra que cette ou ces assembly, adhre(nt) aux contrats IAuthentification et IRole.

15

Affectation des politiques aux Rles

Rsumons la situation Lutilisateur sauthentifie via un formulaire Si il est authentifi, on recherche les rles auxquels il appartient

Mais est-ce que cela suffit ? Comment utiliser rellement ces rles dans notre application ? Puisque nous avons dcid d'utiliser un systme personnalis, nous allons utiliser des classes du framework .NET prvues cet effet. Tout dabord pour symboliser un utilisateur dans lapplication, nous allons manipuler la classe GenericIdentity, qui reprsente un objet d'identit quelconque, par opposition la classe WindowsIdentity qui reprsente l'utilisateur connect Windows. Pour ce faire, nous instancions un objet de type GenericIdentity Dim IdentiteUtilisateur As New GenericIdentity(NomUtilisateur) Ensuite nous allons affecter les rles un objet GenericPrincipal qui reprsentera les rles pour lutilisateur en cours. Dim UtilisateurPrincipal As GenericPrincipal UtilisateurPrincipal = New GenericPrincipal(IdentiteUtilisateur,strRoles) GenericPrincipal, nous impose de dfinir nos propres rles, par opposition la classe WindowsPrincipal, qui reprsente un objet permettant du code appelant de vrifier l'appartenance de lutilisateur un rle Windows prdfini tel que UTILISATEURS, ADMINISTRATEURS, INVITES, SYSTEMS, etc.. Enfin jindique au systme que je veux utiliser des politiques personnalises AppDomain.CurrentDomain.SetPrincipalPolicy(PrincipalPolicy.UnauthenticatedPrincipal) Puis jaffecte ces politiques la thread Courante. Thread.CurrentPrincipal = UtilisateurPrincipal

Remarque : Vous retrouverez dans le projet VBTour.Securite.Politique.Generique.vbproj la mthode AffecterPolices() qui implmente cette fonctionnalit. Cette mthode est dailleurs appele par la mthode UIAuthentifier de mon interface graphique. Vous remarquerez galement, que jai utilis pour ce projet la fameuse Fabrique De Classe. En effet, je ne sais pas si un jour, je ne vais pas dcider dutiliser un autre systme de politiques

A quoi cela ma servi daffecter la thread courante lutilisateur et les rles ? Tout simplement, pouvoir nimporte quel moment vrifier dans quel(s) role(s) fait parti lutilisateur. En effet lobjet CurrentPrincipal, possde la mthode static IsInRole() qui renvoi vrai si lutilisateur fait partie du rle que lon prcise.

16

Reprenons nos cas concrets de la base Nortwhind. Nous avions un certain nombre dutilisateurs : Fuller, qui faisait partie des rles : Vice President Sales, Sales Manager, Sales Representative. Buchanan : Sales Manager, Sales Representative Davolio : Sales Representative Si dans mon application jai trois boutons qui sont par dfaut inactifs et que jajoute le code suivant : Bouton1.Enabled= CurrentPrincipal.IsInRole(Vice President Sales) Bouton2.Enabled = CurrentPrincipal.IsInRole(Sales Manager) Bouton3.Enabled= CurrentPrincipal.IsInRole(Sales Representative) Que croyez-vous quil se passe si davolio se connecte ? Seul bouton3 sera actif Si Buchanan se connecte ? Bouton2 et Bouton3 seront actifs Et Fuller ? Tous les boutons actifs Remarque : Vous retrouverez le code qui implmente ce mcanisme dans la mthode ActiveLaSecuritePourLesControlesDuFormulaireMDI() de la classe IUSecurite.vb du projet VBTour Exemple.vbproj.

Conclusion
Nous sommes rellement loin dun systme scuris, mais nous avons commenc mettre en place un mcanisme qui va nous permettre de modifier des implmentations sans avoir trop dimpact dans le dveloppement de lapplication Client MDI. Ce mcanisme est connu sous le doux terme de design pattern, fabrique de classe (ou dun driv). Nous avons vu comment, avec les classes .NET, nous pouvons trs facilement affecter une identit et des rles la thread courante, pour pouvoir rutiliser cette identit nimporte quel moment dans lapplication. Nanmoins, se pose encore un certains nombres de questions. La dfinition, des rles en lui-mme est trs fortement lie la base de donnes Northwind, et si je veux changer et utiliser dautres rles ? Par exemple les rles Windows ? Comment implmenter lautorit dauthentification ? La Gestion des rles ? Est-ce que mon application est rellement scurise ? Jessaierai dy rpondre la prochaine fois, et le prochain article, portera sur la rel mcanique dauthentification et gestion des rles. Attendez vous donc voir de la cryptographie, de laccs des bases de donnes, voir un audit de scurit sur code.

17

Restez lcoute, et merci davoir tenu jusquici.

Les Sources :
Les sources sont disponibles dans le fichier VBTour Exemple.zip, quil suffit de dcompresser directement sur la racine c:\. Un rpertoire VBTour Exemple est cre avec comme arborescence Fichier solution charger dans Visual Studio.NET VBTour Exemple.sln VBTour Exemple.suo Source de linterface Graphique Source de la fabrique de classe Source des interfaces Source du lauthentification bouchon pour \IU \VBTour.Fabrique \VBTour.Securite \VBTour.Securite.Bouchon.Authentification \VBTour.Securite.Bouchon.Role \VBTour.Securite.Politique.Generique

Source du bouchon pour la gestion des rles Source des politiques gnrique

Rfrences :
Pour ceux qui ne veulent pas attendre - Security For Microsoft Visual Basic .NET (Ed Robinson, Michael James Bond) MSPress - Ecrire du code Scuris 2 Edition (Michael Howard et David LeBlanc) - Building Secure Microsoft ASP.NET Applications - Design Patterns Catalogue de modles de conception rutilisables (Erich Gamma, Richard Helm, Ralph Johnson et John Vlissides) (Gang of Four)

18