Sécurisation des services Web XML créés à l'aide d'ASP.NET

Pour décider de la meilleure implémentation de sécurité pour un service Web XML, il faut commencer par considérer deux principes de sécurité clés : l'authentification et l'autorisation. L'authentification désigne le processus de validation d'une identité en fonction des informations d'authentification, telles que le nom et le mot de passe d'un utilisateur, auprès d'une autorité. Une fois l'identité authentifiée, l'autorisation détermine si l'identité est autorisée à accéder à une ressource.

Les services Web XML créés à l'aide d'ASP.NET peuvent choisir leurs options de sécurité parmi les options d'authentification et d'autorisation offertes par ASP.NET ou la sécurité SOAP personnalisée. ASP.NET fonctionne conjointement à Internet Information Services (IIS) pour fournir plusieurs options d'authentification et d'autorisation. Il est également possible de créer des options d'authentification personnalisées, telles que l'utilisation d'en-têtes SOAP. De plus, ASP.NET offre la capacité, connue sous le nom d'emprunt d'identité, d'exécuter une demande avec les informations d'authentification du client. Pour plus d'informations sur l'utilisation de l'emprunt d'identité, consultez Emprunt d'identité ASP.NET.

Sont récapitulées dans cette rubrique les options d'authentification et d'autorisation mises à disposition des services Web XML créés à l'aide d'ASP.NET. Pour un complément d'information sur les options de sécurité mises à disposition des applications Web ASP.NET, consultez Sécurité des applications Web ASP.NET.

Options d'authentification pour les services Web XML

Les services Web XML créés à l'aide d'ASP.NET disposent de plusieurs options pour authentifier les clients ; le problème est donc de connaître celui qui convient pour un service Web XML spécifique. Lors de la sélection de l'option de sécurité appropriée, un développeur doit choisir entre le niveau de sécurité et la performance. Pour certains services Web XML, il est essentiel que les informations d'authentification du client soient transmises sur le réseau par cryptage ; un algorithme cryptant ces informations est donc crucial. Par exemple, un développeur écrivant un service Web XML de traitement des cartes de crédit s'inquiète probablement plus du vol éventuel des informations d'authentification du client que de la charge mémoire de cryptage des informations relatives à la carte de crédit.

Le tableau suivant répertorie les options d'authentification mises à la disposition des services Web XML créés à l'aide de ASP.NET. Les options présentant le préfixe Windows font partie des options d'authentification Microsoft Windows mises à la disposition des services Web XML créés à l'aide de ASP.NET.

Résumé des options d'authentification

Pour toutes les options répertoriées ci-dessus, sauf l'utilisation des en-têtes SOAP, les paramètres de sécurité sont spécifiés à l'aide d'une combinaison de fichiers de configuration et de services IIS. Pour plus d'informations sur les fichiers de configuration, consultez Configuration ASP.NET. L'option des en-têtes SOAP personnalisés est détaillée après la section Autorisation, puisque cette solution implique l'authentification et l'autorisation.

Authentification Windows

IIS et ASP.NET fournissent la prise en charge de l'authentification des applications Web, y compris des services Web XML, à l'aide de la sécurité intégrée dans Windows. Windows fournit trois options d'authentification : de base, Digest et intégrée Windows. De plus, chaque option peut être utilisée avec SSL. Étant donné que toutes les options d'authentification Windows (sauf celle de base) cryptent les données sous une forme ou une autre, le niveau de cryptage supplémentaire offert par SSL n'est généralement utilisé que conjointement à l'authentification de base ou aux certificats clients.

Indépendamment de l'option d'authentification Windows utilisée, la configuration du service Web XML et de son client est identique. Les certificats clients constituent une exception ; la procédure de configuration du serveur et du client pour leur utilisation est donc fournie ci-après séparément. Il n'est pas nécessaire d'ajouter du code à un service Web XML pour utiliser l'authentification Windows, car les options d'authentification sont définies dans un fichier de configuration et dans IIS. Le code permettant de passer les informations d'authentification au service Web XML doit être ajouté au client du service.

Si SSL est choisi comme partie intégrante du mécanisme d'authentification utilisé par un service Web XML, il doit être configuré pour l'application Web hébergeant le service ou pour le service lui-même, à l'aide d'IIS. La description de service et, en conséquence, les classes proxy qu'elle génère reflèteront que le service Web XML utilise SSL (si SSL est utilisé pour accéder à la description de service et à la page d'aide du service). L'URL du service Web XML dans la description de service sera précédée de https. Pour plus d'informations sur la configuration de SSL, consultez la documentation IIS.

