Freigeben über

Entwickeln eines Moduls mit .NET

  • Artikel

von Mike Volodarsky

Einführung

Mit IIS 7.0 und höher ist es möglich, den Server durch Module zu erweitern, die auf zwei Arten entwickelt werden:

  • Verwenden von verwaltetem Code und der ASP.NET Servererweiterungs-APIs
  • Verwenden von systemeigenem Code und den nativen IIS-Servererweiterungs-APIs

In der Vergangenheit waren ASP.NET Module in der Funktionalität eingeschränkt, da die ASP.NET Anforderungsverarbeitungspipeline von der Haupt-Serveranforderungspipeline getrennt war.

In IIS werden verwaltete Module praktisch so leistungsfähig wie native Module mit der integrierten Pipelinearchitektur. Am wichtigsten ist es, dass die Dienste, die verwaltete Module bereitstellen, jetzt auf alle Anforderungen an den Server angewendet werden können, nicht nur auf Anforderungen an ASP.NET Inhalte wie ASPX-Seiten. Verwaltete Module werden in konsistenter Weise mit nativen Modulen konfiguriert und verwaltet und können in den gleichen Verarbeitungsphasen und Reihenfolgen wie native Module ausgeführt werden. Schließlich können verwaltete Module eine breitere Gruppe von Vorgängen ausführen, um die Anforderungsverarbeitung über mehrere hinzugefügte und erweiterte ASP.NET-APIs zu bearbeiten.

In diesem Artikel wird die Erweiterung des Servers mit einem verwalteten Modul veranschaulicht, um die Möglichkeit zum Ausführen der Standardauthentifizierung für einen beliebigen Anmeldeinformationsspeicher hinzuzufügen, beispielsweise die anbieterbasierte Anmeldeinformationsinfrastruktur im ASP.NET 2.0-Mitgliedschaftssystem.

Dies ermöglicht das Ersetzen der integrierten Unterstützung der Standardauthentifizierung in IIS, die an den Windows-Anmeldeinformationsspeicher gebunden ist, durch einen, der beliebige Anmeldeinformationsspeicher unterstützt, oder eines der vorhandenen Mitgliedschaftsanbieter die mit ASP.NET 2.0 wie SQL Server, SQL Express oder Active Directory ausgeliefert werden.

In diesem Artikel werden die folgenden Aufgaben behandelt:

  • Entwickeln eines verwalteten Moduls mithilfe von ASP.NET-APIs
  • Bereitstellen eines verwalteten Moduls auf dem Server

Weitere Informationen zu den Grundlagen der Entwicklung von IIS-Modulen und -Handlern finden Sie unter Entwickeln von IIS7 Modulen und -Handlern mit .NET Framework.

Darüber hinaus finden Sie viele Ressourcen und Tipps zum Schreiben von IIS-Modulen im Blog sowie http://www.mvolo.com/zum Herunterladen vorhandener IIS-Module für Ihre Anwendungen. Einige Beispiele finden Sie unter Umleitungsanforderungen an Ihre Anwendung mit dem HttpRedirection-Modul, Schön aussehende Verzeichnisauflistungen für Ihre IIS-Website mit DirectoryListingModuleund Das Anzeigen von hübschen Dateisymbolen in Ihren ASP.NET Anwendungen mit IconHandler.

Hinweis

Der in diesem Artikel bereitgestellte Code ist in C# geschrieben.

Voraussetzungen

Die folgenden IIS-Features müssen installiert sein, damit die Schritte in diesem Dokument ausgeführt werden können:

ASP.NET

Installieren Sie ASP.NET über die Windows Vista Systemsteuerung. Wählen Sie "Programme" – "Windows-Features aktivieren oder deaktivieren". Öffnen Sie dann "Internet-Informationsdienste" - "World Wide Web Services" - "Anwendungsentwicklungsfunktionen" und markieren Sie "ASP.NET".

