Crea un metodo di autenticazione personalizzato per ADFS in Windows Server

Articolo
02/23/2024

Questa procedura dettagliata fornisce istruzioni per implementare un metodo di autenticazione personalizzato per AD FS in Windows Server 2012 R2. Per altre informazioni, vedere Metodi di autenticazione aggiuntivi.

Avviso

L'esempio che è possibile compilare qui è solo a scopo didattico. Queste istruzioni sono per l'implementazione più semplice, più minima possibile esporre gli elementi necessari del modello. Nessun back-end di autenticazione, elaborazione degli errori o dati di configurazione.

Impostare la casella di sviluppo

Questa procedura dettagliata viene utilizzato Visual Studio 2012. Il progetto può essere compilato usando qualsiasi ambiente di sviluppo in grado di creare una classe .NET per Windows. Il progetto deve essere destinato a .NET 4.5 perché i metodi BeginAuthentication e TryEndAuthentication usano il tipo System.Security.Claims.Claim, parte di .NET Framework versione 4.5. Per il progetto è necessario un riferimento:

DLL di riferimento	Posizione	Necessario per
Microsoft.IdentityServer.Web.dll	La DLL si trova in %windir%\ADFS in un server Windows Server 2012 R2 in cui è stato installato AD FS. Questa DLL deve essere copiata nel computer di sviluppo e un riferimento esplicito creato nel progetto.	Tipi di interfaccia che includono IAuthenticationContext, IProofData

Creazione del provider

In Visual Studio 2012: scegli File->Nuovo->Progetto...
Selezionare Libreria di classi e assicurarsi di avere come destinazione .NET 4.5.
Creare una copia di Microsoft.IdentityServer.Web.dll da %windir%\ADFS nel server Windows Server 2012 R2 in cui è stato installato AD FS e incollarlo nella cartella Project nel computer di sviluppo.
In Esplora soluzioni, fare clic con il pulsante destro del mouse su Riferimenti e Aggiungi riferimento....
Passare alla copia locale di Microsoft.IdentityServer.Web.dll e Aggiungi...
Fare clic su OK per confermare il nuovo riferimento:

È ora necessario essere configurati per risolvere tutti i tipi necessari per il provider.
Aggiungere una nuova classe al progetto (fare clic con il pulsante destro del mouse sul progetto, Aggiungi... Classe...) e assegnargli un nome come MyAdapter, illustrato di seguito:

Nel nuovo file MyAdapter.cs sostituire il codice esistente con il codice seguente:

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
        }

    }
}

Non siamo ancora pronti a costruire... ci sono altre due interfacce da usare.

Aggiungere altre due classi al progetto: una per i metadati e l'altra per il modulo di presentazione. È possibile aggiungerli all'interno dello stesso file della classe precedente.
```
class MyMetadata : IAuthenticationAdapterMetadata
{

}

class MyPresentationForm : IAdapterPresentationForm
{

}
```

Successivamente, è possibile aggiungere i membri necessari per ognuno di essi. Prima di tutto, i metadati (con commenti inline utili)

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

Adesso si dovrebbe essere in grado di premere F12 (fare clic con il pulsante destro del mouse - Vai a definizione) in IAuthenticationAdapter per visualizzare il set di membri dell'interfaccia necessari.

Successivamente, è possibile eseguire un'implementazione di queste.

Sostituire l'intero contenuto della classe con quanto segue:

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

Successivamente, il modulo di presentazione:

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

Si noti l'elemento 'todo' per Resources.FormPageHtml indicato sopra. È possibile correggerlo in un minuto, ma prima di tutto aggiungere le istruzioni restituite necessarie finali, in base ai tipi appena implementati, alla classe MyAdapter iniziale. A tale scopo, aggiungere quanto segue all'implementazione di IAuthenticationAdapter esistente:

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

}

Ora per il file di risorse contenente il frammento html. Creare un nuovo file di testo nella cartella del progetto con il contenuto seguente:

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

Selezionare quindi Progetto->Aggiungi componente... File di risorse e denominare il file Risorse e fare clic su Aggiungi:
Quindi, all'interno del Resources.resx scegliere Aggiungi risorsa... Aggiungere un file esistente. Passare al file di testo (contenente il frammento html) salvato in precedenza.

Assicurarsi che il codice GetFormHtml risolva correttamente il nome della nuova risorsa dal prefisso del nome del file di risorse (file con estensione resx) seguito dal nome della risorsa stessa:
```
public string GetFormHtml(int lcid)
{
    string htmlTemplate = Resources.MfaFormHtml; //Resxfilename.resourcename
    return htmlTemplate;
}
```