Pour configurer le service Web XML pour l'authentification Windows

1. Configurez le service Web XML pour utiliser l'authentification Windows, à l'aide d'IIS.

   IIS vous permet de spécifier la sécurité au niveau du répertoire ou du fichier. Si vous souhaitez spécifier la sécurité d'un service Web XML dans chaque fichier, définissez les autorisations sur le fichier .asmx dans IIS. Le fichier .asmx est le point d'entrée dans le service Web XML. Consultez la documentation IIS pour plus d'informations.

2. Modifiez le fichier de configuration pour spécifier l'authentification Windows.

   Affectez la valeur « **Windows **» à l'attribut mode de l'élément XML authentication dans un fichier de configuration. Pour plus d'informations sur la configuration d'un fichier de configuration, consultez Configuration ASP.NET. L'exemple de code suivant modifie un fichier de configuration afin de pouvoir utiliser l'authentification Windows.

   // Fragment of a Web.config file.
   <authentication mode= "Windows">
   </authentication> 
   

Pour passer les informations d'authentification d'un client à un service Web XML à l'aide de l'authentification Windows

1. Créez une nouvelle instance de la classe proxy pour le service Web XML. Si une classe proxy n'a pas été générée, consultez Création d'un proxy de service Web XML pour obtenir plus d'informations.

2. Créez une nouvelle instance de la classe NetworkCredential, en définissant les propriétés UserName, Password et Domain.

3. Créez une nouvelle instance de CredentialCache.

4. Ajoutez NetworkCredential à CredentialCache avec la méthode Add de CredentialCache.