Wenn Sie über einen Windows Server® 2008-Build verfügen, öffnen Sie "Server-Manager" – "Rollen", und wählen Sie "Webserver (IIS)". Klicken Sie auf "Rollendienste hinzufügen". Aktivieren Sie unter "Anwendungsentwicklung" das Kontrollkästchen "ASP.NET".

Hintergrundinformationen zur Basic-Authentifizierung

Die Basic-Authentifizierung ist ein Authentifizierungsschema, das im HTTP.1-Protokoll (RFC 2617) definiert ist. Es verwendet einen standardmäßigen Challenge-basierten Mechanismus, der wie folgt funktioniert:

  • Der Browser stellt ohne Anmeldeinformationen eine Anforderung an eine URL
  • Wenn der Server eine Authentifizierung für diese URL erfordert, antwortet er mit der Mitteilung 401 Zugriff verweigert und enthält einen Header, der angibt, dass das Standardauthentifizierungsschema unterstützt wird
  • Der Browser empfängt die Antwort und stellt eine Anforderung an den Benutzer, sofern konfiguriert, zur Eingabe eines Benutzernamens/Passworts, das er bei der nächsten Anfrage an die URL im Klartext in einen Request-Header einfügt
  • Der Server empfängt den Benutzernamen / das Kennwort in einer Kopfzeile und verwendet diese für die Authentifizierung

Hinweis

Während eine ausführliche Erläuterung dieses Authentifizierungsprotokolls außerhalb des Umfangs dieses Artikels liegt, ist es erwähnenswert, dass das Standardauthentifizierungsschema SSL sicher sein muss, da er den Benutzernamen / das Kennwort im Nur-Text sendet.

IIS enthält Unterstützung für die Basic-Authentifizierung für die Windows-Konten, die im lokalen Kontospeicher oder Active Directory für Domänenkonten gespeichert sind. Wir möchten unseren Benutzern die Möglichkeit geben, sich mit der Basisauthentifizierung zu authentifizieren, aber die Anmeldeinformationen stattdessen mit dem ASP.NET 2.0-Mitgliedschaftsdienst zu validieren. Dadurch können Benutzerinformationen in einer Vielzahl vorhandener Mitgliedschaftsanbieter, z. B. SQL Server, gespeichert werden, ohne an Windows-Konten gebunden zu sein.

Aufgabe 1: Entwickeln eines Moduls mit .NET

In dieser Aufgabe untersuchen wir die Entwicklung eines Authentifizierungsmoduls, welches das HTTP.1-Standardauthentifizierungsschema unterstützt. Dieses Modul wurde mit dem Standard ASP.NET Modulmuster entwickelt, das seit ASP.NET v1.0 verfügbar ist. Dieses selbe Muster wird verwendet, um ASP.NET Module zu erstellen, die den IIS-Server erweitern. Tatsächlich können vorhandene ASP.NET Module, die für frühere Versionen von IIS geschrieben wurden, in IIS verwendet werden und die Vorteile einer besseren ASP.NET Integration nutzen, um mehr Leistungsfähigkeit für die Webanwendungen zu bieten, die sie verwenden.

Hinweis

Der vollständige Code für das Modul wird in Anhang A bereitgestellt.

Ein verwaltetes Modul ist eine .NET-Klasse, die die System.Web.IHttpModule-Schnittstelle implementiert. Die primäre Funktion dieser Klasse besteht darin, ein oder mehrere Ereignisse zu registrieren, die in der IIS-Anforderungsverarbeitungspipeline auftreten, und dann einige nützliche Arbeiten ausführen, wenn IIS die Ereignishandler des Moduls für diese Ereignisse aufruft.

Erstellen wir nun eine neue Quelldatei mit dem Namen "BasicAuthenticationModule.cs", und erstellen wir die Modulklasse (der vollständige Quellcode ist in Anhang A enthalten):

public class BasicAuthenticationModule : System.Web.IHttpModule
{
    void Init(HttpApplication context)
    {
    }
    void Dispose()
    {
    }
}

