CSharp WCF AuthWithInterceptors

C# - WCF - Authentification et autorisation avec intercepteurs. [Année de développement : 2018]

À propos des technologies d'application et du fonctionnement :

Technologies :

• Langage de programmation : C#

• Côté FrontEnd : Windows Présentation Foundation (WPF) - .NET Framework 4.6.1

• Côté back-end : Windows Communication Foundation (WCF) - .NET Framework 4.6.1

Installation/Configuration :

1. Restaurez les packages nécessaires sur le projet sélectionné, exécutez la commande suivante dans PM Console

   Update-Package -reinstall

À propos de l'application :

Dans cette application, je vais montrer comment utiliser l'autorisation et l'authentification à l'aide d'un service WCF dans les normes d'architecture d'entreprise.

Les principaux aspects que nous abordons ici sont :

• WCF

• Service d'authentification ASP.NET

• Authentification personnalisée

• Cookies HTTP

• Attribut d’autorisation PrincipalPermission

• Sujet ActuelPrincipal

• Intercepteurs de messages

En résumé, voici les activités impliquées :

• Créez une application de service WCF.

• Ajoutez un AuthenticationService.svc réutilisant le service d’authentification ASP.NET.

• Créez une classe de validateur d'utilisateur.

• Activez l'authentification personnalisée dans Global.asax.

• Renvoie le cookie si utilisateur valide.

• Modifier la configuration du service.

• Créez un ExecuteOperationsService.svc avec trois méthodes différentes nommées SumOperation, ReadOperation et WriteOperation.

• Décorez les méthodes de service avec l’attribut PrincipalPermission pour l’accès autorisé uniquement.

• Décorez la classe ExecuteOperationsService avec l’attribut AspNetCompatibilityRequirements.

• Implémentez des intercepteurs dans l’application serveur.

• Implémentez le code de paramètre d’identité sur les intercepteurs dans l’application de service.

• Modifiez le code côté service pour inclure le rôle au lieu du nom.

• Utilisez un ticket crypté pour stocker le nom d'utilisateur et les rôles.

• Créez l'application client et ajoutez des références aux deux services.

• Implémentez des intercepteurs dans l’application client.

• Créez une instance du service d'authentification et appelez la méthode Login().

• Recevez le cookie et stockez-le.

• Créez une instance ExecuteOperationsService et appelez SumOperation, ReadOperation et WriteOperation.

• Attacher le cookie au client ExecuteOperationsService

Points saillants utiles :

1. Ajoutez un AuthenticationService.svc réutilisant le service d'authentification ASP.NET.

Ajoutez un nouveau service WCF et nommez-le AuthenticationService.svc. Supprimez les fichiers associés puisque nous allons exposer le service d'authentification ASP.NET.

• Supprimer AuthenticationService.cs

• Supprimer IAuthenticationService.cs

Remplacez le contenu de AuthenticationService.svc par ce qui suit :

 <%@ ServiceHost Language="C#" Service="System.Web.ApplicationServices.AuthenticationService" Factory="System.Web.ApplicationServices.ApplicationServicesHostFactory" %>

2. Activez l'authentification personnalisée dans Global.asax et renvoyez un cookie si l'utilisateur est valide.

Ajoutez un nouvel élément Web > Global Application Class dans le projet.

