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

Artigo
02/13/2024

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, confira Métodos de autenticação adicionais.

Aviso

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

Como configurar a caixa de desenvolvimento

Este passo a passo usa o Visual Studio 2012. O projeto pode ser criado com qualquer ambiente de desenvolvimento que possa criar uma classe .NET para o Windows. O projeto precisa 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 só referência necessária para o projeto:

DLL de referência	Onde encontrá-las	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 precisa ser copiada para o computador de desenvolvimento, e uma referência explícita precisa ser criada no projeto.	Tipos de interface, incluindo IAuthenticationContext e 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 do computador de desenvolvimento.
Em Gerenciador de Soluções, clique com o botão direito do mouse em Referências e Adicionar Referência…
Procure a cópia local de Microsoft.IdentityServer.Web.dll e escolha Adicionar…
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 projeto (clique com o botão direito do mouse no seu projeto, Adicionar… Classe…) e dê a ele um nome como MyAdapter, conforme 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 criar… Faltam mais duas interfaces.

Adicione mais duas classes ao seu projeto: uma é para os metadados e a outra para o formulário de apresentação. Você pode adicioná-las ao mesmo arquivo da 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ê conseguirá usar F12 (clique com o botão direito do mouse e escolha Ir para Definição) em IAuthenticationAdapter para ver o conjunto de membros de interface necessários.

Em seguida, você poderá executar uma implementação deles.

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 corrigir isso em um minuto, mas primeiro vamos adicionar as instruções de retorno finais necessárias, com base nos tipos recém-implementados, à classe MyAdapter inicial. Para fazer isso, adicione o seguinte à implementação de 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 de HTML. Crie um 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 Projeto->Adicionar Componente… arquivo de Recursos, dê ao arquivo o nome Recursos e clique em Adicionar:
Em seguida, no arquivo Resources.resx, escolha Adicionar Recurso…Adicionar arquivo existente. Procure o arquivo de texto (que contém o fragmento de 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 do nome do recurso em si:
```
public string GetFormHtml(int lcid)
{
    string htmlTemplate = Resources.MfaFormHtml; //Resxfilename.resourcename
    return htmlTemplate;
}
```

Agora você poderá criar o build.

Criar 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, compile a solução.

Implantar o adaptador no computador de teste do AD FS

Para que um provedor externo seja invocado pelo AD FS, ele precisa ser registrado no sistema. Os provedores de adaptador precisam fornecer um instalador que execute as ações de instalação necessárias, incluindo a instalação no GAC, e o instalador precisa 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 os arquivos e adicione-os ao GAC.

Verifique se você tem um computador Windows Server 2012 R2 ou uma máquina virtual.
Instale o serviço de função do AD FS e configure um farm com, no mínimo, um nó.

Para ver as etapas detalhadas para configurar um servidor de federação em um ambiente de laboratório, confira o Guia de implantação do AD FS do Windows Server 2012 R2.
Copie as ferramentas do Gacutil.exe para o servidor.

O Gacutil.exe pode ser encontrado em %homedrive%Program Files (x86)Microsoft SDKsWindowsv8.0AbinNETFX 4.0 Tools em um computador Windows 8. Você precisará do próprio arquivo gacutil.exe e de 1033, de en-US e 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 com sinal de nome forte) para o mesmo local de pasta do gacutil.exe (o local serve apenas para conveniência)
Adicione seus arquivos .dll ao GAC em cada servidor de federação do AD FS no farm:

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

Para ver 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 um farm de servidores de federação que usa o Banco de Dados Interno do Windows, precisará 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 Serviços Windows, por exemplo).
Execute o seguinte comando: Get-AdfsAuthenticationProvider.

Isso mostra seu provedor como um dos provedores 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 no seu ambiente do AD FS, execute 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 Gerenciamento do AD FS

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

Primeiro, use Get-AdfsGlobalAuthenticationPolicy. Você verá o nome do provedor como um dos valores de AdditionalAuthenticationProvider.

Use Get-AdfsAdditionalAuthenticationRule. Você verá as regras para Extranet e da Intranet configuradas como resultado da 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 fornecido 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: criar uma regra global para exigir a MFA nas 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 terceiras 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-se com a 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 da sua 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, então, basta clicar na guia Primário na interface do usuário da Política de multifator.
Verifique se Autenticação de Formulários é a única opção marcada para o método de autenticação Extranet e Intranet. Clique em OK.
Abra a página HTML do logon iniciado pelo IdP (https://<fsname>/adfs/ls/idpinitiatedsignon.htm) e entre como um usuário válido do AD no seu ambiente de teste.
Insira as credenciais da 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 em BeginAuthentication e TryEndAuthentication. Observe como BeginAuthentication é executado quando o usuário entra pela primeira vez no formulário da MFA, enquanto TryEndAuthentication é disparado em cada Envio do formulário.

Atualizar o adaptador para uma 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 da MFA, mas ainda não pode se autenticar porque não colocou a lógica correta na sua implementação de 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á-la para que ela nem sempre retorne MyPresentationForm(). Para isso, você pode criar um método utilitário simples dentro da 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 mostrado 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ê precisa desfazer a política do AD FS, cancelar o registro do AD FS e reiniciar o AD FS, remover a .dll do GAC e adicionar a nova .dll ao GAC, registrá-la no AD FS, reiniciar o AD FS e reconfigurar a política do AD FS.

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

Limpar política do AD FS

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

clear policy

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ê precisa remover o provedor do AdfsGlobalAuthenticationPolicy (desmarcando as caixas de seleção que marcou no snap-in Gerenciamento do AD FS ou usando o Windows PowerShell).

O serviço do AD FS precisa 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 Gerenciamento do AD FS (no menu Ferramentas do Gerenciador do Servidor).
Clique em Políticas de Autenticação.
Em Autenticação Multifator, clique no link Editar à direita de Configurações Globais.
Em Selecionar métodos de autenticação adicionais, marque a caixa AdminName do provedor. Clique em Aplicar.
Para fornecer um “gatilho” para invocar a MFA usando o adaptador, em Locais, marque Extranet e Intranet, por exemplo. Clique em OK.

Autenticar-se com a 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 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, então, basta clicar na guia Primário na interface do usuário da Política de multifator.
Verifique se Autenticação de Formulários é a única opção marcada para o método de autenticação Extranet e Intranet. Clique em OK.
Abra a página HTML do logon iniciado pelo IdP (https://<fsname>/adfs/ls/idpinitiatedsignon.htm) e entre como um usuário válido do AD no seu ambiente de teste.
Insira as credenciais da 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.

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

Screenshot of the M F A successful sign in page.

Consulte Também

Outros recursos

Métodos de autenticação adicionais

Gerenciar riscos com Autenticação Multifator adicional para aplicativos confidenciais

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

Como configurar a caixa de desenvolvimento

Criar o provedor

Criar 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 o 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-se com a MFA usando seu adaptador

Atualizar o adaptador para uma autenticação bem-sucedida

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

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-se com a MFA usando seu adaptador

Consulte Também

Outros recursos

Recursos adicionais