Die primäre Funktion der Init-Methode besteht darin, die Ereignishandlermethoden des Moduls mit den entsprechenden Anforderungspipelineereignissen zu verknüpfen. Die Klasse des Moduls stellt die Ereignishandlemethoden bereit und sie implementieren die vom Modul bereitgestellte gewünschte Funktionalität. Dies wird weiter unten ausführlich erörtert.

Die Dispose-Methode wird verwendet, um jeden Modulstatus zu bereinigen, wenn die Modulinstanz verworfen wird. Es wird in der Regel nicht implementiert, es sei denn, das Modul verwendet bestimmte Ressourcen, die freigegeben werden müssen.

Init()

Nach dem Erstellen der Klasse besteht der nächste Schritt darin, die Init-Methode zu implementieren. Die einzige Anforderung besteht darin, das Modul für ein oder mehrere Anforderungspipeline-Ereignisse zu registrieren. Verbinden Sie Modulmethoden, die der Signatur des System.EventHandler-Delegaten folgen, mit den gewünschten Pipeline-Ereignissen, die in der bereitgestellten System.Web.HttpApplication-Instanz verfügbar gemacht werden:

public void Init(HttpApplication context)            
{
   //          
   // Subscribe to the authenticate event to perform the 
   // authentication. 
   // 
   context.AuthenticateRequest += new        
              EventHandler(this.AuthenticateUser);

   // 
   // Subscribe to the EndRequest event to issue the 
   // challenge if necessary. 
   // 
   context.EndRequest += new 
              EventHandler(this.IssueAuthenticationChallenge);
}

Die AuthenticateUser-Methode wird für jede Anforderung während des AuthenticateRequest-Events aufgerufen. Wir verwenden sie, um den Benutzer basierend auf den Anmeldeinformationen zu authentifizieren, die in der Anforderung vorhanden sind.

Die IssueAuthenticationChallenge-Methode wird für jede Anforderung während des EndRequest-Ereignisses aufgerufen. Sie ist dafür verantwortlich, eine Basic-Authentifizierungsanforderung an den Client zurückzugeben, wenn das Autorisierungsmodul eine Anforderung ablehnt und die Authentifizierung erforderlich ist.

AuthenticateUser()

Implementieren Sie die AuthenticateUser-Methode. Die Methode macht folgendes:

  • Die Basic Anmeldeinformationen extrahieren, wenn sie in den Headern für eingehende Anforderungen vorhanden sind. Informationen zur Implementierung dieses Schritts finden Sie unter der ExtractBasicAuthenticationCredentials-Hilfsmethode.
  • Versucht, die bereitgestellten Anmeldeinformationen über die Mitgliedschaft zu validieren (mithilfe des konfigurierten Standardmitgliedschaftsanbieters). Informationen zur Implementierung dieses Schritts finden Sie unter der ValidateCredentials-Hilfsmethode.
  • Erstellt einen Benutzerprinzipal, der den Benutzer identifiziert, wenn die Authentifizierung erfolgreich ist, und ordnet ihn der Anforderung zu.

Am Ende dieser Verarbeitung erstellt das Modul, wenn das Modul die Benutzeranmeldeinformationen erfolgreich abrufen und validieren konnte, einen authentifizierten Benutzerprinzipal, den andere Module und Anwendungscode später in Zugriffssteuerungsentscheidungen verwenden. Beispielsweise untersucht das URL-Autorisierungsmodul den Benutzer im nächsten Pipeline-Ereignis, um die von der Anwendung konfigurierten Autorisierungsregeln zu erzwingen.

IssueAuthenticationChallenge()

Die IssueAuthenticationChallenge-Methode implementieren. Die Methode macht folgendes:

  • Überprüft den Antwortstatuscode, um festzustellen, ob diese Anforderung abgelehnt wurde.
  • Geben Sie in diesem Fall einen Abfrageheader für die Basic-Authentifizierung an die Antwort aus, um den Client zur Authentifizierung auszulösen.

Hilfsmethoden

