Vorgehensweise: Ausführen von benutzerdefinierter Authentifizierung mit SOAP-Headern

Artikel
02/27/2011

Dieses Thema bezieht sich auf eine veraltete Technologie. XML-Webdienste und XML-Webdienstclients sollten nun mithilfe der folgenden Technologie erstellt werden: Windows Communication Foundation.

Die folgende benutzerdefinierte Lösung wird mit ASP.NET erstellt, um einen Authentifizierungsmechanismus mit SOAP-Headern bereitzustellen. Die Lösung umfasst ein benutzerdefiniertes IHttpModule-Objekt auf dem Webserver, das die folgenden Schritte ausführt:

Das HTTP Module analysiert HTTP-Nachrichten, um zu überprüfen, ob es sich um SOAP-Nachrichten handelt.
Wenn das HTTP Module eine SOAP-Nachricht erkennt, wird der SOAP-Header gelesen.
Wenn die SOAP-Nachricht den SOAP-Header mit Anmeldeinformationen für die Authentifizierung enthält, löst das HTTP Module ein benutzerdefiniertes global.asax-Ereignis aus.

Im angegebenen Beispiel wird der Benutzer durch das HTTP Module authentifiziert, und es werden Context-Eigenschaften festgelegt, mit deren Hilfe ein Webdienst entscheiden kann, ob der Client zum Zugriff auf den Webdienst berechtigt ist.

Hinweis:
In diesem Beispiel wird der Text im Netzwerk in Klartext gesendet (er ist also nicht verschlüsselt). Wenn Klartext den Sicherheitsanforderungen der Anwendung nicht genügt, fügen Sie einen Verschlüsselungsalgorithmus hinzu.

Beispiel

Das folgende Codebeispiel ist ein HTTP-Modul, das HTTP-Nachrichten für SOAP-Anforderungen analysiert. Wenn die HTTP-Nachricht eine SOAP-Nachricht ist, wird das benutzerdefinierte Ereignis WebServiceAuthenticationEvent ausgelöst.

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;
      }
    }
}

Public NotInheritable Class WebServiceAuthenticationModule
        Implements IHttpModule

        Public Delegate Sub WebServiceAuthenticationEventHandler(ByVal sender As [Object], ByVal e As WebServiceAuthenticationEvent)
        Private _eventHandler As WebServiceAuthenticationEventHandler = Nothing

        Public Custom Event Authenticate As 
                      WebServiceAuthenticationEventHandler
            AddHandler(ByVal value As 
                           WebServiceAuthenticationEventHandler)
                _eventHandler = value
            End AddHandler
            RemoveHandler(ByVal value As 
                       WebServiceAuthenticationEventHandler)
                _eventHandler = value
            End RemoveHandler
            RaiseEvent(ByVal sender As Object, 
                    ByVal e As WebServiceAuthenticationEvent)
            End RaiseEvent
        End Event

        Public Sub Dispose() Implements System.Web.IHttpModule.Dispose

        End Sub 'Dispose


        Public Sub Init(ByVal app As HttpApplication) Implements System.Web.IHttpModule.Init
            AddHandler app.AuthenticateRequest, AddressOf Me.OnEnter

        End Sub 'Init


        Private Sub OnAuthenticate(ByVal e As WebServiceAuthenticationEvent)
            If _eventHandler Is Nothing Then
                Return
            End If
            _eventHandler(Me, e)
            If Not (e.User Is Nothing) Then
                e.Context.User = e.Principal
            End If

        End Sub 'OnAuthenticate 

        Public ReadOnly Property ModuleName() As String
            Get
                Return "WebServiceAuthentication"
            End Get
        End Property

        Sub OnEnter(ByVal [source] As [Object], ByVal eventArgs As EventArgs)
            Dim app As HttpApplication = CType([source], HttpApplication)
            Dim context As HttpContext = app.Context
            Dim HttpStream As Stream = context.Request.InputStream

            ' Save the current position of stream.
            Dim posStream As Long = HttpStream.Position

            ' If the request contains an HTTP_SOAPACTION 
            ' header, look at this message.
            If context.Request.ServerVariables("HTTP_SOAPACTION") Is Nothing Then
                Return
            End If
            ' Load the body of the HTTP message
            ' into an XML document.
            Dim dom As New XmlDocument()
            Dim soapUser As String
            Dim soapPassword As String

            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 e As Exception
                ' Reset the position of stream.
                HttpStream.Position = posStream

                ' Throw a SOAP exception.
                Dim name As New XmlQualifiedName("Load")
                Dim soapException As New SoapException("Unable to read SOAP request", name, e)
                Throw soapException
            End Try

            ' Raise the custom global.asax event.
            OnAuthenticate(New WebServiceAuthenticationEvent(context, soapUser, soapPassword))
            Return

        End Sub 'OnEnter
    End Class 'WebServiceAuthenticationModule

