Erstellen einer benutzerdefinierten Authentifizierungsmethode für AD FS unter Windows Server

Artikel
02/13/2024

Diese exemplarische Vorgehensweise enthält Anweisungen zum Implementieren einer benutzerdefinierten Authentifizierungsmethode für AD FS in Windows Server 2012 R2. Weitere Informationen finden Sie unter Zusätzliche Authentifizierungsmethoden.

Warnung

Das hier vorgestellte Beispiel dient nur zu Übungszwecken. Die Anweisungen sind auf eine sehr einfache und minimalistische Implementierung ausgelegt, um die erforderlichen Elemente des Modells zu veranschaulichen. Es gibt kein Authentifizierungs-Back-End, keine Fehlerverarbeitung und keine Konfigurationsdaten.

Einrichten der Dev-Box

In dieser exemplarische Vorgehensweise wird Visual Studio 2012 verwendet. Das Projekt kann in jeder Entwicklungsumgebung erstellt werden, die eine .NET-Klasse für Windows erstellen kann. Das Projekt muss auf .NET 4.5 ausgerichtet sein, da die Methoden BeginAuthentication und TryEndAuthentication den Typ System.Security.Claims.Claim verwenden, der Teil von .NET Framework Version 4.5 ist. Für das Projekt ist ein Verweis erforderlich:

Referenz-DLL	Ort	Erforderlich für
Microsoft.IdentityServer.Web.dll	Die DLL-Datei befindet sich auf einem Windows Server 2012 R2-Server, auf dem AD FS installiert wurde, unter „%windir%\ADFS“. Diese DLL muss auf den Entwicklungscomputer kopiert und dann ein expliziter Verweis im Projekt erstellt werden.	Schnittstellentypen wie IAuthenticationContext, IProofData

Erstellen des Anbieters

Wählen Sie in Visual Studio 2012 „Datei“ -> „Neu“ -> „Projekt“ aus.
Wählen Sie „Klassenbibliothek“ aus, und stellen Sie sicher, .NET 4.5 als Ziel zu verwenden.
Erstellen Sie eine Kopie von Microsoft.IdentityServer.Web.dll unter „%windir%\ADFS“ auf dem Windows Server 2012 R2-Server, auf dem AD FS installiert wurde, und fügen Sie sie in den Ordner „Project“ auf dem Entwicklungscomputer ein.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Verweise und dann auf Verweis hinzufügen.
Navigieren Sie zu Ihrer lokalen Kopie von Microsoft.IdentityServer.Web.dll, und wählen Sie Hinzufügen aus.
Klicken Sie auf OK, um den neuen Verweis zu bestätigen:

Nun sollte die Umgebung so eingerichtet sein, dass alle Typen, die für den Anbieter erforderlich sind, aufgelöst werden.
Fügen Sie Ihrem Projekt eine neue Klasse hinzu (klicken Sie mit der rechten Maustaste auf Ihr Projekt, „Hinzufügen“, „Klasse“), und geben Sie ihm einen Namen wie MyAdapter, wie unten gezeigt:

Ersetzen Sie in der neuen Datei „MyAdapter.cs“ den vorhandenen Code durch den folgenden:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Globalization;
using System.IO;
using System.Net;
using System.Xml.Serialization;
using Microsoft.IdentityServer.Web.Authentication.External;
using Claim = System.Security.Claims.Claim;

namespace MFAadapter
{
    class MyAdapter : IAuthenticationAdapter
    {
        public IAuthenticationAdapterMetadata Metadata
        {
            //get { return new <instance of IAuthenticationAdapterMetadata derived class>; }
        }

        public IAdapterPresentation BeginAuthentication(Claim identityClaim, HttpListenerRequest request, IAuthenticationContext authContext)
        {
            //return new instance of IAdapterPresentationForm derived class
        }

        public bool IsAvailableForUser(Claim identityClaim, IAuthenticationContext authContext)
        {
            return true; //its all available for now
        }

        public void OnAuthenticationPipelineLoad(IAuthenticationMethodConfigData configData)
        {
            //this is where AD FS passes us the config data, if such data was supplied at registration of the adapter
        }

        public void OnAuthenticationPipelineUnload()
        {

        }

        public IAdapterPresentation OnError(HttpListenerRequest request, ExternalAuthenticationException ex)
        {
            //return new instance of IAdapterPresentationForm derived class
        }

        public IAdapterPresentation TryEndAuthentication(IAuthenticationContext authContext, IProofData proofData, HttpListenerRequest request, out Claim[] outgoingClaims)
        {
            //return new instance of IAdapterPresentationForm derived class
        }

    }
}