Die vom Modul verwendeten Hilfsmethoden implementieren, einschließlich:

  • ExtractBasicAuthenticationCredentials. Diese Methode extrahiert die Basic-Authentifizierungsanmeldeinformationen aus dem Autorisierungsanforderungsheader, wie im Standardauthentifizierungsschema angegeben.
  • ValidateCredentials. Diese Methode versucht, Benutzeranmeldeinformationen mithilfe der Mitgliedschaft zu validieren. Die Mitgliedschafts-API abstrahiert den zugrunde liegenden Anmeldeinformationsspeicher und ermöglicht die Konfiguration der Implementierungen des Anmeldeinformationsspeichers durch Hinzufügen / Entfernen von Mitgliedschaftsanbietern über die Konfiguration.

Hinweis

In diesem Beispiel wird die Mitgliedschaftsvalidierung auskommentiert, und stattdessen überprüft das Modul einfach, ob der Benutzername und das Kennwort der Zeichenfolge "test" entsprechen. Dies geschieht aus Gründen der Klarheit und ist nicht für Produktions-Bereitstellungen vorgesehen. Sie werden eingeladen, die Validierung von mitgliedschaftsbasierten Anmeldeinformationen zu aktivieren, indem Sie einfach den Mitgliedschaftscode innerhalb von ValidateCredentials aufheben und einen Mitgliedschaftsanbieter für Ihre Anwendung konfigurieren. Weitere Informationen finden Sie im Anhang C.

Aufgabe 2: Bereitstellen des Moduls an die Anwendung

Nach dem Erstellen des Moduls in der ersten Aufgabe fügen wir es dann der Anwendung hinzu.

Der Anwendung bereitstellen

Erstens, stellen Sie das Modul für die Anwendung bereit. Hier stehen nun verschiedene Optionen zur Verfügung:

  • Kopieren Sie die Quelldatei, die das Modul enthält, in das Verzeichnis /App_Code der Anwendung hinein. Dies erfordert keine Kompilierung des Moduls - Automatisch kompiliert und lädt ASP.NET den Modultyp, wenn die Anwendung gestartet wird. Speichern Sie diesen Quellcode einfach im Verzeichnis /App_Code Ihrer Anwendung als BasicAuthenticationModule.cs. Tun Sie dies, wenn Sie sich bei den anderen Schritten nicht sicher sind.

  • Kompilieren Sie das Modul in eine Assembly, und legen Sie diese Assembly im Verzeichnis /BIN der Anwendung ab. Dies ist die typischste Option, wenn dieses Modul nur für diese Anwendung verfügbar sein soll und Sie die Quelle des Moduls nicht mit Ihrer Anwendung versenden möchten. Kompilieren Sie die Modulquelldatei, indem Sie folgendes von einer Befehlszeilenaufforderung ausführen:

    <PATH_TO_FX_SDK>csc.exe /out:BasicAuthenticationModule.dll /target:library BasicAuthenticationModule.cs

    Dabei <PATH_TO_FX_SDK> handelt es sich um den Pfad zum .NET Framework SDK, das den CSC.EXE Compiler enthält.

  • Kompilieren Sie das Modul in eine stark benannte Assembly, und registrieren Sie diese im GAC. Dies ist eine gute Option, wenn Sie möchten, dass mehrere Anwendungen auf Ihrem Computer dieses Modul verwenden. Weitere Informationen zum Erstellen stark benannter Assemblys finden Sie unter Erstellen und Verwenden von Assemblys mit starken Namen.

Bevor Sie Konfigurationsänderungen in der Datei web.config der Anwendung vornehmen, müssen wir einige der Konfigurationsabschnitte entsperren, die standardmäßig auf Serverebene gesperrt sind. Führen Sie folgendes an einer Eingabeaufforderung mit erhöhten Rechten aus (Klicken Sie mit der > rechten Maustaste auf Cmd.exe, und wählen Sie "Als Administrator ausführen" aus):

%windir%\system32\inetsrv\APPCMD.EXE unlock config /section:windowsAuthentication
%windir%\system32\inetsrv\APPCMD.EXE unlock config /section:anonymousAuthentication