Remplacez l'événement Appilcation_Start comme suit :

 protected void Application_Start (expéditeur d'objet, EventArgs e) { AuthenticationService.Authenticating += AuthenticationService_Authenticating; }

Ajoutez le gestionnaire d'événements suivant :

 private void AuthenticationService_Authenticating (expéditeur d'objet, AuthenticatingEventArgs e) { string role = string.Empty;     e.Authenticated = UserIsValid (e, rôles de référence) ;     e.AuthenticationIsComplete = true ;     if (e.Authenticated) { string selectedValue = FormsAuthentication.Encrypt(CreateFormsAuthenticationTicket(e, rôles));         OperationContext.Current.OutgoingMessageProperties[HttpResponseMessageProperty.Name] = SetSetCookieInResponseChannelHeaders(encryptedValue);     } }

La méthode extrait le nom d'utilisateur et le mot de passe de l'objet d'informations d'identification personnalisé de l'argument d'événement d'authentification. Ensuite, il valide le nom d'utilisateur et le mot de passe avec notre classe UserValidator.

La propriété Authentifié représente respectivement vrai / faux si un utilisateur est valide ou non.

3. Activer le service d'authentification et la compatibilité ASP.NET

Nous devons maintenant modifier le fichier web.config pour inclure les éléments suivants :

• Activer le service d'authentification

• Activer la compatibilité ASP.NET

   <système.web.extensions>
   <script>
     <WebServices>
       <authenticationService activé="true"/>
     </WebServices>
   </script>
  </system.web.extensions>

4. Implémentez les intercepteurs dans l'application serveur.

En effet, le code ci-dessus consistant à attacher un cookie au contexte d'opération semble être un travail fastidieux à chaque fois que nous devons effectuer un appel de service. Nous pouvons déplacer ces tâches en arrière-plan à l'aide des intercepteurs WCF.

MSDN : WCF Data Services permet à une application d'intercepter les messages de requête afin que vous puissiez ajouter une logique personnalisée à une opération. Vous pouvez utiliser cette logique personnalisée pour valider les données des messages entrants. Vous pouvez également l'utiliser pour restreindre davantage la portée d'une requête de requête, par exemple pour insérer une stratégie d'autorisation personnalisée par requête.

Voici les activités impliquées dans cette étape.

• Ajoutez le comportement de l'intercepteur dans le serveur web.config.

• Créez la classe Interceptor Behaviour. (Voir dans le projet)

• Créez la classe IdentityMessageInspector . (Voir dans le projet)

Le code suivant dans le fichier web.config du service juste sous <system.serviceModel>

 <système.serviceModel>
 <services>
   <service name="AuthenticationAndAuthorization.ExecuteOperationsService" behaviorConfiguration="InterceptorBehavior" />
 </services>

 <comportements>
   <comportements de service>
     <comportement>
       <serviceMetadata httpGetEnabled="true" />
       <serviceDebug includeExceptionDetailInFaults="true" />
     </comportement>
     <behavior name="InterceptorBehavior">
       <serviceDebug includeExceptionDetailInFaults="true" />
       <interceptorBehaviorExtension />
     </comportement>
   </serviceBehaviors>
 </comportements>

 <extensions>
   <extensionsdecomportement>
     <add name="interceptorBehaviorExtension" type="AuthenticationAndAuthorization.Extensions.IDispatchMessageInspector.InterceptorBehaviorExtension, AuthenticationAndAuthorization, Version=1.0.0.0, Culture=neutral"/>
   </behaviorExtensions>
 </extensions>

 <serviceHostingEnvironment aspNetCompatibilityEnabled="true" multipleSiteBindingsEnabled="true" />
</system.serviceModel>

5. Cryptage des cookies.

Notre cookie contient des informations facilement lisibles par les utilitaires d'examen HTTP tels que Fiddler. Cela rend les informations des cookies sujettes à des menaces de sécurité.

FormsAuthenticationTicket : L'espace de noms System.Web.Security nous fournit une classe pratique. Nous pouvons stocker les informations sur le nom d'utilisateur et les rôles dans cette instance de classe. La classe de ticket offre également des fonctionnalités d’expiration et de cryptage.

Le code suivant crée le ticket :

 private FormsAuthenticationTicket CreateFormsAuthenticationTicket(AuthenticatingEventArgs e, string role) => new FormsAuthenticationTicket(1, e.UserName, DateTime.Now, DateTime.Now.AddHours(24), true, rôles, FormsAuthentication.FormsCookiePath);

Le code suivant crypte et déchiffre le ticket :

 chaîne encryptéeValue = FormsAuthentication.Encrypt(CreateFormsAuthenticationTicket(e, rôles)); privé FormsAuthenticationTicket GetDecryptTicket(string encryptedTicket) => FormsAuthentication.Decrypt(encryptedTicket);

Nous pouvons maintenant transmettre le ticket sous forme de paire nom-valeur via les propriétés du message :

 private HttpResponseMessageProperty SetSetCookieInResponseChannelHeaders (string cookieValue) { Réponse HttpResponseMessageProperty = new HttpResponseMessageProperty ();     réponse.Headers[HttpResponseHeader.SetCookie] = FormsAuthentication.FormsCookieName + "=" + cookieValue ;     réponse de retour ; }

Vous devez spécifier le nom du cookie et les propriétés de la clé de la machine dans le fichier web.config comme indiqué ci-dessous :

 <mode d'authentification="Formulaires">
   <forms slideExpiration="true" name="AuthCookie" protection="All" timeout="20"/>
 </authentification>

 <machineKey déchiffrement="AES" validation="SHA1" decryptionKey="1523F567EE75F7FB5AC0AC4D79E1D9F25430E3E2F1BCDD3370BCFC4EFC97A541" validationKey="33CBA563F26041EE5B5FE9581076C40618DCC1218F5F447634EDE8624508A129"/>

6. Implémentez des intercepteurs dans l'application client.

Voici les activités impliquées dans cette étape.

• Ajouter un comportement d'intercepteur dans Client App.config

• Créez la classe Interceptor Behaviour. (Voir dans le projet)

• Créez la classe CookieMessageInspector . (Voir dans le projet)

Le code suivant dans le fichier App.config du service juste sous <system.serviceModel>

 <comportements>
 <endpointBehaviors>
   <nom du comportement ="InterceptorBehavior">
     <interceptorBehaviorExtension />
       </comportement>
 </endpointBehaviors>
</comportements>

Modifiez l'élément Behaviour Configuration de la section ExecuteOperations Service comme indiqué ci-dessous.

 <adresse du point de terminaison="http://localhost:8046/ExecuteOperationsService.svc" liaison="basicHttpBinding" liaisonConfiguration="BasicHttpBinding_IExecuteOperationsService" contract="ExecuteOperationsServiceReference.IExecuteOperationsService" name="BasicHttpBinding_IExecuteOperationsService" behaviorConfiguration="InterceptorBehavior"/>