Noch ist kein Build möglich, es gibt noch zwei weitere Schnittstellen.

Fügen Sie Ihrem Projekt zwei weitere Klassen hinzu: eine für die Metadaten und die andere für das Präsentationsformular. Sie können diese in derselben Datei wie die obige Klasse hinzufügen.
```
class MyMetadata : IAuthenticationAdapterMetadata
{

}

class MyPresentationForm : IAdapterPresentationForm
{

}
```

Als Nächstes können Sie jeder die erforderlichen Member hinzufügen. Zunächst die Metadaten (mit hilfreichen Inlinekommentaren).

class MyMetadata : IAuthenticationAdapterMetadata
{
    //Returns the name of the provider that will be shown in the AD FS management UI (not visible to end users)
    public string AdminName
    {
        get { return "My Example MFA Adapter"; }
    }

    //Returns an array of strings containing URIs indicating the set of authentication methods implemented by the adapter 
    /// AD FS requires that, if authentication is successful, the method actually employed will be returned by the
    /// final call to TryEndAuthentication(). If no authentication method is returned, or the method returned is not
    /// one of the methods listed in this property, the authentication attempt will fail.
    public virtual string[] AuthenticationMethods 
    {
        get { return new[] { "http://example.com/myauthenticationmethod1", "http://example.com/myauthenticationmethod2" }; }
    }

    /// Returns an array indicating which languages are supported by the provider. AD FS uses this information
    /// to determine the best language\locale to display to the user.
    public int[] AvailableLcids
    {
        get
        {
            return new[] { new CultureInfo("en-us").LCID, new CultureInfo("fr").LCID};
        }
    }

    /// Returns a Dictionary containing the set of localized friendly names of the provider, indexed by lcid. 
    /// These Friendly Names are displayed in the "choice page" offered to the user when there is more than 
    /// one secondary authentication provider available.
    public Dictionary<int, string> FriendlyNames
    {
        get
        {
            Dictionary<int, string> _friendlyNames = new Dictionary<int, string>();
            _friendlyNames.Add(new CultureInfo("en-us").LCID, "Friendly name of My Example MFA Adapter for end users (en)");
            _friendlyNames.Add(new CultureInfo("fr").LCID, "Friendly name translated to fr locale");
            return _friendlyNames;
        }
    }

    /// Returns a Dictionary containing the set of localized descriptions (hover over help) of the provider, indexed by lcid. 
    /// These descriptions are displayed in the "choice page" offered to the user when there is more than one 
    /// secondary authentication provider available.
    public Dictionary<int, string> Descriptions
    {
        get 
        {
            Dictionary<int, string> _descriptions = new Dictionary<int, string>();
            _descriptions.Add(new CultureInfo("en-us").LCID, "Description of My Example MFA Adapter for end users (en)");
            _descriptions.Add(new CultureInfo("fr").LCID, "Description translated to fr locale");
            return _descriptions; 
        }
    }

    /// Returns an array indicating the type of claim that the adapter uses to identify the user being authenticated.
    /// Note that although the property is an array, only the first element is currently used.
    /// MUST BE ONE OF THE FOLLOWING
    /// "http://schemas.microsoft.com/ws/2008/06/identity/claims/windowsaccountname"
    /// "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/upn"
    /// "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress"
    /// "http://schemas.microsoft.com/ws/2008/06/identity/claims/primarysid"
    public string[] IdentityClaims
    {
        get { return new[] { "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/upn" }; }
    }

    //All external providers must return a value of "true" for this property.
    public bool RequiresIdentity
    {
        get { return true; }
    }
}

Nun sollten Sie bei IAuthenticationAdapter F12 drücken können (klicken Sie mit der rechten Maustaste – „Gehe zu Definition“), um die erforderlichen Schnittstellenmember anzuzeigen.

Als Nächstes können Sie eine Implementierung ausführen.

Ersetzen Sie den gesamten Inhalt Ihrer Klasse durch folgenden Code:

namespace MFAadapter
{
    class MyAdapter : IAuthenticationAdapter
    {
        public IAuthenticationAdapterMetadata Metadata
        {
            //get { return new <instance of IAuthenticationAdapterMetadata derived class>; }
        }

        public IAdapterPresentation BeginAuthentication(Claim identityClaim, HttpListenerRequest request, IAuthenticationContext authContext)
        {
            //return new instance of IAdapterPresentationForm derived class
        }