Nachdem Sie diese Befehle ausgeführt haben, können Sie diese Konfigurationsabschnitte in der Datei web.config Ihrer Anwendung definieren.

Konfigurieren Sie Ihr Modul so, dass es in der Anwendung ausgeführt wird. Erstellen Sie zunächst eine neue Datei web.config, die die zum Aktivieren und Verwenden des neuen Moduls erforderliche Konfiguration enthält. Fügen Sie zunächst den folgenden Text hinzu, und speichern Sie ihn im Stammverzeichnis Ihrer Anwendung (%systemdrive%\inetpub\wwwroot\web.config wenn Sie die Stammanwendung auf der Standardwebsite verwenden).

<configuration> 
    <system.webServer> 
        <modules> 
        </modules> 
        <security> 
            <authentication> 
                <windowsAuthentication enabled="false"/> 
                <anonymousAuthentication enabled="false"/> 
            </authentication> 
        </security> 
    </system.webServer> 
</configuration>

Deaktivieren Sie vor dem Aktivieren des neuen Basic-Authentifizierungsmoduls alle anderen IIS-Authentifizierungsmodule. Standardmäßig sind nur die Windows-Authentifizierung und die anonyme Authentifizierung aktiviert. Da der Browser nicht versuchen soll, mit Ihren Windows-Anmeldeinformationen zu authentifizieren oder anonyme Benutzer zuzulassen, deaktivieren wir sowohl das Windows-Authentifizierungsmodul als auch das Modul Anonyme Authentifizierung.

Aktivieren Sie nun das Modul, indem Sie es zur Liste der Module hinzufügen, die von unserer Anwendung geladen werden. Öffnen Sie web.config erneut, und fügen Sie den Eintrag zum <modules> Tag hinzu

<add name="MyBasicAuthenticationModule" type="IIS7Demos.BasicAuthenticationModule" />

Sie können das Modul auch mithilfe des IIS-Verwaltungstools oder des APPCMD.EXE Befehlszeilentools bereitstellen.

Der endgültige Inhalt der Datei web.config der Anwendung nach diesen Änderungen ist in Anhang B aufgeführt.

Herzlichen Glückwunsch, Sie haben die Konfiguration des benutzerdefinierten Basic-Authentifizierungsmoduls abgeschlossen.

Probieren Sie es aus! Öffnen Sie Internet Explorer, und stellen Sie eine Anforderung an die Anwendung unter der folgenden URL:

http://localhost/

Das Anmeldedialogfeld für die Basic-Authentifizierung sollte angezeigt werden. Geben Sie "test" in das Feld "Benutzername:" und "test" im Feld "Kennwort:" ein, um Zugriff zu erhalten. Zu beachten ist, dass sie auch durch Ihr neues BasicAuthenticationModule geschützt werden, wenn Sie HTML, JPG oder andere Inhalte in Ihre Anwendung kopieren.

Zusammenfassung

In diesem Artikel wurde beschrieben, wie Sie ein benutzerdefiniertes verwaltetes Modul für eine Anwendung entwickeln und bereitstellen und es diesem Modul ermöglichen, Dienste für alle Anforderungen an die Anwendung bereitzustellen.

Sie haben auch die Leistungsfähigkeit der Entwicklung von Serverkomponenten in verwaltetem Code beobachtet. Dies ermöglichte die Entwicklung eines Standardauthentifizierungsdiensts, der vom Windows-Anmeldeinformationsspeicher entkoppelt ist.

Wenn Sie möchten, konfigurieren Sie dieses Modul, um die Leistungsfähigkeit der ASP.NET 2.0 Mitgliedschaftsanwendungsdienste zu nutzen, um austauschbare Anmeldeinformationsspeicher zu unterstützen. Weitere Informationen finden Sie im Anhang C.

