Criar um método de autenticação personalizado para o AD FS no Windows Server

Este passo a passo fornece instruções para implementar um método de autenticação personalizado para o AD FS no Windows Server 2012 R2. Para obter mais informações, consulte Métodos de autenticação adicionais.

Configurando o ambiente de desenvolvimento

Este passo a passo usa o Visual Studio 2012. O projeto pode ser criado usando qualquer ambiente de desenvolvimento que possa criar uma classe .NET para Windows. O projeto deve ter como destino o .NET 4.5 porque os métodos BeginAuthentication e TryEndAuthentication usam o tipo System.Security.Claims.Claim, parte do .NET Framework versão 4.5. Há uma referência necessária para o projeto:

Criar o provedor

1. ** No Visual Studio 2012: Escolha Ficheiro->Novo...->Projeto...

2. Selecione Biblioteca de Classes e garanta que está configurado para .NET 4.5.

   

3. Faça uma cópia do Microsoft.IdentityServer.Web.dll do %windir%\ADFS no servidor Windows Server 2012 R2 onde o AD FS foi instalado e cole-o na pasta Project na máquina de desenvolvimento.

4. No Gerenciador de Soluções, clique com o botão direito do mouse em Referências e Adicionar Referência...

5. Navegue até a sua cópia local do Microsoft.IdentityServer.Web.dll e Adicionar...

6. Clique em OK para confirmar a nova referência:

   

   Agora vocês devem estar preparados para resolver todos os tipos necessários para o provedor.

7. Adicione uma nova classe ao seu projeto (Clique com o botão direito do mouse em seu projeto, Adicionar... Classe...) e dê-lhe um nome como MyAdapter, mostrado abaixo:

   

8. No novo MyAdapter.cs de arquivo, substitua o código existente pelo seguinte:

   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. Ainda não estamos prontos para começar a construir... faltam duas interfaces.

   Adicione mais duas classes ao seu projeto: uma para os metadados e outra para o formulário de apresentação. Você pode adicioná-los dentro do mesmo arquivo que a classe acima.

   class MyMetadata : IAuthenticationAdapterMetadata
   {
   
   }
   
   class MyPresentationForm : IAdapterPresentationForm
   {
   
   }
   

10. Em seguida, você pode adicionar os membros necessários para cada um. Primeiro, os metadados (com comentários embutidos úteis)

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

    Agora você deve ser capaz de pressionar F12 (clique com o botão direito – Ir para Definição) em IAuthenticationAdapter para ver o conjunto de membros necessários da interface.

    Em seguida, você pode executar uma implementação destes.

11. Substitua todo o conteúdo da sua aula pelo seguinte:

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

    Em seguida, o formulário de apresentação:

    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. Observe a anotação 'por fazer' para o elemento Resources.FormPageHtml acima. Você pode corrigi-lo em um minuto, mas primeiro vamos adicionar as instruções de retorno finais necessárias, com base nos tipos recém-implementados, à sua classe MyAdapter inicial. Para fazer isso, adicione o seguinte à sua implementação IAuthenticationAdapter existente:

    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. Agora para o arquivo de recurso que contém o fragmento html. Crie um novo arquivo de texto na pasta do projeto com o seguinte conteúdo:

    <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. Em seguida, selecione Project-Add> Component... Recursos e nomeie o ficheiro Recursos, e clique em Adicionar:

    

15. Em seguida, no arquivo Resources.resx , escolha Adicionar recurso... Adicione um arquivo existente. Navegue até o arquivo de texto (que contém o fragmento html) que você salvou acima.

    Verifique se o código GetFormHtml resolve o nome do novo recurso corretamente pelo prefixo do nome do arquivo de recursos (arquivo .resx) seguido pelo nome do próprio recurso:

    public string GetFormHtml(int lcid)
    {
        string htmlTemplate = Resources.MfaFormHtml; //Resxfilename.resourcename
        return htmlTemplate;
    }
    

Agora você deve ser capaz de construir.

Construa o adaptador

O adaptador deve ser construído num assembly .NET com um nome forte, que possa ser instalado no GAC no Windows. Para conseguir isso em um projeto do Visual Studio, conclua as seguintes etapas:

1. Clique com o botão direito do mouse no nome do projeto no Gerenciador de Soluções e clique em Propriedades.

2. Na guia Assinatura, marque Assinar o assembly e escolha <Novo...> em Escolha um arquivo de chave de nome forte: insira um nome de arquivo de chave e senha e clique em OK. Em seguida, certifique-se que Assinar a montagem está assinalado e Assinar apenas com atraso está desassinalado. A página de propriedades Assinatura deve ter esta aparência:

   

3. Em seguida, crie a solução.

Implantar o adaptador na máquina de teste do AD FS

Antes que um provedor externo possa ser invocado pelo AD FS, ele deve ser registrado no sistema. Os fornecedores de adaptadores têm de fornecer um instalador que execute as ações de instalação necessárias, incluindo a instalação no GAC, e o instalador tem de suportar o registo no AD FS. Se isso não for feito, o administrador precisará executar as etapas do Windows PowerShell abaixo. Essas etapas podem ser usadas no laboratório para permitir a realização de testes e depuração.

Preparar a máquina de teste do AD FS

Copie arquivos e adicione ao GAC.

1. Verifique se você tem um computador ou máquina virtual com Windows Server 2012 R2.

2. Instale o serviço de função AD FS e configure uma fazenda com pelo menos um nó.

   Para obter etapas detalhadas para configurar um servidor de federação em um ambiente de laboratório, consulte o Guia de Implantação do AD FS do Windows Server 2012 R2.

3. Copie as ferramentas de Gacutil.exe para o servidor.

   Gacutil.exe pode ser encontrado em %homedrive%Program Files (x86)Microsoft SDKsWindowsv8.0AbinNETFX 4.0 Tools em uma máquina Windows 8. Você precisará do próprio arquivo gacutil.exe e das pastas 1033, en-US e de outros recursos localizados abaixo do local das Ferramentas NETFX 4.0.

4. Copie o(s) arquivo(s) do(s) provedor(es) (arquivos .dll com nome forte assinado, um ou mais) para a mesma pasta que contém gacutil.exe (o local é apenas por conveniência)

5. Adicione o(s) ficheiro(s) de .dll ao GAC em cada servidor de federação do AD FS na fazenda:

   Exemplo: usando a ferramenta de linha de comando GACutil.exe para adicionar uma dll ao GAC: C:>.gacutil.exe /if .<yourdllname>.dll

   Para visualizar a entrada resultante no GAC:C:>.gacutil.exe /l <yourassemblyname>

Registar o seu fornecedor no AD FS

Quando os pré-requisitos acima forem atendidos, abra uma janela de comando do Windows PowerShell no servidor de federação e insira os seguintes comandos (observe que, se você estiver usando um farm de servidores de federação que usa o Banco de Dados Interno do Windows, deverá executar esses comandos no servidor de federação primário do farm):

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

   Onde YourTypeName é o nome de tipo forte do .NET: "YourDefaultNamespace.YourIAuthenticationAdapterImplementationClassName, YourAssemblyName, Version=YourAssemblyVersion, Culture=neutral, PublicKeyToken=YourPublicKeyTokenValue, processorArchitecture=MSIL"

   Isso registrará seu provedor externo no AD FS, com o Nome que você forneceu como AnyNameYouWish acima.

2. Reinicie o serviço AD FS (usando o snap-in Serviços do Windows, por exemplo).

3. Execute o seguinte comando: Get-AdfsAuthenticationProvider.

   Isso mostra seu provedor como um dos provedores no sistema.

   Example:

   $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 você tiver o serviço de registro de dispositivo habilitado em seu ambiente AD FS, execute também o seguinte comando do PowerShell: net start drs

   Para verificar o provedor registrado, use o seguinte comando do PowerShell:Get-AdfsAuthenticationProvider.

   Isso mostra seu provedor como um dos provedores no sistema.

Criar a política de autenticação do AD FS que invoca o adaptador

Criar a política de autenticação usando o snap-in AD FS Management