        public bool IsAvailableForUser(Claim identityClaim, IAuthenticationContext authContext)
        {
            return true; //its all available for now
        }

        public void OnAuthenticationPipelineLoad(IAuthenticationMethodConfigData configData)
        {
            //this is where AD FS passes us the config data, if such data was supplied at registration of the adapter
        }

        public void OnAuthenticationPipelineUnload()
        {

        }

        public IAdapterPresentation OnError(HttpListenerRequest request, ExternalAuthenticationException ex)
        {
            //return new instance of IAdapterPresentationForm derived class
        }

        public IAdapterPresentation TryEndAuthentication(IAuthenticationContext authContext, IProofData proofData, HttpListenerRequest request, out Claim[] outgoingClaims)
        {
            //return new instance of IAdapterPresentationForm derived class
        }
    }
}

Als Nächstes folgt das Präsentationsformular:

class MyPresentationForm : IAdapterPresentationForm
{
    /// Returns the HTML Form fragment that contains the adapter user interface. This data will be included in the web page that is presented
    /// to the cient.
    public string GetFormHtml(int lcid)
    {
        string htmlTemplate = Resources.FormPageHtml; //todo we will implement this
        return htmlTemplate;
    }

    /// Return any external resources, ie references to libraries etc., that should be included in
    /// the HEAD section of the presentation form html.
    public string GetFormPreRenderHtml(int lcid)
    {
        return null;
    }

    //returns the title string for the web page which presents the HTML form content to the end user
    public string GetPageTitle(int lcid)
    {
        return "MFA Adapter";
    }
}

Beachten Sie das „todo“ für das Element Resources.FormPageHtml oben. Sie können dies in Kürze beheben, aber zuerst werden die letzten erforderlichen Rückgabeanweisungen basierend auf den neu implementierten Typen der anfänglichen MyAdapter-Klasse hinzugefügt. Fügen Sie dazu Ihrer vorhandenen IAuthenticationAdapter-Implementierung Folgendes hinzu:

class MyAdapter : IAuthenticationAdapter
{
    public IAuthenticationAdapterMetadata Metadata
    {
        //get { return new <instance of IAuthenticationAdapterMetadata derived class>; }
        get { return new MyMetadata(); }
    }

    public IAdapterPresentation BeginAuthentication(Claim identityClaim, HttpListenerRequest request, IAuthenticationContext authContext)
    {
        //return new instance of IAdapterPresentationForm derived class
        return new MyPresentationForm();
    }

    public bool IsAvailableForUser(Claim identityClaim, IAuthenticationContext authContext)
    {
        return true; //its all available for now
    }

    public void OnAuthenticationPipelineLoad(IAuthenticationMethodConfigData configData)
    {
        //this is where AD FS passes us the config data, if such data was supplied at registration of the adapter
    }

    public void OnAuthenticationPipelineUnload()
    {

    }

    public IAdapterPresentation OnError(HttpListenerRequest request, ExternalAuthenticationException ex)
    {
        //return new instance of IAdapterPresentationForm derived class
        return new MyPresentationForm();
    }

    public IAdapterPresentation TryEndAuthentication(IAuthenticationContext authContext, IProofData proofData, HttpListenerRequest request, out Claim[] outgoingClaims)
    {
        //return new instance of IAdapterPresentationForm derived class
        outgoingClaims = new Claim[0];
        return new MyPresentationForm();
    }

}

Als Nächstes wird die Ressourcendatei bearbeitet, die das HTML-Fragment enthält. Erstellen Sie eine neue Textdatei in Ihrem Projektordner mit folgendem Inhalt:

<div id="loginArea">
    <form method="post" id="loginForm" >
        <!-- These inputs are required by the presentation framework. Do not modify or remove -->
        <input id="authMethod" type="hidden" name="AuthMethod" value="%AuthMethod%" />
        <input id="context" type="hidden" name="Context" value="%Context%" />
        <!-- End inputs are required by the presentation framework. -->
        <p id="pageIntroductionText">This content is provided by the MFA sample adapter. Challenge inputs should be presented below.</p>
        <label for="challengeQuestionInput" class="block">Question text</label>
        <input id="challengeQuestionInput" name="ChallengeQuestionAnswer" type="text" value="" class="text" placeholder="Answer placeholder" />
        <div id="submissionArea" class="submitMargin">
            <input id="submitButton" type="submit" name="Submit" value="Submit" onclick="return AuthPage.submitAnswer()"/>
        </div>
    </form>
    <div id="intro" class="groupMargin">
        <p id="supportEmail">Support information</p>
    </div>
    <script type="text/javascript" language="JavaScript">
        //<![CDATA[
        function AuthPage() { }
        AuthPage.submitAnswer = function () { return true; };
        //]]>
    </script>
