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

Artigo
2025-04-30
Aplica-se a: ✅ Windows Server 2025, ✅ Windows Server 2022, ✅ Windows Server 2019, ✅ Windows Server 2016

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.

Aviso

O exemplo que você pode criar aqui é apenas para fins educacionais. Essas instruções são para a implementação mais simples e mínima possível para expor os elementos necessários do modelo. Não há nenhum back-end de autenticação, processamento de erros ou dados de configuração.

Configurar a caixa 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 ser direcionado ao .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:

DLL de referência	Onde encontrá-lo	Obrigatório para
Microsoft.IdentityServer.Web.dll	A dll está localizada em %windir%\ADFS em um servidor Windows Server 2012 R2 no qual o AD FS foi instalado. Essa dll deve ser copiada para o computador de desenvolvimento e uma referência explícita criada no projeto.	Tipos de interface, incluindo IAuthenticationContext, IProofData

Criar o provedor

No Visual Studio 2012: Escolha Arquivo-Novo-Projeto>>...
Selecione Biblioteca de Classes e verifique se o .NET 4.5 está definido como o destino.
Faça uma cópia de Microsoft.IdentityServer.Web.dll de %windir%\ADFS no servidor Windows Server 2012 R2 em que o AD FS foi instalado e cole-o na pasta Projeto em seu computador de desenvolvimento.
No Gerenciador de Soluções, clique com o botão direito do mouse em Referências e Adicionar Referência...
Navegue até a cópia local do Microsoft.IdentityServer.Web.dll e Adicione...
Clique em OK para confirmar a nova referência:

Agora você estará pronto para resolver todos os tipos necessários para o provedor.
Adicione uma nova classe ao seu projeto (clique com o botão direito do mouse em seu projeto, Adicionar... Classe...) e dê a ele um nome como MyAdapter, mostrado abaixo:

No novo arquivo MyAdapter.cs, 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
        }

    }
}

Ainda não estamos prontos para construir... há mais duas interfaces a serem concluídas.

Adicione mais duas classes ao projeto: uma é para os metadados e outra para o formulário de apresentação. Você pode adicioná-los no mesmo arquivo que a classe acima.
```
class MyMetadata : IAuthenticationAdapterMetadata
{

}

class MyPresentationForm : IAdapterPresentationForm
{

}
```

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 do mouse – Ir para Definição) no IAuthenticationAdapter para ver o conjunto de membros de interface necessários.

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

Substitua todo o conteúdo da classe 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";
    }
}

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

}

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>

Em seguida, selecione Project-Add>Component... Arquivo recursos e nomeie o arquivo como Recursos, e clique em Adicionar:
Em seguida, no arquivo Resources.resx , escolha Adicionar Recurso... Adicionar arquivo existente. Navegue até o arquivo de texto (contendo o fragmento html) que você salvou acima.

Verifique se o código GetFormHtml resolve o nome do novo recurso corretamente pelo prefixo de nome do arquivo de recursos (arquivo.resx) seguido pelo nome do recurso em si:
```
public string GetFormHtml(int lcid)
{
    string htmlTemplate = Resources.MfaFormHtml; //Resxfilename.resourcename
    return htmlTemplate;
}
```

Agora você poderá criar o build.

Construir o adaptador

O adaptador deve ser integrado a um assembly .NET fortemente nomeado que possa ser instalado no GAC no Windows. Para fazer isso em um projeto do Visual Studio, conclua as seguintes etapas:

Clique com o botão direito do mouse no nome do projeto no Gerenciador de Soluções e clique em Propriedades.
Na guia Assinatura, marque Assinar o assembly e escolha <Novo…> em Escolher um arquivo de chave de nome forte: insira um nome de arquivo de chave e senha e clique em OK. Em seguida, verifique se a opção Assinar o assembly está marcada e se Somente sinal de atraso está desmarcada. A página Assinatura de propriedades será semelhante a esta:
Em seguida, crie a solução.

Implantar o adaptador no computador de teste do AD FS