Hier finden Sie viele Ressourcen und Tipps zum Schreiben von IIS-Modulen im Blog, http://www.mvolo.com/, sowie zum Herunterladen vorhandener IIS-Module für Ihre Anwendungen. Einige Beispiele finden Sie unter Umleitungsanforderungen an Ihre Anwendung mit dem HttpRedirection-Modul, Schön aussehende Verzeichnisauflistungen für Ihre IIS-Website mit DirectoryListingModuleund Das Anzeigen von hübschen Dateisymbolen in Ihren ASP.NET Anwendungen mit IconHandler.

Anhang A: Quellcode des Basic-Authentifizierungsmoduls

Speichern Sie diesen Quellcode als BasicAuthenticationModule.cs im Verzeichnis /App_Code, um ihn schnell in Ihrer Anwendung bereitzustellen.

Hinweis

Wenn Sie Editor verwenden, müssen Sie Speichern als: Alle Dateien festlegen, um das Speichern der Datei als BasicAuthenticationModule.cs.txt zu vermeiden.

#region Using directives
using System;
using System.Collections;
using System.Text;
using System.Web;
using System.Web.Security;
using System.Security.Principal;
using System.IO;
#endregion
 
namespace IIS7Demos
{
    /// 
    /// This module performs basic authentication. 
    /// For details on basic authentication see RFC 2617. 
    /// 
    /// The basic operational flow is: 
    /// 
    ///     On AuthenticateRequest: 
    ///         extract the basic authentication credentials 
    ///         verify the credentials 
    ///         if succesfull, create the user principal with these credentials 
    /// 
    ///     On SendResponseHeaders: 
    ///         if the request is being rejected with an unauthorized status code (401), 
    ///         add the basic authentication challenge to trigger basic authentication. 
    ///       
    /// 

    public class BasicAuthenticationModule : IHttpModule
    {
        #region member declarations
        public const String     HttpAuthorizationHeader = "Authorization";  // HTTP1.1 Authorization header 
        public const String     HttpBasicSchemeName = "Basic"; // HTTP1.1 Basic Challenge Scheme Name 
        public const Char       HttpCredentialSeparator = ':'; // HTTP1.1 Credential username and password separator 
        public const int        HttpNotAuthorizedStatusCode = 401; // HTTP1.1 Not authorized response status code 
        public const String     HttpWWWAuthenticateHeader = "WWW-Authenticate"; // HTTP1.1 Basic Challenge Scheme Name 
        public const String     Realm = "demo"; // HTTP.1.1 Basic Challenge Realm 
        #endregion

        #region Main Event Processing Callbacks
        public void AuthenticateUser(Object source, EventArgs e)
        {
            HttpApplication application = (HttpApplication)source;
            HttpContext context = application.Context;
            String userName = null;
            String password = null;
            String realm = null;
            String authorizationHeader = context.Request.Headers[HttpAuthorizationHeader];

            // 
            //  Extract the basic authentication credentials from the request 
            // 
            if (!ExtractBasicCredentials(authorizationHeader, ref userName, ref password))
                return;
            // 
            // Validate the user credentials 
            // 
            if (!ValidateCredentials(userName, password, realm))
               return;

            // 
            // Create the user principal and associate it with the request 
            // 
            context.User = new GenericPrincipal(new GenericIdentity(userName), null);
        }

        public void IssueAuthenticationChallenge(Object source, EventArgs e)
        {
            HttpApplication application = (HttpApplication)source;
            HttpContext context = application.Context;

            // 
            // Issue a basic challenge if necessary 
            // 

            if (context.Response.StatusCode == HttpNotAuthorizedStatusCode)
            {
                context.Response.AddHeader(HttpWWWAuthenticateHeader, "Basic realm =\"" + Realm + "\"");
            }
        }
        #endregion

        #region Utility Methods
        protected virtual bool ValidateCredentials(String userName, String password, String realm)
        {
            // 
            //  Validate the credentials using Membership (refault provider) 
            // 
            // NOTE: Membership is commented out for clarity reasons.   
            // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 
            // WARNING: DO NOT USE THE CODE BELOW IN PRODUCTION 
            // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 
            // return Membership.ValidateUser(userName, password); 
            if (userName.Equals("test") && password.Equals("test"))
            {
                return true;
            }
            else 
            {
                return false;
            }    
        }
      