</div>

Wählen Sie dann Projekt -> Komponente hinzufügen und dann „Ressourcendatei“ aus. Geben Sie der Datei den Namen Resources, und klicken Sie auf Hinzufügen:
Wählen Sie dann in der Datei Resources.resx die Option „Ressource hinzufügen“, „Vorhandene Datei hinzufügen“ aus. Navigieren Sie zu der Textdatei (mit dem HTML-Fragment), die Sie oben gespeichert haben.

Stellen Sie sicher, dass Ihr Code für „GetFormHtml“ den Namen der neuen Ressource ordnungsgemäß durch das Präfix für Ressourcendateien (RESX-Datei) auflöst, gefolgt vom Namen der Ressource selbst:
```
public string GetFormHtml(int lcid)
{
    string htmlTemplate = Resources.MfaFormHtml; //Resxfilename.resourcename
    return htmlTemplate;
}
```

Nun sollte der Build möglich sein.

Erstellen des Adapters

Der Adapter sollte in eine .NET-Assembly mit starkem Namen integriert sein, die im GAC unter Windows installiert werden kann. Führen Sie dazu in einem Visual Studio-Projekt die folgenden Schritte aus:

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektnamen, und klicken Sie dann auf Eigenschaften.
Aktivieren Sie auf der Registerkarte Signieren die Option Assembly signieren, und wählen Sie unter Schlüsseldatei mit starkem Namen auswählen die Option <Neu> aus. Geben Sie einen Namen und ein Kennwort für die Schlüsseldatei ein, und klicken Sie auf OK. Stellen Sie dann sicher, dass Assembly signieren aktiviert und Nur Signierung verzögern deaktiviert ist. Die Seite Signieren für Eigenschaften sollte wie folgt aussehen:
Erstellen Sie dann die Projektmappe.

Bereitstellen des Adapters auf Ihrem AD FS-Testcomputer

Bevor ein externer Anbieter von AD FS aufgerufen werden kann, muss er im System registriert werden. Adapteranbieter müssen ein Installationsprogramm bereitstellen, das die erforderlichen Installationsmaßnahmen einschließlich der Installation im GAC ausführt und die Registrierung in AD FS unterstützt. Wenn dies nicht der Fall ist, muss der oder die Administrator*in die folgenden Schritte in Windows PowerShell ausführen. Diese Schritte können im Lab zum Testen und Debuggen verwendet werden.

Vorbereiten des AD FS-Testcomputers

Kopieren Sie Dateien, und fügen Sie sie GAC hinzu.

Stellen Sie sicher, dass Sie über einen Windows Server 2012 R2-Computer oder einen virtuellen Computer verfügen.
Installieren Sie den AD FS-Rollendienst, und konfigurieren Sie eine Farm mit mindestens einem Knoten.

Ausführliche Schritte zum Einrichten eines Verbundservers in einer Labumgebung finden Sie im Bereitstellungshandbuch für AD FS unter Windows Server 2012 R2.
Kopieren Sie das Tool „Gacutil.exe“ auf den Server.

„Gacutil.exe“ befindet sich auf einem Windows 8-Computer unter %homedrive%\Programme (x86)\Microsoft SDKs\Windows\v8.0A\bin\NETFX 4.0 Tools. Sie benötigen die Datei gacutil.exe selbst und die Ordner 1033, en-US sowie die anderen lokalisierten Ressourcenordner unterhalb des Speicherorts NETFX 4.0 Tools.
Kopieren Sie Ihre Anbieterdateien (mindestens eine signierte DLL-Datei mit starkem Namen) an denselben Ordnerspeicherort wie gacutil.exe (der Speicherort dient nur der Bequemlichkeit).
Fügen Sie Ihre DLL-Dateien dem GAC auf jedem AD FS-Verbundserver in der Farm hinzu:

Beispiel: Verwenden des Befehlszeilentools „GACutil.exe“ zum Hinzufügen einer DLL-Datei zum GAC: C:>.gacutil.exe /if .<yourdllname>.dll

So zeigen Sie den resultierenden Eintrag im GAC an: C:>.gacutil.exe /l <yourassemblyname>

Registrieren Ihres Anbieters in AD FS