Das folgende Codebeispiel stellt ein benutzerdefiniertes Authentifizierungsereignis dar, das beim Empfang einer SOAP-Anforderung vom HTTP Module ausgelöst wird.

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;
         }
       }
    }
}

Imports System
Imports System.Web
Imports System.Security.Principal

Public Class WebServiceAuthenticationEvent
    Inherits EventArgs
    Private _IPrincipalUser As Iprincipal
    Private _Context As HttpContext
    Private _User As String
    Private _Password As String
    
    
    Public Sub New(ByVal context As HttpContext) 
        _Context = context
    
    End Sub 'New
    
    
    Public Sub New(ByVal context As HttpContext, ByVal user As String, ByVal password As String) 
        _Context = context
        _User = user
        _Password = password
    
    End Sub 'New
    
    Public ReadOnly Property Context() As HttpContext 
        Get
            Return _Context
        End Get
    End Property
    
    Public Property Principal() As IPrincipal 
        Get
            Return _IPrincipalUser
        End Get
        Set
            _IPrincipalUser = value
        End Set
    End Property
    
    Overloads Public Sub Authenticate() 
        Dim i As New GenericIdentity(User)
        Me.Principal = New GenericPrincipal(i, New String(-1) {})
    
    End Sub 'Authenticate
    
    Overloads Public Sub Authenticate(ByVal roles() As String) 
        Dim i As New GenericIdentity(User)
        Me.Principal = New GenericPrincipal(i, roles)
    
    End Sub 'Authenticate
    
    Public Property User() As String 
        Get
            Return _User
        End Get
        Set
            _User = value
        End Set
    End Property
    
    Public Property Password() As String 
        Get
            Return _Password
        End Get
        Set
            _Password = value
        End Set
    End Property
    
    Public ReadOnly Property HasCredentials() As Boolean 
        Get
            If _User Is Nothing OrElse _Password Is Nothing Then
                Return False
            End If
            Return True
        End Get
    End Property
End Class 'WebServiceAuthenticationEvent

Im folgenden Codebeispiel wird der Delegat für das benutzerdefinierte WebServiceAuthenticationEvent-Ereignis festgelegt.

namespace Microsoft.WebServices.Security 
{
   using System;

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

Imports System
Public Delegate Sub WebServiceAuthenticationEventHandler(ByVal sender As [Object], ByVal e As WebServiceAuthenticationEvent)

Im folgenden Codebeispiel wird ein Webdienst veranschaulicht, der den von einem Client zu übergebenden Authentication-SOAP-Header definiert. Der XML-Webdienst muss die Authentifizierung nicht durchführen. Vielmehr prüft er die User.Identity.IsAuthenticated-Eigenschaft, um zu ermitteln, ob der Benutzer vom HTTP Module authentifiziert wurde.

<%@ 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";
  }
}

<%@ WebService Language="VB" Class="SecureWebService" %>

Imports System 
Imports System.Web.Services
Imports System.Web.Services.Protocols

Public Class Authentication
    Inherits SoapHeader
    Public User As String
    Public Password As String
End Class 'Authentication

Public Class SecureWebService
    Inherits WebService
    Public authentication As Authentication
    
    
    <WebMethod(), SoapHeader("authentication")>  _
    Public Function ValidUser() As String 
        If User.IsInRole("Customer") Then
            Return "User is in role customer"
        End If 
        If User.Identity.IsAuthenticated Then
            Return "User is a valid user"
        End If
        Return "not authenticated"
    
    End Function 'ValidUser
End Class 'SecureWebService

Das folgende Codebeispiel stellt einen Webdienstclient dar, der innerhalb eines Authentication-SOAP-Headers die erforderlichen Anmeldeinformationen für einen Authentifizierungsmechanismus übergibt, der auf benutzerdefinierten SOAP-Headern basiert.

// Create a new instance of a 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;

' Create a new instance of a Web service proxy class.
Dim s As New SecureWebService()

' Create the Authentication SOAP header and set values.
Dim a As New Authentication()
a.User = user.Value
a.Password = password.Value

Assign the Header.
s.AuthenticationValue = a

Dim result As String = s.ValidUser()
span1.InnerHtml = result

Siehe auch

Freigeben über

Vorgehensweise: Ausführen von benutzerdefinierter Authentifizierung mit SOAP-Headern

Beispiel

Siehe auch

Aufgaben

Verweis

Konzepte

Weitere Ressourcen

Zusätzliche Ressourcen