        protected virtual bool ExtractBasicCredentials(String authorizationHeader, ref String username, ref String password)
        {
            if ((authorizationHeader == null) || (authorizationHeader.Equals(String.Empty)))
               return false;
            String verifiedAuthorizationHeader = authorizationHeader.Trim();
            if (verifiedAuthorizationHeader.IndexOf(HttpBasicSchemeName) != 0)     
                return false;

            // get the credential payload 
            verifiedAuthorizationHeader = verifiedAuthorizationHeader.Substring(HttpBasicSchemeName.Length, verifiedAuthorizationHeader.Length - HttpBasicSchemeName.Length).Trim();
           // decode the base 64 encoded credential payload 
            byte[] credentialBase64DecodedArray = Convert.FromBase64String(verifiedAuthorizationHeader);
            UTF8Encoding encoding = new UTF8Encoding();
            String decodedAuthorizationHeader = encoding.GetString(credentialBase64DecodedArray, 0, credentialBase64DecodedArray.Length);

            // get the username, password, and realm 
            int separatorPosition = decodedAuthorizationHeader.IndexOf(HttpCredentialSeparator);

           if (separatorPosition <= 0)
              return false;
            username = decodedAuthorizationHeader.Substring(0, separatorPosition).Trim();
           password = decodedAuthorizationHeader.Substring(separatorPosition + 1, (decodedAuthorizationHeader.Length - separatorPosition - 1)).Trim();

            if (username.Equals(String.Empty) || password.Equals(String.Empty))
               return false;

           return true;
        }
        #endregion

        #region IHttpModule Members
        public void Init(HttpApplication context)
        {
            // 
            // Subscribe to the authenticate event to perform the 
            // authentication. 
            // 
            context.AuthenticateRequest += new 
                               EventHandler(this.AuthenticateUser);
            // 
            // Subscribe to the EndRequest event to issue the 
            // challenge if necessary. 
            // 
            context.EndRequest += new 
                               EventHandler(this.IssueAuthenticationChallenge);
        }
        public void Dispose()
        {
            // 
            // Do nothing here 
            // 
        }
        #endregion

    }
}

Anhang B: Web.config für das Basic-Authentifizierungsmodul

Speichern Sie diese Konfiguration als Web.config-Datei im Stamm ihrer Anwendung:

<configuration> 
    <system.webServer> 
      <modules> 
           <add name="MyBasicAuthenticationModule" type="IIS7Demos.BasicAuthenticationModule" /> 
      </modules> 
      <security> 
         <authentication> 
          <windowsAuthentication enabled="false"/> 
             <anonymousAuthentication enabled="false"/> 
         </authentication> 
      </security> 
    </system.webServer> 
</configuration>

Anhang C: Konfigurieren der Mitgliedschaft

Mit dem ASP.NET 2.0 Mitgliedschaftsdienst können Anwendungen schnell die Validierung von Anmeldeinformationen und die Benutzerverwaltung implementieren, die für die meisten Authentifizierungs- und Zugriffssteuerungsschemas erforderlich ist. Die Mitgliedschaft isoliert den Anwendungscode von der tatsächlichen Implementierung des Anmeldeinformationsspeichers und bietet eine Reihe von Optionen für die Integration in vorhandene Anmeldeinformationsspeicher.

Um die Mitgliedschaft für dieses Modul-Beispiel nutzen zu können, heben Sie eine Auskommentierung eines Aufrufs von Membership.ValidateUser innerhalb der ValidateCredentials-Methode auf, und konfigurieren Sie einen Mitgliedschaftsanbieter für Ihre Anwendung. Weitere Informationen zum Konfigurieren der Mitgliedschaft finden Sie unter Konfigurieren einer ASP.NET Applikation, um Mitgliedschaft zu nutzen.