Nachdem die oben genannten Voraussetzungen erfüllt sind, öffnen Sie ein Windows PowerShell-Befehlsfenster auf Ihrem Verbundserver, und geben Sie die folgenden Befehle ein. (Beachten Sie, dass Sie diese Befehle auf dem primären Verbundserver der Farm ausführen müssen, wenn Sie eine Verbundserverfarm verwenden, die auf die interne Windows-Datenbank zurückgreift.)

Register-AdfsAuthenticationProvider –TypeName YourTypeName –Name “AnyNameYouWish” [–ConfigurationFilePath (optional)]

Dabei ist YourTypeName Ihr starker .NET-Typname: „YourDefaultNamespace.YourIAuthenticationAdapterImplementationClassName, YourAssemblyName, Version=YourAssemblyVersion, Culture=neutral, PublicKeyToken=YourPublicKeyTokenValue, processorArchitecture=MSIL“

Dadurch wird Ihr externer Anbieter in AD FS mit dem Namen registriert, den Sie oben für „AnyNameYouWish“ angegeben haben.
Starten Sie den AD FS-Dienst neu (z. B. mithilfe des Windows-Snap-Ins „Dienste“).
Führen Sie den folgenden Befehl aus: Get-AdfsAuthenticationProvider.

Dadurch wird Ihr Anbieter als einer der Anbieter im System angezeigt.

Beispiel:
```
$typeName = "MFAadapter.MyAdapter, MFAadapter, Version=1.0.0.0, Culture=neutral, PublicKeyToken=e675eb33c62805a0, processorArchitecture=MSIL”
Register-AdfsAuthenticationProvider -TypeName $typeName -Name “MyMFAAdapter”
net stop adfssrv
net start adfssrv
```
Wenn Sie den Geräteregistrierungsdienst in Ihrer AD FS-Umgebung aktiviert haben, führen Sie auch den folgenden PowerShell-Befehl aus: net start drs

Verwenden Sie den folgenden PowerShell-Befehl, um den registrierten Anbieter zu überprüfen: Get-AdfsAuthenticationProvider

Dadurch wird Ihr Anbieter als einer der Anbieter im System angezeigt.

Erstellen der AD FS-Authentifizierungsrichtlinie, die Ihren Adapter aufruft

Erstellen der Authentifizierungsrichtlinie mithilfe des AD FS-Verwaltungs-Snap-Ins

Öffnen Sie das AD FS-Verwaltungs-Snap-In (über das Menü Tools in Server-Manager).
Klicken Sie auf Authentifizierungsrichtlinien.
Klicken Sie im mittleren Bereich unter Multi-Faktor-Authentifizierung rechts neben Globale Einstellungen auf den Link Bearbeiten.
Aktivieren Sie unten auf der Seite unter Zusätzliche Authentifizierungsmethoden auswählen das Kontrollkästchen für den AdminName Ihres Anbieters. Klicken Sie auf Anwenden.
Wenn Sie einen Auslöser zum Aufrufen von MFA über Ihren Adapter bereitstellen möchten, aktivieren Sie beispielsweise unter Speicherorte sowohl Extranet als auch Intranet. Klicke auf OK. (Informationen zum Konfigurieren von Auslösern nach vertrauender Seite finden Sie weiter unten unter „Erstellen der Authentifizierungsrichtlinie mit Windows PowerShell“.)
Überprüfen Sie die Ergebnisse über die folgenden Befehle:

Verwenden Sie zuerst Get-AdfsGlobalAuthenticationPolicy. Ihr Anbietername sollte als einer der Werte von „AdditionalAuthenticationProvider“ angezeigt werden.

Verwenden Sie dann Get-AdfsAdditionalAuthenticationRule. Die Regeln für Extranet und Intranet sollten als Ergebnis der Richtlinienauswahl auf der Benutzeroberfläche für Administrator*innen konfiguriert sein.

Erstellen der Authentifizierungsrichtlinie mit Windows PowerShell

Aktivieren Sie zunächst den Anbieter in der globalen Richtlinie:
```
Set-AdfsGlobalAuthenticationPolicy -AdditionalAuthenticationProvider “YourAuthProviderName”`
```
Hinweis

Beachten Sie, dass der für den Parameter „AdditionalAuthenticationProvider“ angegebene Wert dem Wert entspricht, den Sie für den Parameter „Name“ im Cmdlet Register-AdfsAuthenticationProvider oben angegeben haben und der der Eigenschaft „Name“ aus der Ausgabe des Cmdlets Get-AdfsAuthenticationProvider entspricht.
```
Set-AdfsGlobalAuthenticationPolicy –AdditionalAuthenticationProvider “MyMFAAdapter”`
```