Antes que um provedor externo possa ser invocado pelo AD FS, ele deve ser registrado no sistema. Os provedores de adaptador devem fornecer um instalador que execute as ações de instalação necessárias, incluindo a instalação no GAC, e o instalador deve dar suporte ao registro 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 habilitar o teste e a depuração.

Preparar o computador de teste do AD FS

Copie arquivos e adicione ao GAC.

Verifique se você tem um computador ou máquina virtual do Windows Server 2012 R2.
Instale o serviço de função do AD FS e configure um farm com, no mínimo, 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.
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 um computador Windows 8. Você precisará do arquivo gacutil.exe em si e do 1033, en-USe da outra pasta de recursos localizada abaixo do local das Ferramentas do NETFX 4.0 .
Copie os arquivos do provedor (um ou mais arquivos .dll assinados com nome forte) para a mesma pasta onde está gacutil.exe (o local é apenas para conveniência)
Adicione seus arquivos .dll ao GAC em cada servidor de federação do AD FS no farm:

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

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

Registrar seu provedor no AD FS

Depois que 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 o 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):

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

Em que 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 fornecido como AnyNameYouWish acima.
Reinicie o serviço do AD FS (usando o snap-in dos Serviços Windows, por exemplo).
Execute o seguinte comando: Get-AdfsAuthenticationProvider.

Isso indica que seu provedor é um dos listados no sistema.

Exemplo:
```
$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 do 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 seu adaptador

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

Abra o snap-in de Gerenciamento do AD FS (no menu Ferramentas do Gerenciador de Servidores).
Clique em Políticas de Autenticação.
No painel central, em Autenticação Multifator, clique no link Editar à direita das Configurações Globais.
Em Selecionar métodos de autenticação adicionais na parte inferior da página, marque a caixa para o AdminName do seu provedor. Clique em Aplicar.
Para fornecer um "gatilho" para invocar a MFA usando o adaptador, em Locais , verifique a Extranet e a Intranet, por exemplo. Clique em OK. (Para configurar gatilhos por parte confiável, consulte "Criar a política de autenticação usando o Windows PowerShell" abaixo.)
Verifique os resultados usando os seguintes comandos:

Primeiro, use Get-AdfsGlobalAuthenticationPolicy. Você deve ver o nome do seu 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 da sua seleção de política na interface do usuário do administrador.

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

Primeiro, habilite o provedor na política global:
```
Set-AdfsGlobalAuthenticationPolicy -AdditionalAuthenticationProvider “YourAuthProviderName”`
```
Observação