1. Abra o snap-in de Gerenciamento do AD FS (no menu Ferramentas do Gerenciador do Servidor).

2. Clique em Políticas de autenticação.

3. No painel central, em Autenticação Multifator, clique no link Editar à direita de Configurações Globais.

4. Em Selecionar métodos de autenticação adicionais na parte inferior da página, selecione a caixa para AdminName do seu provedor. Clique em Aplicar.

5. Para fornecer um "gatilho" para invocar MFA usando seu adaptador, em Locais , marque Extranet e Intranet, por exemplo. Clique em OK. (Para configurar os triggers por parte confiável, consulte "Criar a política de autenticação usando o Windows PowerShell" abaixo.)

6. Verifique os resultados usando os seguintes comandos:

   Primeira utilização de Get-AdfsGlobalAuthenticationPolicy. Você deve ver o nome do provedor como um dos valores de Provedor de Autenticação Adicional.

   Em seguida, use Get-AdfsAdditionalAuthenticationRule. Você deve ver as regras para Extranet e Intranet configuradas como resultado de sua seleção de política na interface do usuário do administrador.

Criar a política de autenticação usando o Windows PowerShell

1. Primeiro, habilite o provedor na política global:

   Set-AdfsGlobalAuthenticationPolicy -AdditionalAuthenticationProvider “YourAuthProviderName”`
   

   Note

   Observe que o valor fornecido para o parâmetro AdditionalAuthenticationProvider corresponde ao valor fornecido para o parâmetro "Name" no cmdlet Register-AdfsAuthenticationProvider acima e à propriedade "Name" da saída Get-AdfsAuthenticationProvider cmdlet.

   Set-AdfsGlobalAuthenticationPolicy –AdditionalAuthenticationProvider “MyMFAAdapter”`
   

2. Em seguida, configure regras globais ou específicas de partes dependentes para acionar a MFA:

   Exemplo 1: para criar uma regra global para exigir MFA para solicitações externas:

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

   Exemplo 2: criar regras de MFA para exigir MFA em solicitações externas a uma parte confiável específica. (Observação: provedores individuais não podem ser conectados a partes confiáveis individuais no AD FS no 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" );'
   

Autenticar com MFA usando o adaptador

Finalmente, execute as etapas abaixo para testar o adaptador:

1. Verifique se o tipo de autenticação Primária global do AD FS está configurado como Autenticação de Formulários para Extranet e Intranet (isso facilita a autenticação da demonstração como um usuário específico)

   1. No snap-in do AD FS, em Políticas de Autenticação, na área Autenticação Primária , clique em Editar ao lado de Configurações Globais.

      1. Ou simplesmente clique no separador Principal da interface de utilizador da política multifator.

2. Verifique se a Autenticação de Formulários é a única opção marcada para o método de autenticação da Extranet e da Intranet. Clique em OK.

3. Abra a página HTML de logon iniciado pelo IDP (https://<fsname>/adfs/ls/idpinitiatedsignon.htm) e faça login como um utilizador válido do AD no seu ambiente de teste.

4. Insira credenciais para autenticação principal.

5. Deve ver a página de formulários de MFA onde aparecem exemplos de perguntas de desafio.

   Se você tiver mais de um adaptador configurado, você verá a página de escolha MFA com seu nome amigável acima.

   

   

Agora você tem uma implementação de trabalho da interface e você tem o conhecimento de como o modelo funciona. Você pode tentar como um exemplo extra definir pontos de interrupção no BeginAuthentication e no TryEndAuthentication. Observe como BeginAuthentication é executado quando o usuário entra pela primeira vez no formulário MFA, enquanto TryEndAuthentication é acionado em cada Envio do formulário.

Atualizar o adaptador para autenticação bem-sucedida

Mas espere – seu adaptador de exemplo nunca será autenticado com sucesso! Isso ocorre porque nada em seu código retorna null para TryEndAuthentication.

Ao concluir os procedimentos acima, você criou uma implementação básica do adaptador e a adicionou a um servidor AD FS. Você pode obter a página de formulários MFA, mas ainda não pode autenticar porque ainda não colocou a lógica correta em sua implementação TryEndAuthentication. Então, vamos acrescentar isso.

Recorde a sua implementação do 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();
}

Vamos atualizá-lo para que nem sempre retorne MyPresentationForm(). Para isso, você pode criar um método de utilidade simples dentro da sua 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;
    }
}