Konfigurieren Sie als Nächstes globale oder spezifische Regeln für vertrauende Seiten, um MFA auszulösen:

Beispiel 1: Erstellen einer globalen Regel, die MFA für externe Anforderungen erfordert:

Set-AdfsAdditionalAuthenticationRule –AdditionalAuthenticationRules 'c:[type == "http://schemas.microsoft.com/ws/2012/01/insidecorporatenetwork", value == "false"] => issue(type = "http://schemas.microsoft.com/ws/2008/06/identity/claims/authenticationmethod", value = "http://schemas.microsoft.com/claims/multipleauthn" );'

Beispiel 2: Erstellen von MFA-Regeln, die MFA für externe Anforderungen an eine bestimmte vertrauende Seite erfordern. (Hinweis: Einzelne Anbieter können nicht mit einzelnen vertrauenden Parteien in AD FS unter Windows Server 2012 R2 verbunden werden.)

$rp = Get-AdfsRelyingPartyTrust –Name <Relying Party Name>
Set-AdfsRelyingPartyTrust –TargetRelyingParty $rp –AdditionalAuthenticationRules 'c:[type == "http://schemas.microsoft.com/ws/2012/01/insidecorporatenetwork", value == "false"] => issue(type = "http://schemas.microsoft.com/ws/2008/06/identity/claims/authenticationmethod", value = "http://schemas.microsoft.com/claims/multipleauthn" );'

Authentifizieren mit MFA über Ihren Adapter

Führen Sie abschließend die folgenden Schritte aus, um Ihren Adapter zu testen:

Stellen Sie sicher, dass der globale primäre AD FS-Authentifizierungstyp als Formularauthentifizierung für Extranet und Intranet konfiguriert ist. (Dies vereinfacht die Authentifizierung Ihrer Demo als bestimmte*r Benutzer*in.)
1. Klicken Sie im AD FS-Snap-In unter Authentifizierungsrichtlinien im Bereich Primäre Authentifizierung neben Globale Einstellungen auf Bearbeiten.
  1. Oder klicken Sie einfach auf der Benutzeroberfläche für mehrstufige Richtlinien auf die Registerkarte Primär.