A questo momento dovrebbe essere possibile compilare.

Compilare l'adapter

L'adattatore deve essere integrato in un assembly .NET con nome sicuro che può essere installato nella GAC in Windows. Per ottenere questo risultato in un progetto di Visual Studio, completare la procedura seguente:

Fare clic con il pulsante destro del mouse sul nome del progetto in Esplora soluzioni, quindi scegliere Proprietà.
Nella scheda Firma selezionare Firma l'assembly e scegliere <Nuovo...> in Scegliere un file di chiave con nome sicuro: immettere un nome e una password del file di chiave e fare clic su OK. Verificare quindi che l'opzione Firma l'assembly sia selezionata e che il segno Ritardo sia deselezionato. La pagina firma delle proprietà dovrebbe essere simile alla seguente:
Quindi, compilare la soluzione.

Distribuire l'adapter nel computer di test di AD FS

Prima che un provider esterno possa essere richiamato da AD FS, deve essere registrato nel sistema. I provider di adattatori devono fornire un programma di installazione che esegue le azioni di installazione necessarie, inclusa l'installazione nella GAC, e il programma di installazione deve supportare la registrazione in AD FS. In caso contrario, l'amministratore deve eseguire i passaggi di Windows PowerShell seguenti. Questi passaggi possono essere usati nel lab per abilitare il test e il debug.

Preparare il computer AD FS di test

Copiare i file e aggiungerli alla GAC.

Assicurarsi di avere un computer o una macchina virtuale Windows Server 2012 R2.
Installare il servizio ruolo AD FS e configurare una farm con almeno un nodo.

Per i passaggi dettagliati per configurare un server federativo in un ambiente lab, vedere la Guida alla distribuzione di AD FS di Windows Server 2012 R2.
Copiare gli strumenti Gacutil.exe nel server.

Gacutil.exe è disponibile in Strumenti %homedrive%Programmi (x86)Microsoft SDKsWindowsv8.0AbinNETFX 4.0 in un computer Windows 8. Sarà necessario il file gacutil.exe stesso e 1033, en-US e l'altra cartella di risorse localizzata sotto il percorso strumenti NETFX 4.0.
Copiare i file del provider (uno o più file con estensione DLL con nome sicuro) nello stesso percorso della cartella di gacutil.exe (il percorso è solo per praticità)
Aggiungere i file DLL alla GAC in ogni server federativo AD FS nella farm:

Esempio: uso dello strumento da riga di comando GACutil.exe per aggiungere una DLL alla GAC: C:>.gacutil.exe /if .<yourdllname>.dll

Per visualizzare la voce risultante nella GAC:C:>.gacutil.exe /l <yourassemblyname>

Registrare il provider in AD FS

Dopo aver soddisfatto i prerequisiti precedenti, aprire una finestra di comando di Windows PowerShell nel server federativo e immettere i comandi seguenti (si noti che se si usa la server farm federativa che usa il database interno di Windows, è necessario eseguire questi comandi nel server federativo primario della farm):

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

Dove YourTypeName è il nome di tipo sicuro .NET: "YourDefaultNamespace.YourIAuthenticationAdapterImplementationClassName, YourAssemblyName, Version=YourAssemblyVersion, Culture=neutral, PublicKeyToken=YourPublicKeyTokenValue, processorArchitecture=MSIL"

Verrà registrato il provider esterno in AD FS, con il nome specificato come AnyNameYouWish precedente.
Riavviare il servizio AD FS, ad esempio usando lo snap-in Servizi Windows.
Eseguire questo comando: Get-AdfsAuthenticationProvider.

Questo mostra il provider come uno dei provider nel sistema.

Esempio
```
$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
```
Se il servizio di registrazione del dispositivo è abilitato nell'ambiente AD FS, eseguire anche il comando di PowerShell seguente: net start drs

Per verificare il provider registrato, usare il comando di PowerShell seguente: Get-AdfsAuthenticationProvider.

Questo mostra il provider come uno dei provider nel sistema.

Creare i criteri di autenticazione di AD FS che richiamano l'adapter

Creare i criteri di autenticazione usando lo snap-in di Gestione AD FS