5. Assignez l'instance de CredentialCache à la propriété Credentials de la classe proxy.

   Si l'authentification intégrée Windows est utilisée, vous devez alors affecter DefaultCredentials à la propriété Credentials.

   Lorsque la propriété Credentials est définie à CredentialCache.DefaultCredentials, le client négocie avec le serveur pour effectuer une authentification Kerberos et/ou NTLM en fonction de la configuration du serveur.

   L'exemple de code suivant définit les informations d'authentification du client passées à une méthode de service Web XML à l'aide de l'authentification Windows.

   Imports System
   Imports System.Web.Services.Protocols
   Imports System.Net
   Imports MyMath
   
   Public Class Calculator
      Public Shared Sub Main()
        ' Create a new instance of the proxy class to an
        ' XML Web service method. 
        Dim mathproxy As MyMath.Math = New MyMath.Math()
   
        ' Create a new instance of CredentialCache.
        Dim mycredentialCache As CredentialCache = New CredentialCache()
   
        ' Create a new instance of NetworkCredential using the client
        ' credentials.
          Dim credentials As NetworkCredential = New _          NetworkCredential(UserName,SecurelyStoredPasword,Domain)
   
        ' Add the NetworkCredential to the CredentialCache.
          mycredentialCache.Add(New Uri(mathproxy.Url), "Basic", _                             credentials)
   
        ' Add the CredentialCache to the proxy class credentials.
        mathproxy.Credentials = mycredentialCache
   
        ' Call the method on the proxy class.
        Dim result As Integer 
        result = mathproxy.Add(3,5)
     End Sub
   End Class 
   [C#]
   using System;
   using System.Web.Services.Protocols;
   using System.Net;
   using MyMath;
   
   public class Calculator
   {
     public static void Main() 
     {
        // Create a new instance of the proxy class to an XML
        // Web service method. 
        MyMath.Math math = new MyMath.Math();
   
       // Create a new instance of CredentialCache.
       CredentialCache credentialCache = new CredentialCache();
   
      // Create a new instance of NetworkCredential using the client
      // credentials.
      NetworkCredential credentials = new
         NetworkCredential(UserName,SecurelyStroredPassword,Domain);
   
      // Add the NetworkCredential to the CredentialCache.
      credentialCache.Add(new Uri(math.Url),                        "Basic", credentials);
   
      // Add the CredentialCache to the proxy class credentials.
      math.Credentials = credentialCache;
   
        // Call the method on the proxy class.
        int result = math.Add(3,5);
     }
   }
   

Authentification Certificats clients

Les certificats clients consistent en un mécanisme d'authentification sécurisé car les clients doivent envoyer un document électronique, appelé certificat client, identifiant un client à l'aide d'une connexion SSL au serveur Web. La connexion SSL crypte les informations d'authentification du client contenues dans le certificat client lorsqu'elles sont transmises sur le réseau. La communication entre le client et le serveur Web est cryptée à l'aide d'une combinaison de clés de cryptage envoyées par le client et de clés fournies par le serveur Web. Une fois la communication établie, seuls les ordinateurs client et serveur peuvent communiquer entre eux à l'aide de cette connexion SSL.

Un certificat client peut être obtenu à partir d'une autorité, pouvant être le serveur Web lui-même ou un intermédiaire de confiance entre le client et le serveur. Une fois le certificat obtenu et le serveur Web configuré pour accepter les certificats clients, un client peut envoyer le certificat au serveur Web sur une connexion SSL, lorsqu'un service Web XML est appelé. Pour plus d'informations sur les certificats clients, consultez la documentation IIS.

Pour configurer le service Web XML pour l'authentification Certificats clients

La liste suivante est une vue d'ensemble de la configuration d'ISS pour authentifier les clients à l'aide de certificats clients. Pour plus d'informations, consultez la documentation IIS.

1. Installez SSL.

2. Configurez l'application Web pour qu'elle accepte les certificats clients.

3. Modifiez le fichier de configuration afin de spécifier l'authentification Windows pour le service Web XML.

   Affectez la valeur « **Windows **» à l'attribut mode de l'élément XML authentication dans un fichier de configuration. Pour plus d'informations sur la configuration d'un fichier de configuration, consultez Configuration ASP.NET. L'exemple de code suivant modifie un fichier de configuration afin de pouvoir utiliser l'authentification Windows.

   // Fragment of a Web.config file.
   <authentication mode= "Windows">
   </authentication>
   

Pour passer les informations d'authentification d'un client à un service Web XML à l'aide de l'authentification Windows

1. Créez une nouvelle instance de la classe proxy pour le service Web XML. Si une classe proxy n'a pas été générée, consultez Création d'un proxy de service Web XML pour obtenir plus d'informations.

2. Créez une nouvelle instance de X509Certificate.

3. Appelez la méthode CreateFromCertFile pour charger le certificat client à partir d'un fichier.

   Un client peut obtenir un fichier de certificat auprès d'une autorité de confiance. Pour plus d'informations, consultez la documentation IIS.

4. Ajoutez X509Certificate à la collection ClientCertificates de la classe proxy.

   L'exemple de code suivant illustre comment un client de service Web XML passe ses informations d'authentification à l'aide d'un certificat client. Un certificat client publié par le serveur Web est chargé à partir d'un fichier avec la méthode CreateFromCertFile puis ajouté à la propriété ClientCertificates de la classe proxy.

   ' Instantiate proxy class to a Bank XML Web service.
   Dim bank As BankSession = new BankSession()
   
   ' Load the client certificate from a file.
   Dim x509 As X509Certificate = X509Certificate.CreateFromCertFile("c:\user.cer")
   
   ' Add the client certificate to the ClientCertificates property
   ' of the proxy class.
   bank.ClientCertificates.Add(x509)
   
   ' Call the method on the proxy class, which requires authentication
   ' using client certificates.
   bank.Deposit(500)
   [C#]
   // Instantiate proxy class to a Bank XML Web service.
   BankSession bank = new BankSession();
   
   // Load the client certificate from a file.
   X509Certificate x509 = X509Certificate.CreateFromCertFile(@"c:\user.cer");
   
   // Add the client certificate to the ClientCertificates property
   // of the proxy class.
   bank.ClientCertificates.Add(x509);
   
   // Call the method on the proxy class, which requires
   // authentication using client certificates.
   bank.Deposit(500);
   

Options d'autorisation pour les services Web XML

L'autorisation a pour objet de déterminer s'il faut accorder à une identité le type d'accès demandé pour une ressource particulière. Deux méthodes fondamentales permettent d'autoriser l'accès à une ressource particulière : l'autorisation de fichier et l'autorisation d'URL. L'autorisation de fichier peut être utilisée dès lors que l'authentification Windows est utilisée, puisque les autorisations sont définies dans IIS pour chaque fichier. L'autorisation d'URL peut être utilisée avec n'importe lequel des mécanismes d'authentification intégrés pris en charge par ASP.NET. Avec l'autorisation d'URL, la configuration s'effectue par l'intermédiaire d'un fichier de configuration, où les utilisateurs peuvent se voir accorder ou refuser de manière sélective l'accès à tout fichier associé à ASP.NET, y compris les fichiers .asmx.

Pour plus d'informations sur la configuration de l'autorisation par fichier, consultez la documentation IIS.

Pour plus d'informations sur la configuration de l'autorisation à l'aide d'un fichier de configuration, consultez Autorisation ASP.NET.

En-têtes SOAP – Solution personnalisée

Les mécanismes d'authentification Windows, y compris les certificats clients, reposent sur le transport HTTP, tandis que SOAP est indépendant du transport. Les services Web XML créés à l'aide d'ASP.NET utilisent SOAP sur HTTP. Une des raisons visant à créer un mécanisme d'authentification personnalisée est donc de découpler l'authentification du transport. Ceci est possible en passant les informations d'authentification dans l'en-tête SOAP.

Les en-têtes SOAP sont un excellent moyen de passer des informations hors bande ou non liées à la sémantique d'un service Web XML. Contrairement à l'élément Body d'un message SOAP, qui inclut les paramètres en entrée et out pour la méthode de service Web XML traités par elle, l'élément Header est optionnel et peut donc être traité par l'infrastructure. C'est-à-dire traité par l'infrastructure développée pour fournir un mécanisme d'authentification personnalisée.

La solution personnalisée suivante est créée à l'aide d'ASP.NET pour fournir un mécanisme d'authentification faisant appel aux en-têtes SOAP. Il faut procéder comme suit :

• Construction d'un module HTTP personnalisé qui s'exécute sur le serveur Web hébergeant les services Web XML.
• HTTP Module analyse les messages HTTP pour vérifier si ce sont des messages SOAP.
• Si HTTP Module détecte un message SOAP, il en lit les en-têtes.
• Si le message a l'en-tête SOAP avec les informations d'authentification, HTTP Module déclenche un événement global.asax personnalisé.

Pour modifier le service Web XML afin qu'il utilise l'authentification d'en-tête SOAP personnalisée, le service doit faire deux choses : spécifier qu'il attend l'en-tête SOAP contenant les informations d'authentification et autoriser l'accès client. Dans l'exemple donné, HTTP Module authentifie l'utilisateur et définit les propriétés Context qu'un service Web XML peut utiliser pour décider si l'accès du client est autorisé.

Un client de service Web XML envoie ses informations d'authentification au service Web XML puis ajoute l'en-tête SOAP prévu à la demande SOAP et la remplit avec les informations du client. Il est important de noter que, dans cet exemple, le texte est envoyé sur le réseau en texte clairement lisible (il n'est pas crypté). Si du texte en clair n'est pas suffisamment protégé pour votre application, ajoutez un algorithme de cryptage.

L'exemple de code suivant est un module HTTP qui analyse les messages HTTP pour les demandes SOAP. Si le message HTTP est un message SOAP, le WebServiceAuthenticationEvent personnalisé est déclenché.

using System;
using System.Web;
using System.IO;
using System.Xml;
using System.Xml.XPath;
using System.Text;
using System.Web.Services.Protocols;

namespace Microsoft.WebServices.Security {

      public sealed class WebServiceAuthenticationModule : IHttpModule 
      {
         private WebServiceAuthenticationEventHandler 
                       _eventHandler = null;

         public event WebServiceAuthenticationEventHandler Authenticate 
         {
           add { _eventHandler += value;}
           remove {_eventHandler -= value;}
         }
 
         public void Dispose() 
         {
         }

         public void Init(HttpApplication app) 
         {
           app.AuthenticateRequest += new
                      EventHandler(this.OnEnter);
         }

         private void OnAuthenticate(WebServiceAuthenticationEvent e) 
         {
           if (_eventHandler == null)
               return;

             _eventHandler(this, e);
             if (e.User != null)
                e.Context.User = e.Principal;
         }

         public string ModuleName
         {
           get{ return "WebServiceAuthentication"; }
         }

         void OnEnter(Object source, EventArgs eventArgs) {
           HttpApplication app = (HttpApplication)source;
           HttpContext context = app.Context;
           Stream HttpStream = context.Request.InputStream;

           // Save the current position of stream.
           long posStream = HttpStream.Position;

           // If the request contains an HTTP_SOAPACTION 
           // header, look at this message.
           if (context.Request.ServerVariables["HTTP_SOAPACTION"]                          == null)
              return;

           // Load the body of the HTTP message
           // into an XML document.
           XmlDocument dom = new XmlDocument();
           string soapUser;
           string soapPassword;

           try 
           {
             dom.Load(HttpStream);

             // Reset the stream position.
             HttpStream.Position = posStream;

             // Bind to the Authentication header.
             soapUser =
                 dom.GetElementsByTagName("User").Item(0).InnerText;
             soapPassword =
                 dom.GetElementsByTagName("Password").Item(0).InnerText;
           } 
           catch (Exception e) 
           {
             // Reset the position of stream.
             HttpStream.Position = posStream;

             // Throw a SOAP exception.
             XmlQualifiedName name = new
                          XmlQualifiedName("Load");
             SoapException soapException = new SoapException(
                       "Unable to read SOAP request", name, e);
             throw soapException;
           }

           // Raise the custom global.asax event.
           OnAuthenticate(new WebServiceAuthenticationEvent                        (context, soapUser, soapPassword));
           return;
      }
    }
}

L'exemple de code suivant est l'événement d'authentification personnalisée déclenché par HTTP Module, si une demande SOAP est reçue.

namespace Microsoft.WebServices.Security {
    using System;
    using System.Web;
    using System.Security.Principal;

    public class WebServiceAuthenticationEvent : EventArgs {
       private Iprincipal _IPrincipalUser;
       private HttpContext _Context;
       private string _User;
       private string _Password;

       public WebServiceAuthenticationEvent(HttpContext context)
       {
            _Context = context;
       }

       public WebServiceAuthenticationEvent(HttpContext context,
                       string user, string password)
       {
           _Context = context;
           _User = user;
           _Password = password;
       }
       public  HttpContext Context 
       { 
         get { return _Context;}
       }
       public IPrincipal Principal 
       { 
         get { return _IPrincipalUser;} 
         set { _IPrincipalUser = value;}
       }
       public void Authenticate()
       {
         GenericIdentity i = new GenericIdentity(User);
         this.Principal = new GenericPrincipal(i, new String[0]);
       }
       public void Authenticate(string[] roles)
       {
         GenericIdentity i = new GenericIdentity(User);
         this.Principal = new GenericPrincipal(i, roles);
       }
       public string User 
       {
         get { return _User; }
         set { _User = value; }
       }
       public string Password
       {
         get { return _Password; }
         set { _Password = value; }
       }
       public bool HasCredentials {
         get 
         {
              if ((_User == null) || (_Password == null))
                return false;
              return true;
         }
       }
    }
}

L'exemple de code suivant est le délégué de l'événement WebServiceAuthenticationEvent personnalisé.

namespace Microsoft.WebServices.Security 
{
   using System;

   public delegate void WebServiceAuthenticationEventHandler(Object sender,  WebServiceAuthenticationEvent e);
}

L'exemple de code suivant est un service Web XML qui définit l'en-tête SOAP Authentication qu'un client doit passer. Le service Web XML n'a pas à faire l'authentification. Il peut au contraire inspecter la propriété User.Identity.IsAuthenticated pour déterminer si HTTP Module a authentifié l'utilisateur.

<%@ WebService Language="C#" Class="SecureWebService" %>

using System;
using System.Web.Services;
using System.Web.Services.Protocols;

public class Authentication : SoapHeader {
  public string User;
  public string Password;
}

public class SecureWebService : WebService{
  public Authentication authentication;

  [WebMethod]
  [SoapHeader("authentication")]
  public string ValidUser(){
    if (User.IsInRole("Customer"))
      return "User is in role customer";

    if (User.Identity.IsAuthenticated)
      return "User is a valid user";
    return "not authenticated";
  }
}

L'exemple de code suivant est un client de service Web XML qui passe les informations d'authentification nécessaires à un mécanisme d'authentification d'en-tête SOAP personnalisée à un en-tête SOAP Authentication.

    // Create a new instance of an XML Web service proxy class.
    SecureWebService s = new SecureWebService();

    // Create the Authentication SOAP header and set values.
    Authentication a = new Authentication();
    a.User = user.Value;
    a.Password = password.Value;

    // Assign the Header.
    s.AuthenticationValue = a;

      string result = s.ValidUser();
      span1.InnerHtml = result;

Voir aussi

Sécurité des applications Web ASP.NET | Configuration ASP.NET | Création de services Web XML à l'aide d'ASP.NET | NetworkCredential | CredentialCache | X509Certificate