Stellen Sie sicher, dass Formularauthentifizierung die einzige Option ist, die sowohl für Extranet als auch für Intranet als Authentifizierungsmethode aktiviert wurde. Klicke auf OK.
Öffnen Sie die für den IDP ausgelöste HTML-Seite („https://< fsname>/adfs/ls/idpinitiatedsignon.htm“), und melden Sie sich als gültige*r AD-Benutzer*in in Ihrer Testumgebung an.
Geben Sie Anmeldeinformationen für die primäre Authentifizierung ein.
Die Seite „MFA-Formulare“ sollte mit Beispielabfragen angezeigt werden.

Wenn Sie mehrere Adapter konfiguriert haben, wird die MFA-Auswahlseite mit Ihrem Anzeigenamen von oben angezeigt.

Sie verfügen jetzt über eine funktionierende Implementierung der Schnittstelle und wissen, wie das Modell funktioniert. Sie können als weiteres Beispiel versuchen, Breakpoints in „BeginAuthentication“ und „TryEndAuthentication“ festzulegen. Beachten Sie, dass „BeginAuthentication“ ausgeführt wird, wenn der oder die Benutzer*in zum ersten Mal in das MFA-Formular gelangt, während „TryEndAuthentication“ bei jeder Übermittlung des Formulars ausgelöst wird.

Aktualisieren des Adapters für eine erfolgreiche Authentifizierung

Einen Moment! Ihr Beispieladapter wird nie erfolgreich authentifiziert! Dies liegt daran, dass nirgendwo im Code NULL für „TryEndAuthentication“ zurückgegeben wird.

Durch Ausführen der obigen Verfahrensweisen haben Sie eine einfache Adapterimplementierung erstellt und einem AD FS-Server hinzugefügt. Sie können die MFA-Formularseite abrufen, aber Sie können sich noch nicht authentifizieren, da Sie noch nicht die richtige Logik in Ihre Implementierung von „TryEndAuthentication“ eingefügt haben. Diese wird nun hinzugefügt.

Erinnern Sie sich an Ihre Implementierung von „TryEndAuthentication“:

public IAdapterPresentation TryEndAuthentication(IAuthenticationContext authContext, IProofData proofData, HttpListenerRequest request, out Claim[] outgoingClaims)
{
    //return new instance of IAdapterPresentationForm derived class
    outgoingClaims = new Claim[0];
    return new MyPresentationForm();
}

Diese wird nun aktualisiert, damit myPresentationForm() nicht immer zurückgegeben wird. Dazu können Sie eine einfache Hilfsmethode in Ihrer Klasse erstellen:

static bool ValidateProofData(IProofData proofData, IAuthenticationContext authContext)
{
    if (proofData == null || proofData.Properties == null || !proofData.Properties.ContainsKey("ChallengeQuestionAnswer"))
    {
        throw new ExternalAuthenticationException("Error - no answer found", authContext);
    }

    if ((string)proofData.Properties["ChallengeQuestionAnswer"] == "adfabric")
    {
        return true;
    }
    else
    {
        return false;
    }
}

Aktualisieren Sie dann „TryEndAuthentication“ wie folgt:

public IAdapterPresentation TryEndAuthentication(IAuthenticationContext authContext, IProofData proofData, HttpListenerRequest request, out Claim[] outgoingClaims)
{
    outgoingClaims = new Claim[0];
    if (ValidateProofData(proofData, authContext))
    {
        //authn complete - return authn method
        outgoingClaims = new[]
        {
            // Return the required authentication method claim, indicating the particulate authentication method used.
            new Claim( "http://schemas.microsoft.com/ws/2008/06/identity/claims/authenticationmethod", "http://example.com/myauthenticationmethod1" )
        };
        return null;
    }
    else
    {
        //authentication not complete - return new instance of IAdapterPresentationForm derived class
        return new MyPresentationForm();
    }
}

Nun müssen Sie den Adapter im Testfeld aktualisieren. Sie müssen zuerst die AD FS-Richtlinie rückgängig machen, dann die Registrierung bei AD FS aufheben und AD FS neu starten, dann die DLL-Datei aus dem GAC entfernen, die neue DLL-Datei dem GAC hinzufügen, sie in AD FS registrieren, AD FS neu starten und dann die AD FS-Richtlinie neu konfigurieren.

Bereitstellen und Konfigurieren des aktualisierten Adapters auf Ihrem AD FS-Testcomputer

Löschen der AD FS-Richtlinie

Deaktivieren Sie alle auf MFA bezogenen Kontrollkästchen auf der MFA-Benutzeroberfläche (siehe unten), und klicken Sie dann auf „OK“.

clear policy

Aufheben der Registrierung des Anbieters (Windows PowerShell)

PS C:> Unregister-AdfsAuthenticationProvider –Name “YourAuthProviderName”

Beispiel:PS C:> Unregister-AdfsAuthenticationProvider –Name “MyMFAAdapter”

Der für „Name“ übergebene Wert ist derselbe Wert, den Sie als „Name“ für das Cmdlet Register-AdfsAuthenticationProvider angegeben haben. Entspricht auch der Eigenschaft „Name“, die von Get-AdfsAuthenticationProvider ausgegeben wird.

Bevor Sie die Registrierung eines Anbieters aufheben, müssen Sie den Anbieter aus der AdfsGlobalAuthenticationPolicy entfernen (durch Deaktivieren der im AD FS-Verwaltungs-Snap-In aktivierten Kontrollkästchen oder mithilfe von Windows PowerShell).

Der AD FS-Dienst muss nach diesem Vorgang neu gestartet werden.

Entfernen der Assembly aus GAC

Verwenden Sie zunächst den folgenden Befehl, um den vollqualifizierten starken Namen des Eintrags zu finden: C:>.gacutil.exe /l <yourAdapterAssemblyName>

Beispiel:C:>.gacutil.exe /l mfaadapter
Entfernen Sie ihn dann mit dem folgenden Befehl aus dem GAC: .gacutil /u “<output from the above command>”

Beispiel:C:>.gacutil /u “mfaadapter, Version=1.0.0.0, Culture=neutral, PublicKeyToken=e675eb33c62805a0, processorArchitecture=MSIL”

Hinzufügen der aktualisierten Assembly zum GAC

Fügen Sie zuerst die aktualisierte DLL-Datei lokal ein. C:>.gacutil.exe /if .MFAAdapter.dll

Anzeigen der Assembly im GAC (Befehlszeile)

C:> .gacutil.exe /l mfaadapter

Registrieren Ihres Anbieters in AD FS

PS C:>$typeName = "MFAadapter.MyAdapter, MFAadapter, Version=1.0.0.1, Culture=neutral, PublicKeyToken=e675eb33c62805a0, processorArchitecture=MSIL”
PS C:>Register-AdfsAuthenticationProvider -TypeName $typeName -Name “MyMFAAdapter1”
Starten Sie den AD FS-Dienst neu.

Erstellen der Authentifizierungsrichtlinie mithilfe des AD FS-Verwaltungs-Snap-Ins

Öffnen Sie das AD FS-Verwaltungs-Snap-In (über das Menü Tools in Server-Manager).
Klicken Sie auf Authentifizierungsrichtlinien.
Klicken Sie unter Multi-Faktor-Authentifizierung rechts neben Globale Einstellungen auf den Link Bearbeiten.
Aktivieren Sie unter Zusätzliche Authentifizierungsmethoden auswählen das Kontrollkästchen für den AdminName Ihres Anbieters. Klicken Sie auf Anwenden.
Wenn Sie einen Auslöser zum Aufrufen von MFA über Ihren Adapter bereitstellen möchten, aktivieren Sie beispielsweise unter „Speicherorte“ sowohl Extranet als auch Intranet. Klicke auf OK.

Authentifizieren mit MFA über Ihren Adapter

Führen Sie abschließend die folgenden Schritte aus, um Ihren Adapter zu testen:

Stellen Sie sicher, dass der globale primäre AD FS-Authentifizierungstyp als Formularauthentifizierung für Extranet und Intranet konfiguriert ist. (Dies vereinfacht die Authentifizierung als bestimmte*r Benutzer*in.)
1. Klicken Sie im AD FS-Verwaltungs-Snap-In unter Authentifizierungsrichtlinien im Bereich Primäre Authentifizierung neben Globale Einstellungen auf Bearbeiten.
  1. Oder klicken Sie einfach auf der Benutzeroberfläche für mehrstufige Richtlinien auf die Registerkarte Primär.
Stellen Sie sicher, dass Formularauthentifizierung die einzige Option ist, die sowohl für Extranet als auch für Intranet als Authentifizierungsmethode aktiviert wurde. Klicke auf OK.
Öffnen Sie die für den IDP ausgelöste HTML-Seite („https://< fsname>/adfs/ls/idpinitiatedsignon.htm“), und melden Sie sich als gültige*r AD-Benutzer*in in Ihrer Testumgebung an.
Geben Sie die Anmeldeinformationen für die primäre Authentifizierung ein.
Die Seite „MFA-Formulare“ sollte mit einem Beispieltext angezeigt werden.
1. Wenn Sie mehrere Adapter konfiguriert haben, wird die MFA-Auswahlseite mit Ihrem Anzeigenamen angezeigt.

Beim Eingeben von adfabric auf der MFA-Authentifizierungsseite sollte eine erfolgreiche Anmeldung erfolgen.

Screenshot of the M F A forms page with example challenge text.

Screenshot of the M F A successful sign in page.

Weitere Informationen

Weitere Ressourcen

Zusätzliche Authentifizierungsmethoden

Verwalten von Risiken mit zusätzlicher mehrstufiger Authentifizierung für sensible Anwendungen

Erstellen einer benutzerdefinierten Authentifizierungsmethode für AD FS unter Windows Server

Einrichten der Dev-Box

Erstellen des Anbieters

Erstellen des Adapters

Bereitstellen des Adapters auf Ihrem AD FS-Testcomputer

Vorbereiten des AD FS-Testcomputers

Registrieren Ihres Anbieters in AD FS

Erstellen der AD FS-Authentifizierungsrichtlinie, die Ihren Adapter aufruft

Erstellen der Authentifizierungsrichtlinie mithilfe des AD FS-Verwaltungs-Snap-Ins

Erstellen der Authentifizierungsrichtlinie mit Windows PowerShell

Authentifizieren mit MFA über Ihren Adapter

Aktualisieren des Adapters für eine erfolgreiche Authentifizierung

Bereitstellen und Konfigurieren des aktualisierten Adapters auf Ihrem AD FS-Testcomputer

Löschen der AD FS-Richtlinie

Aufheben der Registrierung des Anbieters (Windows PowerShell)

Entfernen der Assembly aus GAC

Hinzufügen der aktualisierten Assembly zum GAC

Anzeigen der Assembly im GAC (Befehlszeile)

Registrieren Ihres Anbieters in AD FS

Erstellen der Authentifizierungsrichtlinie mithilfe des AD FS-Verwaltungs-Snap-Ins

Authentifizieren mit MFA über Ihren Adapter

Weitere Informationen

Weitere Ressourcen

Zusätzliche Ressourcen