Observe que o valor fornecido para o parâmetro AdditionalAuthenticationProvider corresponde ao valor que você forneceu para o parâmetro “Name” no cmdlet Register-AdfsAuthenticationProvider acima e à propriedade “Name” da saída do cmdlet Get-AdfsAuthenticationProvider.
```
Set-AdfsGlobalAuthenticationPolicy –AdditionalAuthenticationProvider “MyMFAAdapter”`
```

Em seguida, configure regras globais ou específicas de terceira parte confiável para disparar 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 a MFA nas solicitações externas para uma terceira 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 seu adaptador

Por fim, execute as etapas abaixo para testar o adaptador:

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 torna sua demonstração mais fácil de autenticar como um usuário específico)
1. No snap-in do AD FS, em Políticas de Autenticação, na área de Autenticação Primária , clique em Editar ao lado de Configurações Globais.
  1. Ou, então, basta clicar na guia Primário na interface do usuário da Política de multifator.
Verifique se a Autenticação de Formulários é a única opção verificada para o método de autenticação extranet e intranet. Clique em OK.
Abra a página html de logon iniciada pelo IDP (https://< fsname>/adfs/ls/idpinitiatedsignon.htm) e entre como um usuário válido do AD em seu ambiente de teste.
Insira credenciais para autenticação primária.
Você verá a página de formulários da MFA com exemplos de perguntas de desafio ser exibida.

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

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

Atualizar o adaptador para autenticação bem-sucedida

Mas espere: seu exemplo de adaptador nunca será autenticado com sucesso. Isso ocorre porque nada no código retorna nulo para TryEndAuthentication.

Ao concluir os procedimentos acima, você criou uma implementação básica do adaptador e a adicionou a um servidor do AD FS. Você pode obter a página de formulários MFA, mas ainda não pode realizar a autenticação porque ainda não colocou a lógica correta na implementação tryEndAuthentication. Então, vamos adicioná-la.

Lembre-se da sua implementação de 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 utilitário simples em 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 conforme 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ê precisa atualizar o adaptador na caixa de teste. Primeiro você deve desfazer a política do AD FS, depois cancelar o registro do AD FS e reiniciar o AD FS, depois remover o .dll do GAC e, em seguida, 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 no computador do AD FS de teste

Limpar política do AD FS

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

política clara

Cancelar o registro do provedor (Windows PowerShell)

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

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

O valor que você transmite para “Name” é o mesmo valor de “Name” fornecido ao cmdlet Register-AdfsAuthenticationProvider. É também a propriedade “Name” que é saída de Get-AdfsAuthenticationProvider.

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

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

Remover o assembly do GAC

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

Exemplo:C:>.gacutil.exe /l mfaadapter
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

Cole a .dll atualizada localmente primeiro. C:>.gacutil.exe /if .MFAAdapter.dll

Exibir o assembly no GAC (linha de comando)

C:> .gacutil.exe /l mfaadapter

Registrar seu provedor no 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”
Reinicie o serviço do AD FS.

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

Abra o snap-in de Gerenciamento do AD FS (no menu Ferramentas do Gerenciador de Servidores).
Clique em Políticas de Autenticação.
Em Autenticação Multifator, clique no link Editar à direita das Configurações Globais.
Em Selecionar métodos de autenticação adicionais, marque a caixa para o AdminName do seu provedor. Clique em Aplicar.
Para fornecer um "gatilho" para invocar a MFA usando o adaptador, em Locais, marque as opções Extranet e Intranet, por exemplo. Clique em OK.

Autenticar com MFA usando seu adaptador

Por fim, execute as etapas abaixo para testar o adaptador:

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 de Autenticação Primária , clique em Editar ao lado de Configurações Globais.
  1. Ou, então, basta clicar na guia Primário na interface do usuário da Política de multifator.
Verifique se a Autenticação de Formulários é a única opção verificada para o método de autenticação extranet e intranet . Clique em OK.
Abra a página html de logon iniciada pelo IDP (https://< fsname>/adfs/ls/idpinitiatedsignon.htm) e entre como um usuário válido do AD em seu ambiente de teste.
Insira as credenciais para autenticação primária.
Você verá a página de formulários da MFA com o exemplo de texto de desafio ser exibida.
1. Se você tiver mais de um adaptador configurado, verá a página de escolha da MFA com seu nome amigável.

Você verá uma entrada bem-sucedida ao inserir adfabric na página de autenticação da MFA.

Captura de tela da página de formulários da MFA com um exemplo de texto de desafio.

Captura de tela da página de entrada bem-sucedida da MFA.

Consulte Também

Outros recursos

Métodos de autenticação adicionais

Gerenciar riscos com autenticação multifator adicional para aplicativos confidenciais

Compartilhar via

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

Configurar a caixa de desenvolvimento

Criar o provedor

Construir o adaptador

Implantar o adaptador no computador de teste do AD FS

Preparar o computador de teste do AD FS

Registrar seu provedor no AD FS

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

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

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

Autenticar com MFA usando seu adaptador

Atualizar o adaptador para autenticação bem-sucedida

Implantar e configurar o adaptador atualizado no computador do AD FS de teste

Limpar política do AD FS

Cancelar o registro do provedor (Windows PowerShell)

Remover o assembly do GAC

Adicionar o assembly atualizado ao GAC

Exibir o assembly no GAC (linha de comando)

Registrar seu provedor no AD FS

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

Autenticar com MFA usando seu adaptador

Consulte Também

Outros recursos

Comentários

Recursos adicionais