Creare un metodo di autenticazione personalizzato per AD FS in Windows Server

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.

Configurazione della casella di sviluppo

Questa guida dettagliata utilizza 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:

Creare il provider

1. In Visual Studio 2012: Scegliere File-Nuovo-Progetto >>...

2. Selezionare Libreria di classi e assicurarsi di avere come destinazione .NET 4.5.

   

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

4. In Esplora soluzioni fare clic con il pulsante destro del mouse su Riferimenti e Aggiungi riferimento...

5. Passare alla copia locale di Microsoft.IdentityServer.Web.dll e Aggiungi...

6. Fare clic su OK per confermare il nuovo riferimento:

   

   Ora dovresti essere configurato per risolvere tutti i tipi richiesti dal provider.

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

   

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

9. Non siamo ancora pronti a realizzare... ci sono ancora due interfacce da completare.

   Aggiungere due altre 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
   {
   
   }
   

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

    Ora dovresti essere in grado di premere F12 (fare clic con il tasto destro del mouse – Vai a definizione) su IAuthenticationAdapter per visualizzare il set di membri dell'interfaccia necessari.

    Successivamente, è possibile eseguire un'implementazione di queste.

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

12. Nota il 'todo' per l'elemento Resources.FormPageHtml sopra. Puoi correggerlo in un minuto, ma prima aggiungiamo le istruzioni di ritorno finali richieste, basate sui tipi appena implementati, alla tua classe iniziale MyAdapter. 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();
        }
    
    }
    

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

14. Quindi, selezionare > e denominare il file Risorse, quindi fare clic su Aggiungi:

    

15. Quindi, all'interno del file 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;
    }
    

Ora dovrebbe essere possibile compilare.

Compilare l'adapter

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

1. Fare clic con il pulsante destro del mouse sul nome del progetto in Esplora soluzioni e scegliere Proprietà.

2. 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 Solo ritardo nella firma non sia selezionato. La pagina Firma delle proprietà dovrebbe apparire in questo modo:

   

3. Compilare quindi la soluzione.

Distribuire l'adapter sulla macchina 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 la macchina AD FS di test

Copiare i file e aggiungerli alla GAC.

1. Assicurarsi di avere un computer o una macchina virtuale Windows Server 2012 R2.

2. Installare il servizio ruolo di 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.

3. Copiare gli strumenti Gacutil.exe sul server.

   Gacutil.exe si trova in %homedrive%Program Files (x86)Microsoft SDKsWindowsv8.0AbinNETFX 4.0 Tools su un computer Windows 8. Sarà necessario il file gacutil.exe stesso e il 1033, en-USe l'altra cartella delle risorse localizzate sotto il percorso degli strumenti NETFX 4.0 .

4. Copiare i file del provider (uno o più file con nome sicuro firmato .dll) nello stesso percorso della cartella di gacutil.exe (il percorso è solo per praticità)

5. Aggiungi i tuoi file .dll alla GAC su ogni server di federazione 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 tuo 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):

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

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

   Il tuo provider esterno verrà registrato in AD FS, con il nome che hai fornito come AnyNameYouWish sopra.

2. Riavviare il servizio AD FS, ad esempio usando lo snap-in dei servizi di Windows.

3. Eseguire il comando seguente: Get-AdfsAuthenticationProvider.

   Questo mostra il tuo 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 tuo provider come uno dei provider nel sistema.

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

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

1. Aprire lo snap-in Gestione AD FS dal menu Strumenti di Server Manager.

2. Fare clic su Criteri di autenticazione.

3. Nel riquadro centrale, in Multi-Factor Authentication, fare clic sul collegamento Modifica a destra di Impostazioni globali.

4. In Seleziona metodi di autenticazione aggiuntivi nella parte inferiore della pagina selezionare la casella AdminName del provider. Fare clic su Applica.

5. Per fornire un "trigger" per richiamare l'autenticazione a più fattori usando l'adattatore, controllare, ad esempio, in Percorsi 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.