Aprire lo snap-in di Gestione AD FS (dal menu Strumenti di Server Manager).
Cliccare su criteri di autenticazione.
Nel riquadro centrale, in Autenticazione a più fattori, fare clic sul collegamento Modifica a destra di Impostazioni globali.
In Seleziona metodi di autenticazione aggiuntivi nella parte inferiore della pagina, selezionare la casella AdminName del provider. Fare clic su Applica.
Ad esempio, per fornire un "trigger" per richiamare L'autenticazione a più fattori usando l'adattatore, ad esempio, in Percorsi controllare sia Extranet che Intranet. Fare clic su OK. Per configurare i trigger per ogni relying party, vedere "Creare i criteri di autenticazione con Windows PowerShell" di seguito.
Controllare i risultati usando i comandi seguenti:

Usare prima di tutto Get-AdfsGlobalAuthenticationPolicy. Il nome del provider dovrebbe essere visualizzato come uno dei valori AdditionalAuthenticationProvider.

Usare quindi Get-AdfsAdditionalAuthenticationRule. Dovrebbero essere visualizzate le regole per Extranet e Intranet configurate in seguito alla selezione dei criteri nell'interfaccia utente dell'amministratore.

Creare i criteri di autenticazione con Windows PowerShell

Abilitare prima di tutto il provider nei criteri globali:
```
Set-AdfsGlobalAuthenticationPolicy -AdditionalAuthenticationProvider “YourAuthProviderName”`
```
Nota

Si noti che il valore fornito per il parametro AdditionalAuthenticationProvider corrisponde al valore specificato per il parametro "Name" nel cmdlet Register-AdfsAuthenticationProvider precedente e alla proprietà "Name" dall'output del cmdlet Get-AdfsAuthenticationProvider.
```
Set-AdfsGlobalAuthenticationPolicy –AdditionalAuthenticationProvider “MyMFAAdapter”`
```

Configurare quindi regole globali o specifiche della relying party per attivare l'autenticazione a più fattori:

Esempio 1: per creare una regola globale per richiedere l'autenticazione a più fattori per le richieste esterne:

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" );'

Esempio 2: per creare regole per richiedere l'autenticazione a più fattori per le richieste esterne a una relying party specifica. (Nota: i singoli provider non possono essere connessi a singole relying party in AD FS in Windows Server 2012 R2).

$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" );'

Eseguire l'autenticazione con MFA usando l'adapter

Infine, seguire questa procedura per testare l'adattatore:

Verificare che il tipo di autenticazione primaria globale di AD FS sia configurato come autenticazione basata su form per Extranet e Intranet (in questo modo la demo risulta più semplice per l'autenticazione come utente specifico)
1. Nello snap-in AD FS, in Criteri di autenticazione, nell'area Autenticazione primaria fare clic su Modifica accanto a Impostazioni globali.
  1. In alternativa, fare clic sulla scheda Primaria dall'interfaccia utente Criteri a più fattori.
Verificare che l'autenticazione basata su form sia l'unica opzione selezionata sia per il metodo di autenticazione Extranet che Intranet. Fare clic su OK.
Aprire la pagina HTML di accesso avviata da IDP (https://<fsname>/adfs/ls/idpinitiatedsignon.htm) e accedere come utente di Active Directory valido nell'ambiente di test.
Immettere le credenziali per l'autenticazione primaria.
Verrà visualizzata la pagina moduli MFA con domande di verifica di esempio.

Se sono configurati più adattatori, verrà visualizzata la pagina di scelta MFA con il nome descrittivo indicato in precedenza.

È ora disponibile un'implementazione funzionante dell'interfaccia e si ha la conoscenza del funzionamento del modello. È possibile provare come esempio aggiuntivo per impostare punti di interruzione in BeginAuthentication e TryEndAuthentication. Si noti come BeginAuthentication viene eseguito quando l'utente immette per la prima volta il modulo MFA, mentre TryEndAuthentication viene attivato in ogni invio del modulo.

Aggiornare l'adapter per l'autenticazione riuscita

Ma aspetta: l'adattatore di esempio non eseguirà mai correttamente l'autenticazione. Questo perché nulla nel codice restituisce null per TryEndAuthentication.

Completando le procedure precedenti, è stata creata un'implementazione di adattatore di base e aggiunta a un server AD FS. È possibile ottenere la pagina dei moduli MFA, ma non è ancora possibile eseguire l'autenticazione perché non è ancora stata inserita la logica corretta nell'implementazione TryEndAuthentication. Aggiungiamolo.

Ricordare l'implementazione di 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();
}

Aggiorniamolo in modo che non restituisca sempre MyPresentationForm(). Per questo è possibile creare un metodo di utilità semplice all'interno della classe:

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

Aggiornare quindi TryEndAuthentication come indicato di seguito:

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

È ora necessario aggiornare l'adattatore nella casella di test. È prima necessario annullare il criterio AD FS, quindi annullare la registrazione da AD FS e riavviare AD FS, quindi rimuovere il file DLL dalla GAC e poi aggiungere la nuova DLL alla GAC, quindi registrarla in AD FS, riavviare AD FS e riconfigurare i criteri AD FS.

Distribuire e configurare l'adattatore aggiornato nel computer AD FS di test

Cancellare i criteri di AD FS

Deselezionare tutte le caselle di controllo correlate all'autenticazione a più fattori nell'interfaccia utente MFA, come illustrato di seguito, quindi fare clic su OK.

clear policy

Annullare la registrazione del provider (Windows PowerShell)

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

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

Il valore passato per "Name" è lo stesso valore di "Name" fornito al cmdlet Register-AdfsAuthenticationProvider. È anche la proprietà "Name" restituita da Get-AdfsAuthenticationProvider.

Prima di annullare la registrazione di un provider, è necessario rimuovere il provider da AdfsGlobalAuthenticationPolicy deselezionando le caselle di controllo archiviate nello snap-in di gestione di AD FS o tramite Windows PowerShell.

Il servizio AD FS deve essere riavviato dopo questa operazione.

Rimuovere l'assembly dalla GAC

Per prima cosa, usare il comando seguente per trovare il nome sicuro completo della voce: C:>.gacutil.exe /l <yourAdapterAssemblyName>

Esempio:C:>.gacutil.exe /l mfaadapter
Usare quindi il comando seguente per rimuoverlo dalla GAC: .gacutil /u “<output from the above command>”

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

Aggiungere l'assembly aggiornato alla GAC

Assicurarsi di incollare prima la DLL aggiornata in locale. C:>.gacutil.exe /if .MFAAdapter.dll

Visualizzare l'assembly nella GAC (riga cmd)

C:> .gacutil.exe /l mfaadapter

Registrare il provider 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”
Riavviare il servizio AD FS.

Creare i criteri di autenticazione usando lo snap-in di Gestione AD FS

Aprire lo snap-in di Gestione AD FS (dal menu Strumenti di Server Manager).
Cliccare su criteri di autenticazione.
In Autenticazione a più fattori fare clic sul collegamento Modifica a destra di Impostazioni globali.
In Selezionare metodi di autenticazione aggiuntivi selezionare la casella AdminName del provider. Fare clic su Applica.
Ad esempio, per fornire un "trigger" per richiamare L'autenticazione a più fattori usando l'adattatore, ad esempio, in Percorsi controllare sia Extranet che Intranet. Fare clic su OK.

Eseguire l'autenticazione con MFA usando l'adapter

Infine, seguire questa procedura per testare l'adattatore:

Verificare che il tipo di autenticazione primaria globale di AD FS sia configurato come Autenticazione basata su form per Extranet e Intranet (in questo modo è più semplice eseguire l'autenticazione come utente specifico).
1. Nello snap-in di gestione di AD FS, in Criteri di autenticazione, nell'area Autenticazione primaria fare clic su Modifica accanto a Impostazioni globali.
  1. In alternativa, fare clic sulla scheda Primaria dall'interfaccia utente Criteri a più fattori.
Verificare che l'Autenticazione basata su form sia l'unica opzione selezionata sia per il metodo di autenticazione Extranet che Intranet. Fare clic su OK.
Aprire la pagina HTML di accesso avviata da IDP (https://<fsname>/adfs/ls/idpinitiatedsignon.htm) e accedere come utente di Active Directory valido nell'ambiente di test.
Immettere le credenziali per l'autenticazione primaria.
Verrà visualizzata la pagina Moduli MFA con il testo della richiesta di verifica di esempio.
1. Se sono configurati più adattatori, verrà visualizzata la pagina di scelta MFA con il nome descrittivo.

Quando si immette adfabric nella pagina di autenticazione MFA, verrà visualizzato un accesso riuscito.

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

Screenshot of the M F A successful sign in page.

Vedi anche

Risorse aggiuntive

Metodi di autenticazione aggiuntivi

Gestire i rischi con l'autenticazione a più fattori aggiuntiva per le applicazioni con esigenze particolari