Em seguida, atualize TryEndAuthentication como abaixo:

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

Agora você tem que atualizar o adaptador na caixa de teste. Você deve primeiro desfazer a política do AD FS, depois cancelar o registro do AD FS e reiniciar o AD FS, remover o .dll do GAC, adicionar o novo .dll ao GAC, registrá-lo no AD FS, reiniciar o AD FS e reconfigurar a política do AD FS.

Implantar e configurar o adaptador atualizado em sua máquina AD FS de teste

Limpar a Política AD FS

Desmarque todas as caixas de seleção relacionadas à MFA na interface do usuário da MFA, mostrada abaixo, e clique em OK.

Cancelar registro do provedor (Windows PowerShell)

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

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

O valor que você passa para "Name" é o mesmo valor que "Name" que você forneceu ao cmdlet Register-AdfsAuthenticationProvider. É também a propriedade "Name" que é gerada por Get-AdfsAuthenticationProvider.

Antes de cancelar o registro de um provedor, você deve removê-lo do AdfsGlobalAuthenticationPolicy (desmarcando as caixas de seleção marcadas no snap-in de gerenciamento do AD FS ou usando o Windows PowerShell.)

O serviço AD FS deve ser reiniciado após esta operação.

Remover montagem do GAC

1. Primeiro, use o seguinte comando para encontrar o nome forte totalmente qualificado da entrada:C:>.gacutil.exe /l <yourAdapterAssemblyName>

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

2. Em seguida, use o seguinte comando para removê-lo do GAC:.gacutil /u “<output from the above command>”

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

Adicionar o assembly atualizado ao GAC

Certifique-se de colar o .dll atualizado localmente primeiro. C:>.gacutil.exe /if .MFAAdapter.dll

Visualizar montagem no GAC (linha de comandos)

C:> .gacutil.exe /l mfaadapter

Registar o seu fornecedor no 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. Reinicie o serviço AD FS.

Criar a política de autenticação usando o snap-in AD FS Management

1. Abra o snap-in de Gestão do AD FS (a partir do menu Ferramentas do Gestor de Servidor).

2. Clique em Políticas de autenticação.

3. Em Multi-Factor Authentication, clique no link Editar à direita de Configurações Globais.

4. Em Selecionar métodos de autenticação adicionais, selecione a caixa de seleção do AdminName do seu provedor. Clique em Aplicar.

5. Para fornecer um "gatilho" para invocar MFA usando seu adaptador, em Locais, marque Extranet e Intranet, por exemplo. Clique em OK.

Autenticar com MFA usando o adaptador

Finalmente, execute as etapas abaixo para testar o adaptador:

1. Verifique se o tipo de autenticação primária global do AD FS está configurado como Autenticação de Formulários para Extranet e Intranet (isso facilita a autenticação como um usuário específico).

   1. No snap-in de gerenciamento do AD FS, em Políticas de Autenticação, na área Autenticação Primária , clique em Editar ao lado de Configurações Globais.

      1. Ou simplesmente clique no separador Principal da UI da política multifator.

2. Verifique se a Autenticação de Formulários é a única opção marcada para o método de autenticação da Extranet e da Intranet . Clique em OK.

3. Abra a página HTML de logon iniciado pelo IDP (https://<fsname>/adfs/ls/idpinitiatedsignon.htm) e faça login como um utilizador válido do AD no seu ambiente de teste.

4. Insira as credenciais para autenticação principal.

5. Deve ver aparecer a página de formulários de MFA com o texto de exemplo do desafio.

   1. Se você tiver mais de um adaptador configurado, verá a página de escolha de MFA com seu nome amigável.

Você verá um login bem-sucedido ao inserir o adfabric na página de autenticação MFA.

Ver também

Outros recursos

Métodos de autenticação adicionais

Gerencie o risco com autenticação multifator adicional para aplicativos confidenciais