6. Controllare i risultati usando i comandi seguenti:

   Per prima cosa, Get-AdfsGlobalAuthenticationPolicy. Il nome del provider dovrebbe essere visualizzato come uno dei valori AdditionalAuthenticationProvider.

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

1. Per prima cosa, abilita il provider nella politica globale.

   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 menzionato sopra e alla proprietà "Name" dall'output del cmdlet Get-AdfsAuthenticationProvider.

   Set-AdfsGlobalAuthenticationPolicy –AdditionalAuthenticationProvider “MyMFAAdapter”`
   

2. Configurare quindi regole globali o specifiche del soggetto affidatario per attivare l'autenticazione a più fattori (MFA):

   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 MFA per richiedere l'autenticazione a più fattori per le richieste esterne a una parte fidata specifica. Nota: I singoli provider non possono essere connessi a singole parti fiduciarie 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:

1. 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 dell'interfaccia della politica a più fattori.

2. Verificare che l'autenticazione basata su form sia l'unica opzione selezionata sia per Extranet che per il metodo di autenticazione Intranet. Fare clic su OK.

3. Aprire la pagina HTML di accesso avviata da IDP (https://<fsname>/adfs/ls/idpinitiatedsignon.htm) ed effettuare l'accesso come utente valido di Active Directory nell'ambiente di test.

4. Immettere le credenziali per l'autenticazione primaria.

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

Ricorda 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 .dll dalla GAC, quindi aggiungere il nuovo .dll alla GAC, quindi registrarlo 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 la policy 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.

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

1. Per prima cosa, usare il comando seguente per trovare il nome forte completo qualificato dell'elemento:C:>.gacutil.exe /l <yourAdapterAssemblyName>

   Esempio:C:>.gacutil.exe /l mfaadapter

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

Assicurati di incollare localmente prima il .dll aggiornato. C:>.gacutil.exe /if .MFAAdapter.dll

Visualizzare l'assembly nella Global Assembly Cache (riga di comando)

C:> .gacutil.exe /l mfaadapter

Registrare il tuo provider in AD FS

1. PS C:>$typeName = "MFAadapter.MyAdapter, MFAadapter, Version=1.0.0.1, Culture=neutral, PublicKeyToken=e675eb33c62805a0, processorArchitecture=MSIL”

2. PS C:>Register-AdfsAuthenticationProvider -TypeName $typeName -Name “MyMFAAdapter1”

3. Riavviare il servizio AD FS.

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

1. Aprire lo snap-in Gestione AD FS dal menu Strumenti di Server Manager.

2. Fare clic su Criteri di autenticazione.

3. In Multi-Factor Authentication fare clic sul collegamento Modifica a destra di Impostazioni globali.

4. In Seleziona metodi di autenticazione aggiuntivi, seleziona la casella per AdminName del provider. Fare clic su Applica.

5. Per fornire un "trigger" per richiamare l'autenticazione a più fattori usando l'adattatore, selezionare, ad esempio, sia Extranet che Intranet nella sezione Percorsi. Fare clic su OK.

Eseguire l'autenticazione con MFA usando l'adapter

Infine, seguire questa procedura per testare l'adattatore:

1. 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 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 dei criteri a più fattori.

2. Verificare che l'autenticazione basata su form sia l'unica opzione selezionata sia per Extranet che per il metodo di autenticazione Intranet . Fare clic su OK.

3. Aprire la pagina HTML di accesso avviata da IDP (https://<fsname>/adfs/ls/idpinitiatedsignon.htm) ed effettuare l'accesso come utente valido di Active Directory nell'ambiente di test.

4. Immettere le credenziali per l'autenticazione primaria.

5. Dovresti vedere la pagina dei moduli MFA con il testo della sfida di esempio.

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

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

Vedere anche

Altre risorse

Metodi di autenticazione aggiuntivi

gestire i rischi con l'autenticazione a più fattori aggiuntiva per le applicazioni sensibili